@factory-js/factory/dist/index.d.cts

🏭 The object generator for testing

type Promisable<T> = T | PromiseLike<T>;

type Key = string | number | symbol;

type UnknownRecord = Record<Key, unknown>;

type PromisableRecord<P extends UnknownRecord> = {
    [K in keyof P]: Promisable<P[K]>;
};

type After<O, V extends UnknownRecord> = (object: O, vars: PromisableRecord<V>) => Promisable<void>;

type Create<P extends UnknownRecord, O> = (props: P) => Promisable<O>;

type InitProps<P extends UnknownRecord> = {
    [K in keyof P]: () => Promisable<P[K]>;
};

type InitVars<V extends UnknownRecord> = {
    [K in keyof V]: () => Promisable<V[K]>;
};

type Props<P extends UnknownRecord, V extends UnknownRecord> = {
    [K in keyof P]: (params: {
        props: PromisableRecord<P>;
        vars: PromisableRecord<V>;
    }) => Promisable<P[K]>;
};

type Deps<T extends UnknownRecord> = {
    [K in keyof T]: (deps: PromisableRecord<T>) => Promisable<T[K]>;
};

type Vars<V extends UnknownRecord> = Deps<V>;

type Trait<P extends UnknownRecord, V extends UnknownRecord, O> = Partial<{
    props: Partial<Props<P, V>>;
    vars: Partial<Vars<V>>;
    after: After<O, V>;
}>;

type TraitSet<P extends UnknownRecord, V extends UnknownRecord, O> = Record<string, Trait<P, V, O> | ((...args: never[]) => Trait<P, V, O>)>;

declare class Factory<P extends UnknownRecord, O, V extends UnknownRecord, T extends TraitSet<P, V, O>> {
    #private;
    constructor({ initProps, initVars, props, vars, create, traits, afterHooks, }: {
        initProps: InitProps<P>;
        initVars: InitVars<V>;
        props: Props<P, V>;
        vars: Vars<V>;
        create: Create<P, O>;
        traits: T;
        afterHooks: After<O, V>[];
    });
    props(props: Partial<Props<P, V>>): Factory<P, O, V, T>;
    vars(vars: Partial<Vars<V>>): Factory<P, O, V, T>;
    traits<T2 extends TraitSet<P, V, O>>(traits: T2 & TraitSet<P, V, O>): Factory<P, O, V, T & T2 & TraitSet<P, V, O>>;
    use(pick: (traits: T) => Trait<P, V, O>): Factory<P, O, V, T>;
    after(after: After<O, V>): Factory<P, O, V, T>;
    build(): Promise<P>;
    buildList(count: number): Promise<P[]>;
    create(): Promise<O>;
    createList(count: number): Promise<O[]>;
    get def(): {
        props: InitProps<P>;
        vars: InitVars<V>;
    };
}
declare const factory: {
    define: <P extends UnknownRecord, O = never, V extends UnknownRecord = Record<never, never>>({ props, vars }: {
        props: InitProps<P>;
        vars: InitVars<V>;
    }, create?: Create<P, O>) => Factory<P, O, V, {}>;
};

declare const later: <T>() => (() => Promisable<T>);

type Iteratee<A extends unknown[], O> = (count: number, ...args: A) => Promisable<O>;
declare const seq: <A extends unknown[], O>(initialCount: number, iteratee: Iteratee<A, O>) => (...args: A) => Promisable<O>;

export { Factory, factory, later, seq };