taskx/index.d.ts

A lightweight TypeScript library for managing complex asynchronous task dependencies with intelligent dependency graph execution and parallel optimization

/**
 * Circular dependency error class
 * Throw this error when a circular dependency is detected in the task network
 * @class CircularDependencyError
 * @extends {Error}
 */
declare class CircularDependencyError extends Error {
    /**
     * Create a circular dependency error instance
     * @constructor
     */
    constructor();
}

/**
 * Error handling strategy enumeration
 * @enum {string}
 */
declare enum ErrorHandlingStrategy {
    /** Stop all tasks when an error occurs */
    STOP_ALL = "stop-all",
    /** Only stop downstream tasks when an error occurs */
    STOP_DOWNSTREAM = "stop-downstream"
}

/**
 * Task network context interface
 * @interface iTaskxContext
 */
interface iTaskxContext {
    /** Map to store task execution results */
    results: Map<AsyncMethod, any>;
    /** Set of completed task methods */
    completed: Set<AsyncMethod>;
    /** Error information, if an error occurs */
    error?: any;
    /** Error handling strategy */
    errorHandlingStrategy: ErrorHandlingStrategy;
}
/**
 * Async method type definition
 * @param {iTaskxContext} context - Task network context
 * @returns {Promise<void>} Async operation result
 */
type AsyncMethod = (context: iTaskxContext) => Promise<void>;
/**
 * Wrapped task class (forward declaration to avoid circular dependencies)
 */
interface iTask {
    /** Try to process the task */
    tryProcess(context: iTaskxContext): Promise<void>;
    /** Add dependency relationship */
    dependOn(...parents: iTask[]): iTask;
}

/**
 * Task processor configuration interface
 * @interface iTaskProcessorConfig
 */
interface iTaskProcessorConfig {
    /** Error handling strategy */
    errorHandlingStrategy?: ErrorHandlingStrategy;
}
/**
 * Task processor class (forward declaration to avoid circular dependencies)
 */
interface iTaskProcessor {
    /** Get context */
    get context(): iTaskxContext;
    /** Process task list */
    process(tasks: iTask[]): Promise<void>;
}
/**
 * Processor factory function type definition
 * @typedef {Function} ProcessorFactory
 * @param {iTaskProcessorConfig} config - Processor configuration
 * @returns {iTaskProcessor} Task processor instance
 */
type ProcessorFactory = (config: iTaskProcessorConfig) => iTaskProcessor;

/**
 * Processor factory function
 * Create task processor instance based on configuration
 * @type {ProcessorFactory}
 * @param {iTaskProcessorConfig} config - Processor configuration
 * @returns {TaskProcessor} Task processor instance
 */
declare const useProcessor: ProcessorFactory;

/**
 * Task registration function type definition
 * @typedef {Function} TaskRegistor
 * @param {AsyncMethod} process - Async processing method
 * @returns {iTask} Wrapped task
 */
type TaskRegistor = (process: AsyncMethod) => iTask;
/**
 * Task registration function
 * Wrap async methods as task instances
 * @type {TaskRegistor}
 * @param {AsyncMethod} process - Async processing method
 * @returns {TaskNode} Wrapped task
 */
declare const registerTask: TaskRegistor;

export { CircularDependencyError, ErrorHandlingStrategy, registerTask, useProcessor };
export type { AsyncMethod, iTask, iTaskProcessor, iTaskProcessorConfig, iTaskxContext };