@h3ravel/arquebus 0.2.0 → 0.2.2

package/dist/index.d.ts

@@ -900,7 +900,9 @@ declare class arquebus<M extends Model$2 = Model$2> {
     createModel(name: string, options?: ModelOptions): typeof Model$2;
 }
 
-declare const BaseModel$1: new (...args: any[]) => any;
+declare const BaseModel$1: (new (...args: any[]) => any) & {
+    [x: string]: any;
+};
 declare class Model$2 extends BaseModel$1 {
     protected primaryKey: string;
     protected builder: IBuilder<any, any> | null;
@@ -1049,7 +1051,9 @@ declare class Collection<I extends Model$1> extends Collection$2<I> {
     [Symbol.iterator]: () => Iterator<I>;
 }
 
-declare const BaseModel: new (...args: any[]) => any;
+declare const BaseModel: (new (...args: any[]) => any) & {
+    [x: string]: any;
+};
 declare class Model$1 extends BaseModel {
     protected primaryKey: string;
     protected perPage: number;
@@ -1348,6 +1352,71 @@ declare class RelationNotFoundError extends BaseError {
 declare class InvalidArgumentError extends BaseError {
 }
 
+/**
+ * Helper type to extract instance type from constructor or mixin function
+ */
+type Constructor<T = TGeneric> = MixinConstructor<T>;
+type Mixin<TBase extends Constructor> = (Base: TBase) => Constructor;
+/**
+ * Helper type to convert union to intersection
+ */
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+/**
+ * Helper type to get static side of a constructor
+ */
+type Static<T> = {
+    [K in keyof T]: T[K];
+};
+/**
+ * Compose function that merges multiple classes and mixins
+ *
+ * @example
+ * const SomePlugin = <TBase extends new (...args: any[]) => TGeneric> (Base: TBase) => {
+ *     return class extends Base {
+ *         pluginAttribtue = 'plugin'
+ *         pluginMethod () {
+ *             return this.pluginAttribtue
+ *         }
+ *     }
+ * }
+ *
+ * // Base class
+ * class Model {
+ *     make () {
+ *         console.log('make')
+ *     }
+ *     pluginMethod (id: string) {
+ *     }
+ * }
+ *
+ * class User extends compose(
+ *     Model,
+ *     SomePlugin,
+ * ) {
+ *     relationPosts () {
+ *         return 'hasMany Posts'
+ *     }
+ * }
+ *
+ * const user = new User()
+ * user.make() // from Model
+ * user.pluginMethod() // from SomePlugin
+ * user.relationPosts() // from User
+ *
+ * console.log(user.pluginMethod('w')) // "plugin"
+ * console.log(user.pluginMethod()) // "plugin"
+ * console.log(user.relationPosts()) // "hasMany Posts"
+ *
+ * @param Base
+ * @param mixins
+ * @returns
+ */
+declare function compose$1<TBase extends Constructor, TMixins extends Array<Mixin<any> | Constructor>>(Base: TBase, ...mixins: TMixins): Constructor<InstanceType<TBase> & UnionToIntersection<{
+    [K in keyof TMixins]: TMixins[K] extends Mixin<any> ? InstanceType<ReturnType<TMixins[K]>> : TMixins[K] extends Constructor ? InstanceType<TMixins[K]> : never;
+}[number]>> & UnionToIntersection<{
+    [K in keyof TMixins]: TMixins[K] extends Mixin<any> ? Static<ReturnType<TMixins[K]>> : TMixins[K] extends Constructor ? Static<TMixins[K]> : never;
+}[number]> & Static<TBase>;
+
 declare const now: (format?: string) => string;
 declare const getRelationName: (relationMethod: string) => string;
 declare const getScopeName: (scopeMethod: string) => string;
@@ -1365,16 +1434,7 @@ declare const getAttrName: (attrMethod: string) => string;
  * @returns
  */
 declare const tap: <I>(instance: I, callback: (ins: I) => Promise<I> | I) => Promise<I> | I;
-type UnionToIntersection<U> = (U extends any ? (x: U) => void : never) extends (x: infer I) => void ? I : never;
-type Mixin<TBase extends MixinConstructor, TReturn extends MixinConstructor> = (base: TBase) => TReturn;
-/**
- * Compose functional mixins
- *
- * @param Base
- * @param mixins
- * @returns
- */
-declare function compose<MC extends MixinConstructor, P extends Mixin<MC, MixinConstructor>[]>(Base: MC, ...mixins: P): new (...args: any[]) => InstanceType<MC> & UnionToIntersection<InstanceType<ReturnType<P[number]>>>;
+declare const compose: typeof compose$1;
 declare const flattenDeep: (arr: any) => any;
 declare const kebabCase: (str: string) => string;
 declare const snakeCase: (str: string) => string;