From 37c029dd152c1d5f2041c2d721df0470a0c21181 Mon Sep 17 00:00:00 2001
From: Glazomer <dan2000kr@gmail.com>
Date: Fri, 1 May 2020 16:45:52 +1000
Subject: [PATCH] refactor(core): made compose into independent file and
 re-exported it

---
 packages/core/.gitignore |   1 +
 packages/core/compose.ts | 153 ++++++++++++++++++++++++++++++++++++++
 packages/core/core.ts    | 154 +--------------------------------------
 3 files changed, 156 insertions(+), 152 deletions(-)
 create mode 100644 packages/core/compose.ts

diff --git a/packages/core/.gitignore b/packages/core/.gitignore
index d0318021..64095251 100644
--- a/packages/core/.gitignore
+++ b/packages/core/.gitignore
@@ -1 +1,2 @@
 core.d.ts
+compose.d.ts
diff --git a/packages/core/compose.ts b/packages/core/compose.ts
new file mode 100644
index 00000000..2e458bc4
--- /dev/null
+++ b/packages/core/compose.ts
@@ -0,0 +1,153 @@
+import { ComponentType, StatelessComponent } from 'react'
+
+export type ExtractProps<T> = T extends ComponentType<infer K> ? { [P in keyof K]: K[P] } : never
+export type HOC<T> = (WrappedComponent: ComponentType) => ComponentType<T>
+export type Wrapper<T> = HOC<T>
+export type Composition<T> = <U extends ComponentType<any>>(
+  fn: U,
+) => StatelessComponent<JSX.LibraryManagedAttributes<U, ExtractProps<U>> & T>
+
+export function compose<T1>(fn1: HOC<T1>): Composition<T1>
+
+export function compose<T1, T2>(fn1: HOC<T1>, fn2: HOC<T2>): Composition<T1 & T2>
+
+export function compose<T1, T2, T3>(
+  fn1: HOC<T1>,
+  fn2: HOC<T2>,
+  fn3: HOC<T3>,
+): Composition<T1 & T2 & T3>
+
+export function compose<T1, T2, T3, T4>(
+  fn1: HOC<T1>,
+  fn2: HOC<T2>,
+  fn3: HOC<T3>,
+  fn4: HOC<T4>,
+): Composition<T1 & T2 & T3 & T4>
+
+export function compose<T1, T2, T3, T4, T5>(
+  fn1: HOC<T1>,
+  fn2: HOC<T2>,
+  fn3: HOC<T3>,
+  fn4: HOC<T4>,
+  fn5: HOC<T5>,
+): Composition<T1 & T2 & T3 & T4 & T5>
+
+export function compose<T1, T2, T3, T4, T5, T6>(
+  fn1: HOC<T1>,
+  fn2: HOC<T2>,
+  fn3: HOC<T3>,
+  fn4: HOC<T4>,
+  fn5: HOC<T5>,
+  fn6: HOC<T6>,
+): Composition<T1 & T2 & T3 & T4 & T5 & T6>
+
+export function compose<T1, T2, T3, T4, T5, T6, T7>(
+  fn1: HOC<T1>,
+  fn2: HOC<T2>,
+  fn3: HOC<T3>,
+  fn4: HOC<T4>,
+  fn5: HOC<T5>,
+  fn6: HOC<T6>,
+  fn7: HOC<T7>,
+): Composition<T1 & T2 & T3 & T4 & T5 & T6 & T7>
+
+export function compose<T1, T2, T3, T4, T5, T6, T7, T8>(
+  fn1: HOC<T1>,
+  fn2: HOC<T2>,
+  fn3: HOC<T3>,
+  fn4: HOC<T4>,
+  fn5: HOC<T5>,
+  fn6: HOC<T6>,
+  fn7: HOC<T7>,
+  fn8: HOC<T8>,
+): Composition<T1 & T2 & T3 & T4 & T5 & T6 & T7 & T8>
+
+export function compose(...fns: Array<HOC<any>>): Composition<any>
+
+/**
+ * @param funcs higher order components
+ *
+ * @example
+ * ```ts
+ * import { compose } from '@bem-react/core';
+ *
+ * const Enhanced = compose(
+ *     withBemMod('Component', { size: 's' }),
+ *     withBemMod('Component', { theme: 'normal' }),
+ * )(Component);
+ * ```
+ */
+export function compose() {
+  // Use arguments instead of rest-arguments to get faster and more compact code.
+  const fns: any[] = [].slice.call(arguments)
+
+  return fns.reduce(
+    (a, b) => {
+      return function() {
+        return a(b.apply(0, arguments))
+      }
+    },
+    (arg: any) => arg,
+  )
+}
+
+export function composeU<T1>(fn1: HOC<T1>): Composition<T1>
+
+export function composeU<T1, T2>(fn1: HOC<T1>, fn2: HOC<T2>): Composition<T1 | T2>
+
+export function composeU<T1, T2, T3>(
+  fn1: HOC<T1>,
+  fn2: HOC<T2>,
+  fn3: HOC<T3>,
+): Composition<T1 | T2 | T3>
+
+export function composeU<T1, T2, T3, T4>(
+  fn1: HOC<T1>,
+  fn2: HOC<T2>,
+  fn3: HOC<T3>,
+  fn4: HOC<T4>,
+): Composition<T1 | T2 | T3 | T4>
+
+export function composeU<T1, T2, T3, T4, T5>(
+  fn1: HOC<T1>,
+  fn2: HOC<T2>,
+  fn3: HOC<T3>,
+  fn4: HOC<T4>,
+  fn5: HOC<T5>,
+): Composition<T1 | T2 | T3 | T4 | T5>
+
+export function composeU<T1, T2, T3, T4, T5, T6>(
+  fn1: HOC<T1>,
+  fn2: HOC<T2>,
+  fn3: HOC<T3>,
+  fn4: HOC<T4>,
+  fn5: HOC<T5>,
+  fn6: HOC<T6>,
+): Composition<T1 | T2 | T3 | T4 | T5 | T6>
+
+export function composeU<T1, T2, T3, T4, T5, T6, T7>(
+  fn1: HOC<T1>,
+  fn2: HOC<T2>,
+  fn3: HOC<T3>,
+  fn4: HOC<T4>,
+  fn5: HOC<T5>,
+  fn6: HOC<T6>,
+  fn7: HOC<T7>,
+): Composition<T1 | T2 | T3 | T4 | T5 | T6 | T7>
+
+export function composeU<T1, T2, T3, T4, T5, T6, T7, T8>(
+  fn1: HOC<T1>,
+  fn2: HOC<T2>,
+  fn3: HOC<T3>,
+  fn4: HOC<T4>,
+  fn5: HOC<T5>,
+  fn6: HOC<T6>,
+  fn7: HOC<T7>,
+  fn8: HOC<T8>,
+): Composition<T1 | T2 | T3 | T4 | T5 | T6 | T7 | T8>
+
+export function composeU(...fns: Array<HOC<any>>): Composition<any>
+
+export function composeU(...args: any[]) {
+  return compose(...args)
+}
diff --git a/packages/core/core.ts b/packages/core/core.ts
index 12a7ab39..6d1cc8c1 100644
--- a/packages/core/core.ts
+++ b/packages/core/core.ts
@@ -1,4 +1,4 @@
-import { ComponentType, StatelessComponent, createElement } from 'react'
+import { ComponentType, createElement } from 'react'
 import { cn, NoStrictEntityMods, ClassNameFormatter } from '@bem-react/classname'
 import { classnames } from '@bem-react/classnames'
 
@@ -127,154 +127,4 @@ export function withBemMod<T, U extends IClassNameProps = {}>(
   }
 }
 
-export type ExtractProps<T> = T extends ComponentType<infer K> ? { [P in keyof K]: K[P] } : never
-export type HOC<T> = (WrappedComponent: ComponentType) => ComponentType<T>
-export type Wrapper<T> = HOC<T>
-export type Composition<T> = <U extends ComponentType<any>>(
-  fn: U,
-) => StatelessComponent<JSX.LibraryManagedAttributes<U, ExtractProps<U>> & T>
-
-export function compose<T1>(fn1: HOC<T1>): Composition<T1>
-
-export function compose<T1, T2>(fn1: HOC<T1>, fn2: HOC<T2>): Composition<T1 & T2>
-
-export function compose<T1, T2, T3>(
-  fn1: HOC<T1>,
-  fn2: HOC<T2>,
-  fn3: HOC<T3>,
-): Composition<T1 & T2 & T3>
-
-export function compose<T1, T2, T3, T4>(
-  fn1: HOC<T1>,
-  fn2: HOC<T2>,
-  fn3: HOC<T3>,
-  fn4: HOC<T4>,
-): Composition<T1 & T2 & T3 & T4>
-
-export function compose<T1, T2, T3, T4, T5>(
-  fn1: HOC<T1>,
-  fn2: HOC<T2>,
-  fn3: HOC<T3>,
-  fn4: HOC<T4>,
-  fn5: HOC<T5>,
-): Composition<T1 & T2 & T3 & T4 & T5>
-
-export function compose<T1, T2, T3, T4, T5, T6>(
-  fn1: HOC<T1>,
-  fn2: HOC<T2>,
-  fn3: HOC<T3>,
-  fn4: HOC<T4>,
-  fn5: HOC<T5>,
-  fn6: HOC<T6>,
-): Composition<T1 & T2 & T3 & T4 & T5 & T6>
-
-export function compose<T1, T2, T3, T4, T5, T6, T7>(
-  fn1: HOC<T1>,
-  fn2: HOC<T2>,
-  fn3: HOC<T3>,
-  fn4: HOC<T4>,
-  fn5: HOC<T5>,
-  fn6: HOC<T6>,
-  fn7: HOC<T7>,
-): Composition<T1 & T2 & T3 & T4 & T5 & T6 & T7>
-
-export function compose<T1, T2, T3, T4, T5, T6, T7, T8>(
-  fn1: HOC<T1>,
-  fn2: HOC<T2>,
-  fn3: HOC<T3>,
-  fn4: HOC<T4>,
-  fn5: HOC<T5>,
-  fn6: HOC<T6>,
-  fn7: HOC<T7>,
-  fn8: HOC<T8>,
-): Composition<T1 & T2 & T3 & T4 & T5 & T6 & T7 & T8>
-
-export function compose(...fns: Array<HOC<any>>): Composition<any>
-
-/**
- * @param funcs higher order components
- *
- * @example
- * ```ts
- * import { compose } from '@bem-react/core';
- *
- * const Enhanced = compose(
- *     withBemMod('Component', { size: 's' }),
- *     withBemMod('Component', { theme: 'normal' }),
- * )(Component);
- * ```
- */
-export function compose() {
-  // Use arguments instead of rest-arguments to get faster and more compact code.
-  const fns: any[] = [].slice.call(arguments)
-
-  return fns.reduce(
-    (a, b) => {
-      return function() {
-        return a(b.apply(0, arguments))
-      }
-    },
-    (arg: any) => arg,
-  )
-}
-
-export function composeU<T1>(fn1: HOC<T1>): Composition<T1>
-
-export function composeU<T1, T2>(fn1: HOC<T1>, fn2: HOC<T2>): Composition<T1 | T2>
-
-export function composeU<T1, T2, T3>(
-  fn1: HOC<T1>,
-  fn2: HOC<T2>,
-  fn3: HOC<T3>,
-): Composition<T1 | T2 | T3>
-
-export function composeU<T1, T2, T3, T4>(
-  fn1: HOC<T1>,
-  fn2: HOC<T2>,
-  fn3: HOC<T3>,
-  fn4: HOC<T4>,
-): Composition<T1 | T2 | T3 | T4>
-
-export function composeU<T1, T2, T3, T4, T5>(
-  fn1: HOC<T1>,
-  fn2: HOC<T2>,
-  fn3: HOC<T3>,
-  fn4: HOC<T4>,
-  fn5: HOC<T5>,
-): Composition<T1 | T2 | T3 | T4 | T5>
-
-export function composeU<T1, T2, T3, T4, T5, T6>(
-  fn1: HOC<T1>,
-  fn2: HOC<T2>,
-  fn3: HOC<T3>,
-  fn4: HOC<T4>,
-  fn5: HOC<T5>,
-  fn6: HOC<T6>,
-): Composition<T1 | T2 | T3 | T4 | T5 | T6>
-
-export function composeU<T1, T2, T3, T4, T5, T6, T7>(
-  fn1: HOC<T1>,
-  fn2: HOC<T2>,
-  fn3: HOC<T3>,
-  fn4: HOC<T4>,
-  fn5: HOC<T5>,
-  fn6: HOC<T6>,
-  fn7: HOC<T7>,
-): Composition<T1 | T2 | T3 | T4 | T5 | T6 | T7>
-
-export function composeU<T1, T2, T3, T4, T5, T6, T7, T8>(
-  fn1: HOC<T1>,
-  fn2: HOC<T2>,
-  fn3: HOC<T3>,
-  fn4: HOC<T4>,
-  fn5: HOC<T5>,
-  fn6: HOC<T6>,
-  fn7: HOC<T7>,
-  fn8: HOC<T8>,
-): Composition<T1 | T2 | T3 | T4 | T5 | T6 | T7 | T8>
-
-export function composeU(...fns: Array<HOC<any>>): Composition<any>
-
-export function composeU(...args: any[]) {
-  return compose(...args)
-}
+export * from './compose'