@cmtlyt/base/dist/shared/base.Cv6pN22A.d.ts

cmtlyt的基础工具库

type GetFunctorResult<T, F = unknown> = T extends Functor<infer R> ? R : F;
declare abstract class Functor<T> {
    abstract name: string;
    constructor(value: T);
    abstract map(_fn: (value: any) => any): any;
    abstract flatMap(_fn: (value: any) => any): any;
    valueOf(): T;
    inspect(): string;
    join: () => T;
}

declare class Container<T> extends Functor<T> {
    name: string;
    map<R>(fn: (value: T) => R): Container<R>;
    flatMap<R>(fn: (value: T) => Container<R>): Container<R>;
}
declare function container<T>(value: T): Container<T>;

declare class Right<T> extends Functor<T> {
    name: string;
    map<R>(fn: (value: T) => R): Right<R>;
    flatMap<R>(fn: (value: T) => Functor<R>): Right<R>;
}
declare function right<T>(value: T): Right<T>;
declare class Left<T> extends Functor<T> {
    name: string;
    map(_fn: (value: T) => any): Left<T>;
    flatMap(_fn: (value: T) => Functor<any>): Left<T>;
}
declare function left<T>(value: T): Left<T>;
declare class Either<T> extends Functor<T> {
    name: string;
    map<R>(fn: (value: T) => R): Either<R> | Left<any>;
    flatMap<C extends Functor<any>, R = GetFunctorResult<C>>(fn: (value: T) => C): Either<R> | Left<any>;
}
declare function either<T>(value: T): Either<T>;

declare class IO<T extends (...args: any[]) => any> extends Functor<T> {
    name: string;
    map<R>(fn: (value: ReturnType<T>) => R): IO<(...args: Parameters<T>) => R>;
    flatMap<C extends Functor<any>, R = GetFunctorResult<C>>(fn: (value: ReturnType<T>) => C): IO<(...args: Parameters<T>) => R>;
    run(...args: Parameters<T>): ReturnType<T>;
}
declare function io<T extends (...args: any[]) => any>(value: T): IO<T>;

declare class MayBe<T> extends Functor<T> {
    name: string;
    isNothing(): boolean;
    map<R>(fn: (value: T) => R): MayBe<R | null>;
    flatMap<C extends Functor<any>, R = GetFunctorResult<C>>(fn: (value: T) => C): MayBe<R | null>;
}
declare function maybe<T>(value: T): MayBe<T>;

interface Resolver<T> {
    resolve: (value: T) => void;
    reject: (reason?: any) => void;
}
type TaskHandler<T> = ((resolver: Resolver<T>) => void) | (() => Promise<T>);
type MapValue<T extends TaskHandler<any>> = T extends TaskHandler<infer R> ? Awaited<R> : never;
interface ListenOptions<T extends TaskHandler<any>> {
    onResolved?: (result: MapValue<T>) => any;
    onRejected?: (reason?: any) => any;
}
type ThenResult<T, D> = T extends (...args: any[]) => infer R ? R : D;
declare class Task<T extends TaskHandler<any>> extends Functor<T> {
    #private;
    name: string;
    constructor(value: T);
    map<R>(fn: (value: MapValue<T>) => R): Task<TaskHandler<R>>;
    flatMap<C extends Functor<any>, R = GetFunctorResult<C>>(fn: (value: MapValue<T>) => C): Task<TaskHandler<R>>;
    then<F extends ListenOptions<T>['onResolved'], R = ThenResult<F, MapValue<T>>>(onResolved?: F, onRejected?: ListenOptions<T>['onRejected']): Promise<R>;
    catch<F extends ListenOptions<T>['onRejected']>(onRejected?: F): Promise<ThenResult<F, void>>;
    run(): this;
    listen(options: ListenOptions<T>): this;
}
declare function task<T>(handler: TaskHandler<T>): Task<TaskHandler<T>>;

declare const index_container: typeof container;
declare const index_either: typeof either;
declare const index_io: typeof io;
declare const index_left: typeof left;
declare const index_maybe: typeof maybe;
declare const index_right: typeof right;
declare const index_task: typeof task;
declare namespace index {
  export { index_container as container, index_either as either, index_io as io, index_left as left, index_maybe as maybe, index_right as right, index_task as task };
}

export { io as a, container as c, either as e, index as i, left as l, maybe as m, right as r, task as t };