@bluelibs/runner 4.7.0 → 4.8.1

package/dist/define.d.ts

@@ -6,4 +6,4 @@ export { defineTaskMiddleware } from "./definers/defineTaskMiddleware";
 export { defineResourceMiddleware } from "./definers/defineResourceMiddleware";
 export { defineOverride } from "./definers/defineOverride";
 export { defineTag } from "./definers/defineTag";
-export { isTask, isPhantomTask, isResource, isResourceWithConfig, isEvent, isHook, isTaskMiddleware, isResourceMiddleware, isTag, isOptional, } from "./definers/tools";
+export { isTask, isPhantomTask, isResource, isResourceWithConfig, isEvent, isHook, isTaskMiddleware, isResourceMiddleware, isTag, isOptional, isError, isAsyncContext, } from "./definers/tools";

package/dist/definers/builders/asyncContext.d.ts

@@ -0,0 +1,11 @@
+import type { IAsyncContext } from "../../types/asyncContext";
+import type { IValidationSchema } from "../../types/utilities";
+export interface AsyncContextFluentBuilder<T = unknown> {
+    id: string;
+    serialize(fn: (data: T) => string): AsyncContextFluentBuilder<T>;
+    parse(fn: (raw: string) => T): AsyncContextFluentBuilder<T>;
+    configSchema(schema: IValidationSchema<T>): AsyncContextFluentBuilder<T>;
+    build(): IAsyncContext<T>;
+}
+export declare function asyncContextBuilder<T = unknown>(id: string): AsyncContextFluentBuilder<T>;
+export declare const asyncContext: typeof asyncContextBuilder;

package/dist/definers/builders/error.d.ts

@@ -0,0 +1,13 @@
+import type { DefaultErrorType } from "../../types/error";
+import { ErrorHelper } from "../defineError";
+import type { IValidationSchema } from "../../types/utilities";
+export interface ErrorFluentBuilder<TData extends DefaultErrorType = DefaultErrorType> {
+    id: string;
+    serialize(fn: (data: TData) => string): ErrorFluentBuilder<TData>;
+    parse(fn: (raw: string) => TData): ErrorFluentBuilder<TData>;
+    dataSchema(schema: IValidationSchema<TData>): ErrorFluentBuilder<TData>;
+    build(): ErrorHelper<TData>;
+    format(fn: (data: TData) => string): ErrorFluentBuilder<TData>;
+}
+export declare function errorBuilder<TData extends DefaultErrorType = DefaultErrorType>(id: string): ErrorFluentBuilder<TData>;
+export declare const error: typeof errorBuilder;

package/dist/definers/builders/middleware.d.ts

@@ -1,4 +1,4 @@
-import type { DependencyMapType, ITaskMiddleware, ITaskMiddlewareDefinition, IResourceMiddleware, IResourceMiddlewareDefinition, IValidationSchema, IMiddlewareMeta, TagType } from "../../defs";
+import type { DependencyMapType, ITaskMiddleware, ITaskMiddlewareDefinition, IResourceMiddleware, IResourceMiddlewareDefinition, IValidationSchema, IMiddlewareMeta, TagType, ITask, IResource } from "../../defs";
 export interface TaskMiddlewareFluentBuilder<C = any, In = void, Out = void, D extends DependencyMapType = {}> {
     id: string;
     dependencies<TNewDeps extends DependencyMapType>(deps: TNewDeps | ((config: C) => TNewDeps), options?: {
@@ -13,7 +13,7 @@ export interface TaskMiddlewareFluentBuilder<C = any, In = void, Out = void, D e
     tags<TNewTags extends TagType[]>(t: TNewTags, options?: {
         override?: boolean;
     }): TaskMiddlewareFluentBuilder<C, In, Out, D>;
-    everywhere(flag: boolean | ((task: any) => boolean)): TaskMiddlewareFluentBuilder<C, In, Out, D>;
+    everywhere(flag: boolean | ((task: ITask<any, any, any, any>) => boolean)): TaskMiddlewareFluentBuilder<C, In, Out, D>;
     build(): ITaskMiddleware<C, In, Out, D>;
 }
 export declare function taskMiddlewareBuilder(id: string): TaskMiddlewareFluentBuilder<any, void, void, {}>;
@@ -31,7 +31,7 @@ export interface ResourceMiddlewareFluentBuilder<C = any, In = void, Out = void,
     tags<TNewTags extends TagType[]>(t: TNewTags, options?: {
         override?: boolean;
     }): ResourceMiddlewareFluentBuilder<C, In, Out, D>;
-    everywhere(flag: boolean | ((resource: any) => boolean)): ResourceMiddlewareFluentBuilder<C, In, Out, D>;
+    everywhere(flag: boolean | ((resource: IResource<any, any, any, any, any>) => boolean)): ResourceMiddlewareFluentBuilder<C, In, Out, D>;
     build(): IResourceMiddleware<C, In, Out, D>;
 }
 export declare function resourceMiddlewareBuilder(id: string): ResourceMiddlewareFluentBuilder<any, void, void, {}>;

package/dist/definers/defineAsyncContext.d.ts

@@ -0,0 +1,15 @@
+import { contextError } from "../errors";
+import { IAsyncContext, IAsyncContextDefinition } from "../types/asyncContext";
+export { contextError as ContextError };
+export declare const storage: import("../platform").IAsyncLocalStorage<Map<string, unknown>>;
+/** Returns the currently active store or undefined. */
+export declare function getCurrentStore(): Map<string, unknown> | undefined;
+/**
+ * Create a new typed Context. The result contains helpers similar to React’s
+ * Context API but adapted for async usage in Runner.
+ */
+export declare function defineAsyncContext<T>(def: IAsyncContextDefinition<T>): IAsyncContext<T>;
+export type { IAsyncContext } from "../types/asyncContext";
+/** Convenience creator allowing optional name. Used by tests and legacy API. */
+/** @deprecated Use defineAsyncContext instead */
+export declare function createContext<T>(name?: string): IAsyncContext<T>;

package/dist/definers/defineError.d.ts

@@ -0,0 +1,26 @@
+import { DefaultErrorType, IErrorDefinition, IErrorHelper, IErrorDefinitionFinal } from "../types/error";
+import { symbolError, symbolOptionalDependency } from "../types/symbols";
+declare class RunnerError<TData extends DefaultErrorType = DefaultErrorType> extends Error {
+    readonly id: string;
+    readonly data: TData;
+    constructor(id: string, message: string, data: TData);
+}
+export declare class ErrorHelper<TData extends DefaultErrorType = DefaultErrorType> implements IErrorHelper<TData> {
+    private readonly definition;
+    [symbolError]: true;
+    constructor(definition: IErrorDefinitionFinal<TData>);
+    get id(): string;
+    throw(data: TData): never;
+    is(error: unknown): error is RunnerError<TData>;
+    optional(): {
+        readonly inner: IErrorHelper<TData>;
+        readonly [symbolOptionalDependency]: true;
+    };
+}
+/**
+ * Create a new error that is going to be used
+ * @param definition
+ * @returns
+ */
+export declare function defineError<TData extends DefaultErrorType = DefaultErrorType>(definition: IErrorDefinition<TData>): ErrorHelper<TData>;
+export {};

package/dist/definers/tools.d.ts

@@ -2,6 +2,8 @@
  * Type guard and utility functions for checking definition types.
  */
 import { ITask, IResource, IResourceWithConfig, ITaskMiddleware, IResourceMiddleware, IEvent, IHook, IOptionalDependency, ITag, IPhantomTask } from "../defs";
+import { IErrorHelper } from "../types/error";
+import type { IAsyncContext } from "../types/asyncContext";
 /**
  * Type guard: checks if a definition is a Task.
  * @param definition - Any value to test.
@@ -45,3 +47,7 @@ export declare function isResourceMiddleware(definition: any): definition is IRe
 export declare function isTag(definition: any): definition is ITag;
 /** Type guard: checks if a definition is an Optional Dependency wrapper. */
 export declare function isOptional(definition: any): definition is IOptionalDependency<any>;
+/** Type guard: checks if a definition is an Error helper. */
+export declare function isError(definition: any): definition is IErrorHelper<any>;
+/** Type guard: checks if a definition is an Async Context. */
+export declare function isAsyncContext(definition: any): definition is IAsyncContext<any>;