@bluelibs/runner 1.0.0

package/dist/TaskRunner.d.ts

@@ -0,0 +1,22 @@
+import { DependencyMapType, DependencyValuesType, ITask } from "./defs";
+import { EventManager } from "./EventManager";
+import { Store } from "./Store";
+export declare class TaskRunner {
+    protected readonly store: Store;
+    protected readonly eventManager: EventManager;
+    protected readonly runnerStore: Map<string, (input: any) => Promise<any>>;
+    constructor(store: Store, eventManager: EventManager);
+    /**
+     * Begins the execution of an task. These are registered tasks and all sanity checks have been performed at this stage to ensure consistency of the object.
+     * This function can throw only if any of the event listeners or run function throws
+     */
+    run<TInput, TOutput extends Promise<any>, TDeps extends DependencyMapType>(task: ITask<TInput, TOutput, TDeps>, input: TInput, taskDependencies?: DependencyValuesType<TDeps>): Promise<TOutput | undefined>;
+    /**
+     * Creates the function with the chain of middleware.
+     * @param task
+     * @param input
+     * @param taskDependencies
+     * @returns
+     */
+    protected createRunnerWithMiddleware<TInput, TOutput extends Promise<any>, TDeps extends DependencyMapType>(task: ITask<TInput, TOutput, TDeps>, taskDependencies: DependencyValuesType<{}>): (input: any) => Promise<TOutput>;
+}

package/dist/TaskRunner.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskRunner = void 0;
+const globalEvents_1 = require("./globalEvents");
+class TaskRunner {
+    store;
+    eventManager;
+    runnerStore = new Map();
+    constructor(store, eventManager) {
+        this.store = store;
+        this.eventManager = eventManager;
+    }
+    /**
+     * Begins the execution of an task. These are registered tasks and all sanity checks have been performed at this stage to ensure consistency of the object.
+     * This function can throw only if any of the event listeners or run function throws
+     */
+    async run(task, input, taskDependencies) {
+        let runner = this.runnerStore.get(task.id);
+        if (!runner) {
+            const storeTask = this.store.tasks.get(task.id);
+            const deps = taskDependencies || storeTask.computedDependencies;
+            runner = this.createRunnerWithMiddleware(task, deps);
+            this.runnerStore.set(task.id, runner);
+        }
+        // begin by dispatching the event of creating it.
+        // then ensure the hooks are called
+        // then ensure the middleware are called
+        await this.eventManager.emit(task.events.beforeRun, { input });
+        await this.eventManager.emit(globalEvents_1.globalEvents.tasks.beforeRun, {
+            task,
+            input,
+        });
+        let error;
+        try {
+            // craft the next function starting from the first next function
+            const output = await runner(input);
+            await this.eventManager.emit(task.events.afterRun, { input, output });
+            await this.eventManager.emit(globalEvents_1.globalEvents.tasks.afterRun, {
+                task,
+                input,
+                output,
+            });
+            return output;
+        }
+        catch (e) {
+            error = e;
+            // If you want to rewthrow the error, this should be done inside the onError event.
+            await this.eventManager.emit(task.events.onError, { error });
+            await this.eventManager.emit(globalEvents_1.globalEvents.tasks.onError, {
+                task,
+                error,
+            });
+            throw e;
+        }
+    }
+    /**
+     * Creates the function with the chain of middleware.
+     * @param task
+     * @param input
+     * @param taskDependencies
+     * @returns
+     */
+    createRunnerWithMiddleware(task, taskDependencies) {
+        // this is the final next()
+        let next = async (input) => {
+            return task.run.call(null, input, taskDependencies);
+        };
+        const existingMiddlewares = task.middleware;
+        const createdMiddlewares = [
+            ...this.store.getGlobalMiddlewares(existingMiddlewares.map((x) => x.id)),
+            ...existingMiddlewares,
+        ];
+        if (createdMiddlewares.length > 0) {
+            // we need to run the middleware in reverse order
+            // so we can chain the next function
+            for (let i = createdMiddlewares.length - 1; i >= 0; i--) {
+                const middleware = createdMiddlewares[i];
+                const storeMiddleware = this.store.middlewares.get(middleware.id); // we know it exists because at this stage all sanity checks have been done.
+                const nextFunction = next;
+                next = async (input) => {
+                    return storeMiddleware.middleware.run({
+                        taskDefinition: task,
+                        input,
+                        next: nextFunction,
+                    }, storeMiddleware.computedDependencies);
+                };
+            }
+        }
+        return next;
+    }
+}
+exports.TaskRunner = TaskRunner;
+//# sourceMappingURL=TaskRunner.js.map

package/dist/TaskRunner.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TaskRunner.js","sourceRoot":"","sources":["../src/TaskRunner.ts"],"names":[],"mappings":"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"}

package/dist/define.d.ts

@@ -0,0 +1,10 @@
+import { ITask, ITaskDefinition, IResource, IResourceWithConfig, IResourceDefinintion, IEventDefinition, IMiddlewareDefinition, DependencyMapType, IMiddleware } from "./defs";
+export declare function defineTask<Input = undefined, Output extends Promise<any> = any, Deps extends DependencyMapType = any, Test = any>(config: ITaskDefinition<Input, Output, Deps, Test>): ITask<Input, Output, Deps, Test>;
+export declare function defineResource<TConfig = void, TValue = any, TDeps extends DependencyMapType = {}>(constConfig: IResourceDefinintion<TConfig, TValue, TDeps>): IResource<TConfig, TValue, TDeps>;
+export declare function defineEvent<TPayload = any>(config: IEventDefinition<TPayload>): IEventDefinition<TPayload>;
+export declare function defineMiddleware<TDeps extends DependencyMapType = {}>(config: IMiddlewareDefinition<TDeps>): IMiddleware<TDeps>;
+export declare function isTask(definition: any): definition is ITask;
+export declare function isResource(definition: any): definition is IResource;
+export declare function isResourceWithConfig(definition: any): definition is IResourceWithConfig;
+export declare function isEvent(definition: any): definition is IEventDefinition;
+export declare function isMiddleware(definition: any): definition is IMiddleware;

package/dist/define.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineTask = defineTask;
+exports.defineResource = defineResource;
+exports.defineEvent = defineEvent;
+exports.defineMiddleware = defineMiddleware;
+exports.isTask = isTask;
+exports.isResource = isResource;
+exports.isResourceWithConfig = isResourceWithConfig;
+exports.isEvent = isEvent;
+exports.isMiddleware = isMiddleware;
+const defs_1 = require("./defs");
+const errors_1 = require("./errors");
+function defineTask(config) {
+    const autorun = {};
+    // if (config.autorun) {
+    //   if (config.autorun.on) {
+    //     autorun.on = Array.isArray(config.autorun.on);
+    //     autorun.schedule = config.autorun.schedule;
+    //   }
+    // }
+    return {
+        [defs_1.symbols.task]: true,
+        id: config.id,
+        dependencies: config.dependencies || {},
+        middleware: config.middleware || [],
+        run: config.run,
+        on: config.on,
+        events: {
+            beforeRun: defineEvent({
+                id: `${config.id}.beforeRun`,
+            }),
+            afterRun: defineEvent({
+                id: `${config.id}.afterRun`,
+            }),
+            onError: defineEvent({
+                id: `${config.id}.onError`,
+            }),
+        },
+        // autorun,
+    };
+}
+function defineResource(constConfig) {
+    return {
+        [defs_1.symbols.resource]: true,
+        id: constConfig.id,
+        dependencies: constConfig.dependencies,
+        hooks: constConfig.hooks || [],
+        register: constConfig.register || [],
+        init: constConfig.init,
+        with: function (config) {
+            return {
+                [defs_1.symbols.resourceWithConfig]: true,
+                resource: this,
+                config,
+            };
+        },
+        events: {
+            beforeInit: defineEvent({
+                id: `${constConfig.id}.beforeInit`,
+            }),
+            afterInit: defineEvent({
+                id: `${constConfig.id}.afterInit`,
+            }),
+            onError: defineEvent({
+                id: `${constConfig.id}.onError`,
+            }),
+        },
+    };
+}
+function defineEvent(config) {
+    return {
+        [defs_1.symbols.event]: true,
+        ...config,
+    };
+}
+function defineMiddleware(config) {
+    const object = {
+        [defs_1.symbols.middleware]: true,
+        ...config,
+        dependencies: config.dependencies || {},
+    };
+    return {
+        ...object,
+        global() {
+            return {
+                ...object,
+                [defs_1.symbols.middlewareGlobal]: true,
+                global() {
+                    throw errors_1.Errors.middlewareAlreadyGlobal(config.id);
+                },
+            };
+        },
+    };
+}
+function isTask(definition) {
+    return definition && definition[defs_1.symbols.task];
+}
+function isResource(definition) {
+    return definition && definition[defs_1.symbols.resource];
+}
+function isResourceWithConfig(definition) {
+    return definition && definition[defs_1.symbols.resourceWithConfig];
+}
+function isEvent(definition) {
+    return definition && definition[defs_1.symbols.event];
+}
+function isMiddleware(definition) {
+    return definition && definition[defs_1.symbols.middleware];
+}
+//# sourceMappingURL=define.js.map

package/dist/define.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"define.js","sourceRoot":"","sources":["../src/define.ts"],"names":[],"mappings":"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"}

package/dist/defs.d.ts

@@ -0,0 +1,127 @@
+export declare const symbols: {
+    task: symbol;
+    resource: symbol;
+    resourceWithConfig: symbol;
+    event: symbol;
+    middleware: symbol;
+    middlewareGlobal: symbol;
+};
+export interface IMeta {
+    title?: string;
+    description?: string;
+    tags: string[];
+}
+export interface ITaskMeta extends IMeta {
+}
+export interface IResourceMeta extends IMeta {
+}
+export interface IEventMeta extends IMeta {
+}
+export interface IMiddlewareMeta extends IMeta {
+}
+export type DependencyMapType = Record<string, ITask | IResource | IEventDefinition>;
+export type DependencyValueType<T> = T extends ITask<infer I, infer O, 
+/** The infer D, while not used is crucial for making this work correctly, otherwise it forces input: unknown to a dependency that has a dependency. */
+infer D> ? (...args: I extends unknown ? [] : [I]) => O : T extends IResource<any, infer V> ? V : T extends IEventDefinition<infer P> ? (input: P) => Promise<void> | never : never;
+export type DependencyValuesType<T extends DependencyMapType> = {
+    [K in keyof T]: DependencyValueType<T[K]>;
+};
+export type RegisterableItems = IResource<void> | IResourceWithConfig<any> | ITaskDefinition | IMiddlewareDefinition | IEventDefinition;
+export interface ITaskDefinition<TInput = any, TOutput extends Promise<any> = any, TDependencies extends DependencyMapType = {}, TEventDefinitionInput = null> {
+    id: string;
+    dependencies?: TDependencies | (() => TDependencies);
+    middleware?: IMiddlewareDefinition[];
+    on?: IEventDefinition<TEventDefinitionInput>;
+    meta?: ITaskMeta;
+    run: (input: TEventDefinitionInput extends null ? TInput : TEventDefinitionInput, dependencies: DependencyValuesType<TDependencies>) => TOutput;
+}
+export type BeforeRunEventPayload<TInput> = {
+    input: TInput;
+};
+export type AfterRunEventPayload<TInput, TOutput> = {
+    input: TInput;
+    output: TOutput;
+};
+export type OnErrorEventPayload = {
+    error: any;
+};
+export type BeforeInitEventPayload<TConfig> = {
+    config: TConfig;
+};
+export type AfterInitEventPayload<TConfig, TValue> = {
+    config: TConfig;
+    value: TValue;
+};
+/**
+ * This is the response after the definition has been prepared. TODO: better naming?
+ */
+export interface ITask<TInput = any, TOutput extends Promise<any> = any, TDependencies extends DependencyMapType = {}, TEventDefinitionInput = null> extends ITaskDefinition<TInput, TOutput, TDependencies, TEventDefinitionInput> {
+    dependencies: TDependencies | (() => TDependencies);
+    computedDependencies?: DependencyValuesType<TDependencies>;
+    middleware: IMiddlewareDefinition[];
+    /**
+     * These events are automatically populated after the task has been defined.
+     */
+    events: {
+        beforeRun: IEventDefinition<BeforeRunEventPayload<TInput>>;
+        afterRun: IEventDefinition<AfterRunEventPayload<TInput, TOutput>>;
+        onError: IEventDefinition<OnErrorEventPayload>;
+    };
+}
+export interface IResourceDefinintion<TConfig = void, TValue = unknown, TDependencies extends DependencyMapType = {}> {
+    id: string;
+    dependencies?: TDependencies | ((config: TConfig) => TDependencies);
+    hooks?: IHookDefinition<TDependencies>[] | ((config: TConfig) => IHookDefinition<TDependencies>[]);
+    register?: Array<RegisterableItems> | ((config: TConfig) => Array<RegisterableItems>);
+    init?: (config: TConfig, dependencies: DependencyValuesType<TDependencies>) => Promise<TValue>;
+    meta?: IResourceMeta;
+}
+export interface IResource<TConfig = void, TValue = any, TDependencies extends DependencyMapType = any> extends IResourceDefinintion<TConfig, TValue, TDependencies> {
+    with(config: TConfig): IResourceWithConfig<TConfig, TValue, TDependencies>;
+    register: Array<RegisterableItems> | ((config: TConfig) => Array<RegisterableItems>);
+    /**
+     * These events are automatically populated after the task has been defined.
+     */
+    events: {
+        beforeInit: IEventDefinition<BeforeInitEventPayload<TConfig>>;
+        afterInit: IEventDefinition<AfterInitEventPayload<TConfig, TValue>>;
+        onError: IEventDefinition<OnErrorEventPayload>;
+    };
+    hooks: IHookDefinition<TDependencies>[] | ((config: TConfig) => IHookDefinition<TDependencies>[]);
+}
+export interface IResourceWithConfig<TConfig = any, TValue = any, TDependencies extends DependencyMapType = any> {
+    resource: IResource<TConfig, TValue, TDependencies>;
+    config: TConfig;
+}
+export interface IEvent<TPayload = any> {
+    id: string;
+    data: TPayload;
+}
+export type EventHandlerType<T = any> = (event: IEvent<T>) => any | Promise<any>;
+export interface IEventDefinition<TPayload = void> {
+    id: string;
+    meta?: IEventMeta;
+}
+export interface IMiddlewareDefinition<TDependencies extends DependencyMapType = any> {
+    id: string;
+    dependencies?: TDependencies | (() => TDependencies);
+    run: (input: IMiddlewareExecutionInput, dependencies: DependencyValuesType<TDependencies>) => Promise<any>;
+    meta?: IMiddlewareMeta;
+}
+export interface IMiddleware<TDependencies extends DependencyMapType = any> extends IMiddlewareDefinition<TDependencies> {
+    dependencies: TDependencies | (() => TDependencies);
+    global(): IMiddleware<TDependencies>;
+}
+export interface IMiddlewareDefinitionConfigured<C extends Record<string, any> = {}> {
+    middleware: IMiddleware<C>;
+    config?: C;
+}
+export interface IMiddlewareExecutionInput {
+    taskDefinition?: ITask;
+    input: any;
+    next: (input?: any) => Promise<any>;
+}
+export interface IHookDefinition<D extends DependencyMapType = {}> {
+    event: IEventDefinition;
+    run: (event: IEvent, dependencies: DependencyValuesType<D>) => Promise<void> | void;
+}

package/dist/defs.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.symbols = void 0;
+exports.symbols = {
+    task: Symbol("task"),
+    resource: Symbol("resource"),
+    resourceWithConfig: Symbol("resourceWithConfig"),
+    event: Symbol("event"),
+    middleware: Symbol("middleware"),
+    middlewareGlobal: Symbol("middlewareGlobal"),
+};
+//# sourceMappingURL=defs.js.map

package/dist/defs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"defs.js","sourceRoot":"","sources":["../src/defs.ts"],"names":[],"mappings":";;;AAAa,QAAA,OAAO,GAAG;IACrB,IAAI,EAAE,MAAM,CAAC,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC,UAAU,CAAC;IAC5B,kBAAkB,EAAE,MAAM,CAAC,oBAAoB,CAAC;IAChD,KAAK,EAAE,MAAM,CAAC,OAAO,CAAC;IACtB,UAAU,EAAE,MAAM,CAAC,YAAY,CAAC;IAChC,gBAAgB,EAAE,MAAM,CAAC,kBAAkB,CAAC;CAC7C,CAAC"}

package/dist/errors.d.ts

@@ -0,0 +1,8 @@
+export declare const Errors: {
+    duplicateRegistration: (type: string, id: string) => Error;
+    dependencyNotFound: (key: string) => Error;
+    unknownItemType: (item: any) => Error;
+    circularDependencies: (cycles: string[]) => Error;
+    eventNotFound: (id: string) => Error;
+    middlewareAlreadyGlobal: (id: string) => Error;
+};

package/dist/errors.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Errors = void 0;
+exports.Errors = {
+    duplicateRegistration: (type, id) => new Error(`${type} "${id}" already registered`),
+    dependencyNotFound: (key) => new Error(`Dependency ${key} not found. Did you forget to register it through a resource?`),
+    unknownItemType: (item) => new Error(`Unknown item type: ${item}`),
+    circularDependencies: (cycles) => new Error(`Circular dependencies detected: ${cycles.join(", ")}`),
+    eventNotFound: (id) => new Error(`Event "${id}" not found. Did you forget to register it?`),
+    middlewareAlreadyGlobal: (id) => new Error("Cannot call global on a global middleware: " + id),
+};
+//# sourceMappingURL=errors.js.map

package/dist/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":";;;AAEa,QAAA,MAAM,GAAG;IACpB,qBAAqB,EAAE,CAAC,IAAY,EAAE,EAAU,EAAE,EAAE,CAClD,IAAI,KAAK,CAAC,GAAG,IAAI,KAAK,EAAE,sBAAsB,CAAC;IAEjD,kBAAkB,EAAE,CAAC,GAAW,EAAE,EAAE,CAClC,IAAI,KAAK,CACP,cAAc,GAAG,+DAA+D,CACjF;IAEH,eAAe,EAAE,CAAC,IAAS,EAAE,EAAE,CAAC,IAAI,KAAK,CAAC,sBAAsB,IAAI,EAAE,CAAC;IAEvE,oBAAoB,EAAE,CAAC,MAAgB,EAAE,EAAE,CACzC,IAAI,KAAK,CAAC,mCAAmC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;IAEnE,aAAa,EAAE,CAAC,EAAU,EAAE,EAAE,CAC5B,IAAI,KAAK,CAAC,UAAU,EAAE,6CAA6C,CAAC;IAEtE,uBAAuB,EAAE,CAAC,EAAU,EAAE,EAAE,CACtC,IAAI,KAAK,CAAC,6CAA6C,GAAG,EAAE,CAAC;CAChE,CAAC"}

package/dist/globalEvents.d.ts

@@ -0,0 +1,36 @@
+import { ITask, IResource } from "./defs";
+export declare const globalEvents: {
+    beforeInit: import("./defs").IEventDefinition<any>;
+    afterInit: import("./defs").IEventDefinition<any>;
+    tasks: {
+        beforeRun: import("./defs").IEventDefinition<{
+            task: ITask<any, any, any>;
+            input: any;
+        }>;
+        afterRun: import("./defs").IEventDefinition<{
+            task: ITask<any, any, any>;
+            input: any;
+            output: any;
+        }>;
+        onError: import("./defs").IEventDefinition<{
+            error: Error;
+            task: ITask<any, any, any>;
+        }>;
+    };
+    resources: {
+        beforeInit: import("./defs").IEventDefinition<{
+            resource: IResource<any, any, any>;
+            config: any;
+        }>;
+        afterInit: import("./defs").IEventDefinition<{
+            resource: IResource<any, any, any>;
+            config: any;
+            value: any;
+        }>;
+        onError: import("./defs").IEventDefinition<{
+            error: Error;
+            resource: IResource<any, any, any>;
+        }>;
+    };
+};
+export declare const globalEventsArray: import("./defs").IEventDefinition<any>[];

package/dist/globalEvents.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.globalEventsArray = exports.globalEvents = void 0;
+const define_1 = require("./define");
+exports.globalEvents = {
+    beforeInit: (0, define_1.defineEvent)({
+        id: "global.beforeInit",
+    }),
+    afterInit: (0, define_1.defineEvent)({
+        id: "global.afterInit",
+    }),
+    tasks: {
+        beforeRun: (0, define_1.defineEvent)({
+            id: "global.tasks.beforeRun",
+        }),
+        afterRun: (0, define_1.defineEvent)({
+            id: "global.tasks.afterRun",
+        }),
+        onError: (0, define_1.defineEvent)({
+            id: "global.tasks.onError",
+        }),
+    },
+    resources: {
+        beforeInit: (0, define_1.defineEvent)({
+            id: "global.resources.beforeInit",
+        }),
+        afterInit: (0, define_1.defineEvent)({
+            id: "global.resources.afterInit",
+        }),
+        onError: (0, define_1.defineEvent)({
+            id: "global.resources.onError",
+        }),
+    },
+};
+exports.globalEventsArray = [
+    exports.globalEvents.beforeInit,
+    exports.globalEvents.afterInit,
+    exports.globalEvents.tasks.beforeRun,
+    exports.globalEvents.tasks.afterRun,
+    exports.globalEvents.tasks.onError,
+    exports.globalEvents.resources.beforeInit,
+    exports.globalEvents.resources.afterInit,
+    exports.globalEvents.resources.onError,
+];
+//# sourceMappingURL=globalEvents.js.map

package/dist/globalEvents.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"globalEvents.js","sourceRoot":"","sources":["../src/globalEvents.ts"],"names":[],"mappings":";;;AAAA,qCAAuC;AAG1B,QAAA,YAAY,GAAG;IAC1B,UAAU,EAAE,IAAA,oBAAW,EAAC;QACtB,EAAE,EAAE,mBAAmB;KACxB,CAAC;IACF,SAAS,EAAE,IAAA,oBAAW,EAAC;QACrB,EAAE,EAAE,kBAAkB;KACvB,CAAC;IACF,KAAK,EAAE;QACL,SAAS,EAAE,IAAA,oBAAW,EAGnB;YACD,EAAE,EAAE,wBAAwB;SAC7B,CAAC;QACF,QAAQ,EAAE,IAAA,oBAAW,EAIlB;YACD,EAAE,EAAE,uBAAuB;SAC5B,CAAC;QACF,OAAO,EAAE,IAAA,oBAAW,EAGjB;YACD,EAAE,EAAE,sBAAsB;SAC3B,CAAC;KACH;IACD,SAAS,EAAE;QACT,UAAU,EAAE,IAAA,oBAAW,EAGpB;YACD,EAAE,EAAE,6BAA6B;SAClC,CAAC;QACF,SAAS,EAAE,IAAA,oBAAW,EAInB;YACD,EAAE,EAAE,4BAA4B;SACjC,CAAC;QACF,OAAO,EAAE,IAAA,oBAAW,EAGjB;YACD,EAAE,EAAE,0BAA0B;SAC/B,CAAC;KACH;CACF,CAAC;AAEW,QAAA,iBAAiB,GAAG;IAC/B,oBAAY,CAAC,UAAU;IACvB,oBAAY,CAAC,SAAS;IACtB,oBAAY,CAAC,KAAK,CAAC,SAAS;IAC5B,oBAAY,CAAC,KAAK,CAAC,QAAQ;IAC3B,oBAAY,CAAC,KAAK,CAAC,OAAO;IAC1B,oBAAY,CAAC,SAAS,CAAC,UAAU;IACjC,oBAAY,CAAC,SAAS,CAAC,SAAS;IAChC,oBAAY,CAAC,SAAS,CAAC,OAAO;CAC/B,CAAC"}

package/dist/globalResources.d.ts

@@ -0,0 +1,8 @@
+import { EventManager } from "./EventManager";
+import { Store } from "./Store";
+import { TaskRunner } from "./TaskRunner";
+export declare const globalResources: {
+    store: import("./defs").IResource<Store, any, {}>;
+    eventManager: import("./defs").IResource<EventManager, any, {}>;
+    taskRunner: import("./defs").IResource<TaskRunner, any, {}>;
+};

package/dist/globalResources.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.globalResources = void 0;
+const define_1 = require("./define");
+exports.globalResources = {
+    store: (0, define_1.defineResource)({
+        id: "global.store",
+        init: async (store) => store,
+    }),
+    eventManager: (0, define_1.defineResource)({
+        id: "global.eventManager",
+        init: async (em) => em,
+    }),
+    taskRunner: (0, define_1.defineResource)({
+        id: "global.taskRunner",
+        init: async (runner) => runner,
+    }),
+};
+//# sourceMappingURL=globalResources.js.map

package/dist/globalResources.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"globalResources.js","sourceRoot":"","sources":["../src/globalResources.ts"],"names":[],"mappings":";;;AAAA,qCAA0C;AAK7B,QAAA,eAAe,GAAG;IAC7B,KAAK,EAAE,IAAA,uBAAc,EAAQ;QAC3B,EAAE,EAAE,cAAc;QAClB,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE,CAAC,KAAK;KAC7B,CAAC;IACF,YAAY,EAAE,IAAA,uBAAc,EAAe;QACzC,EAAE,EAAE,qBAAqB;QACzB,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE;KACvB,CAAC;IACF,UAAU,EAAE,IAAA,uBAAc,EAAa;QACrC,EAAE,EAAE,mBAAmB;QACvB,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE,EAAE,CAAC,MAAM;KAC/B,CAAC;CACH,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,49 @@
+import { defineTask, defineResource, defineEvent, defineMiddleware } from "./define";
+import { run } from "./run";
+declare const globals: {
+    events: {
+        beforeInit: import("./defs").IEventDefinition<any>;
+        afterInit: import("./defs").IEventDefinition<any>;
+        tasks: {
+            beforeRun: import("./defs").IEventDefinition<{
+                task: import("./defs").ITask<any, any, any>;
+                input: any;
+            }>;
+            afterRun: import("./defs").IEventDefinition<{
+                task: import("./defs").ITask<any, any, any>;
+                input: any;
+                output: any;
+            }>;
+            onError: import("./defs").IEventDefinition<{
+                error: Error;
+                task: import("./defs").ITask<any, any, any>;
+            }>;
+        };
+        resources: {
+            beforeInit: import("./defs").IEventDefinition<{
+                resource: import("./defs").IResource<any, any, any>;
+                config: any;
+            }>;
+            afterInit: import("./defs").IEventDefinition<{
+                resource: import("./defs").IResource<any, any, any>;
+                config: any;
+                value: any;
+            }>;
+            onError: import("./defs").IEventDefinition<{
+                error: Error;
+                resource: import("./defs").IResource<any, any, any>;
+            }>;
+        };
+    };
+    resources: {
+        store: import("./defs").IResource<import("./Store").Store, any, {}>;
+        eventManager: import("./defs").IResource<import("./EventManager").EventManager, any, {}>;
+        taskRunner: import("./defs").IResource<import("./TaskRunner").TaskRunner, any, {}>;
+    };
+};
+export { globals };
+export { defineTask as task, defineResource as resource, defineEvent as event, defineMiddleware as middleware, run, };
+export * as definitions from "./defs";
+export { Store } from "./Store";
+export { EventManager } from "./EventManager";
+export { TaskRunner } from "./TaskRunner";

package/dist/index.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskRunner = exports.EventManager = exports.Store = exports.definitions = exports.run = exports.middleware = exports.event = exports.resource = exports.task = exports.globals = void 0;
+const define_1 = require("./define");
+Object.defineProperty(exports, "task", { enumerable: true, get: function () { return define_1.defineTask; } });
+Object.defineProperty(exports, "resource", { enumerable: true, get: function () { return define_1.defineResource; } });
+Object.defineProperty(exports, "event", { enumerable: true, get: function () { return define_1.defineEvent; } });
+Object.defineProperty(exports, "middleware", { enumerable: true, get: function () { return define_1.defineMiddleware; } });
+const globalEvents_1 = require("./globalEvents");
+const globalResources_1 = require("./globalResources");
+const run_1 = require("./run");
+Object.defineProperty(exports, "run", { enumerable: true, get: function () { return run_1.run; } });
+const globals = {
+    events: globalEvents_1.globalEvents,
+    resources: globalResources_1.globalResources,
+};
+exports.globals = globals;
+exports.definitions = require("./defs");
+var Store_1 = require("./Store");
+Object.defineProperty(exports, "Store", { enumerable: true, get: function () { return Store_1.Store; } });
+var EventManager_1 = require("./EventManager");
+Object.defineProperty(exports, "EventManager", { enumerable: true, get: function () { return EventManager_1.EventManager; } });
+var TaskRunner_1 = require("./TaskRunner");
+Object.defineProperty(exports, "TaskRunner", { enumerable: true, get: function () { return TaskRunner_1.TaskRunner; } });
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;AAAA,qCAKkB;AAYF,qFAhBd,mBAAU,OAgBQ;AACA,yFAhBlB,uBAAc,OAgBY;AACX,sFAhBf,oBAAW,OAgBS;AACA,2FAhBpB,yBAAgB,OAgBc;AAdhC,iDAA8C;AAC9C,uDAAoD;AACpD,+BAA4B;AAa1B,oFAbO,SAAG,OAaP;AAXL,MAAM,OAAO,GAAG;IACd,MAAM,EAAE,2BAAY;IACpB,SAAS,EAAE,iCAAe;CAC3B,CAAC;AAEO,0BAAO;AAShB,wCAAsC;AACtC,iCAAgC;AAAvB,8FAAA,KAAK,OAAA;AACd,+CAA8C;AAArC,4GAAA,YAAY,OAAA;AACrB,2CAA0C;AAAjC,wGAAA,UAAU,OAAA"}