@poppinss/utils 4.0.4 → 5.0.0

package/build/src/Helpers/compose.d.ts

@@ -1,8 +1,4 @@
 declare type Constructor = new (...args: any[]) => any;
-/**
- * Converting unions to intersection
- */
-declare type UnionToIntersection<T> = (T extends any ? (x: T) => any : never) extends (x: infer R) => any ? R : never;
 /**
  * Normalizes constructor to work with mixins. There is an open bug for mixins
  * to allow constructors other than `...args: any[]`
@@ -12,10 +8,21 @@ declare type UnionToIntersection<T> = (T extends any ? (x: T) => any : never) ex
 export declare type NormalizeConstructor<T extends Constructor> = {
     new (...args: any[]): InstanceType<T>;
 } & Omit<T, 'constructor'>;
+export interface UnaryFunction<T, R> {
+    (source: T): R;
+}
 /**
  * Compose a class by applying mixins to it.
  * The code is inspired by https://justinfagnani.com/2015/12/21/real-mixins-with-javascript-classes/, its
  * just that I have added the support for static types too.
  */
-export declare const compose: <SuperClass extends Constructor, M extends ((superclass: SuperClass) => Constructor)[]>(superclass: SuperClass, ...mixins: M) => SuperClass & UnionToIntersection<ReturnType<M[number]>>;
+export declare function compose<T extends Constructor, A>(superclass: T, mixin: UnaryFunction<T, A>): A;
+export declare function compose<T extends Constructor, A, B>(superclass: T, mixin: UnaryFunction<T, A>, mixinB: UnaryFunction<A, B>): B;
+export declare function compose<T extends Constructor, A, B, C>(superclass: T, mixin: UnaryFunction<T, A>, mixinB: UnaryFunction<A, B>, mixinC: UnaryFunction<B, C>): C;
+export declare function compose<T extends Constructor, A, B, C, D>(superclass: T, mixin: UnaryFunction<T, A>, mixinB: UnaryFunction<A, B>, mixinC: UnaryFunction<B, C>, mixinD: UnaryFunction<C, D>): D;
+export declare function compose<T extends Constructor, A, B, C, D, E>(superclass: T, mixin: UnaryFunction<T, A>, mixinB: UnaryFunction<A, B>, mixinC: UnaryFunction<B, C>, mixinD: UnaryFunction<C, D>, mixinE: UnaryFunction<D, E>): E;
+export declare function compose<T extends Constructor, A, B, C, D, E, F>(superclass: T, mixin: UnaryFunction<T, A>, mixinB: UnaryFunction<A, B>, mixinC: UnaryFunction<B, C>, mixinD: UnaryFunction<C, D>, mixinF: UnaryFunction<E, F>): F;
+export declare function compose<T extends Constructor, A, B, C, D, E, F, G>(superclass: T, mixin: UnaryFunction<T, A>, mixinB: UnaryFunction<A, B>, mixinC: UnaryFunction<B, C>, mixinD: UnaryFunction<C, D>, mixinF: UnaryFunction<E, F>, mixinG: UnaryFunction<F, G>): G;
+export declare function compose<T extends Constructor, A, B, C, D, E, F, G, H>(superclass: T, mixin: UnaryFunction<T, A>, mixinB: UnaryFunction<A, B>, mixinC: UnaryFunction<B, C>, mixinD: UnaryFunction<C, D>, mixinF: UnaryFunction<E, F>, mixinG: UnaryFunction<F, G>, mixinH: UnaryFunction<G, H>): H;
+export declare function compose<T extends Constructor, A, B, C, D, E, F, G, H, I>(superclass: T, mixin: UnaryFunction<T, A>, mixinB: UnaryFunction<A, B>, mixinC: UnaryFunction<B, C>, mixinD: UnaryFunction<C, D>, mixinF: UnaryFunction<E, F>, mixinG: UnaryFunction<F, G>, mixinH: UnaryFunction<G, H>, mixinI: UnaryFunction<H, I>): I;
 export {};

package/build/src/Helpers/compose.js

@@ -9,12 +9,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.compose = void 0;
-/**
- * Compose a class by applying mixins to it.
- * The code is inspired by https://justinfagnani.com/2015/12/21/real-mixins-with-javascript-classes/, its
- * just that I have added the support for static types too.
- */
-const compose = (superclass, ...mixins) => {
+function compose(superclass, ...mixins) {
     return mixins.reduce((c, mixin) => mixin(c), superclass);
-};
+}
 exports.compose = compose;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@poppinss/utils",
-	"version": "4.0.4",
+	"version": "5.0.0",
 	"description": "Handy utilities for repetitive work",
 	"main": "build/index.js",
 	"files": [