ordu/dist/ordu.d.ts

Execute functions in a configurable order, modifying a shared data structure.

import { EventEmitter } from 'events';
import StrictEventEmitter from 'strict-event-emitter-types';
export type { TaskDef, TaskSpec };
export { Ordu, Task, LegacyOrdu };
type OrduOptions = {
    debug: boolean;
    select: {
        sort: boolean | number | null;
    };
};
interface Events {
    'task-result': TaskResult;
    'task-end': {
        result: TaskResult;
        operate: Operate;
        data: any;
    };
}
type OrduEmitter = StrictEventEmitter<EventEmitter, Events>;
interface OrduIF {
    add(td: TaskDef): OrduIF;
    add(td: TaskDef[]): OrduIF;
    add(te: TaskExec): OrduIF;
    add(te: TaskExec, td: TaskDef): OrduIF;
    add(te: TaskExec[]): OrduIF;
    tasks(): Task[];
    task: {
        [name: string]: Task;
    };
    operator(name: string, opr: Operator): void;
    operator(opr: Operator): void;
    operators(): object;
    execSync(this: Ordu, ctx: any, data: any, opts: any): ExecResult;
    exec(ctx: any, data: any, opts: any): Promise<ExecResult>;
}
interface TaskDef {
    id?: string;
    name?: string;
    before?: string;
    after?: string;
    exec?: TaskExec;
    if?: {
        [k: string]: any;
    };
    active?: boolean;
    meta?: any;
    select?: string | ((source?: any, spec?: TaskSpec) => any);
    apply?: TaskDef | TaskDef[];
}
type TaskExec = (s: TaskSpec) => any;
interface TaskSpec {
    ctx: any;
    data: any;
    task: Task;
    async: boolean;
    opts?: OrduOptions;
    node?: any;
}
type TaskFunc = (s: TaskSpec) => any;
declare class Task {
    static count: number;
    runid: string;
    name: string;
    before?: string;
    after?: string;
    exec: TaskFunc;
    if?: {
        [k: string]: any;
    };
    active?: boolean;
    meta: {
        when: number;
        from: object;
    };
    constructor(taskdef: TaskDef);
}
declare class TaskResult {
    op: string;
    out?: object;
    err?: Error;
    why?: string;
    task: Task;
    name: string;
    start: number;
    end: number;
    runid: string;
    index: number;
    total: number;
    async: boolean;
    constructor(task: Task, taskI: number, total: number, runid: string);
    update(raw: any): void;
}
type Operate = {
    stop: boolean;
    err?: Error;
    async?: boolean;
};
type ExecResult = {
    tasklog: any[];
    task?: Task;
    taskcount: number;
    tasktotal: number;
    start: number;
    end: number;
    err?: Error;
    data: any;
};
type Operator = (r: TaskResult, ctx: any, data: object) => Operate;
declare const Ordu_base: {
    new (): OrduEmitter;
};
declare class Ordu extends Ordu_base implements OrduIF {
    private _opts;
    private _tasks;
    private _operator_map;
    task: {
        [name: string]: Task;
    };
    constructor(opts?: Partial<OrduOptions>);
    operator(first: string | Operator, opr?: Operator): void;
    operators(): {
        [op: string]: Operator;
    };
    add(first: any, second?: any): Ordu;
    private _add_task;
    execSync(this: Ordu, ctx?: any, data?: any, opts?: any, node?: any): ExecResult;
    exec(ctx?: any, data?: any, opts?: any, node?: any): Promise<ExecResult>;
    _execImpl(this: Ordu, ctx: any, data: any, opts: any, resolve?: (execres: ExecResult) => void, node?: any): ExecResult | Promise<ExecResult>;
    tasks(): Task[];
    private _operate;
    private _task_if;
}
declare function LegacyOrdu(opts?: any): any;