abxbus 2.4.1

package/dist/cjs/async_context.js

@@ -0,0 +1,70 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var async_context_exports = {};
+__export(async_context_exports, {
+  _runWithAsyncContext: () => _runWithAsyncContext,
+  async_local_storage: () => async_local_storage,
+  captureAsyncContext: () => captureAsyncContext,
+  createAsyncLocalStorage: () => createAsyncLocalStorage,
+  hasAsyncLocalStorage: () => hasAsyncLocalStorage
+});
+module.exports = __toCommonJS(async_context_exports);
+let _AsyncLocalStorageClass = null;
+const is_node = typeof process !== "undefined" && typeof process.versions !== "undefined" && typeof process.versions.node === "string";
+const loadAsyncLocalStorageClass = () => {
+  if (!is_node) return null;
+  const maybe_process = globalThis.process;
+  const get_builtin_module = maybe_process?.getBuiltinModule;
+  if (typeof get_builtin_module === "function") {
+    const mod = get_builtin_module("node:async_hooks");
+    if (mod?.AsyncLocalStorage) {
+      return mod.AsyncLocalStorage;
+    }
+  }
+  try {
+    const maybe_require = Function('return typeof require === "function" ? require : undefined')();
+    const mod = maybe_require?.("node:async_hooks");
+    if (mod?.AsyncLocalStorage) {
+      return mod.AsyncLocalStorage;
+    }
+  } catch {
+    return null;
+  }
+  return null;
+};
+_AsyncLocalStorageClass = loadAsyncLocalStorageClass();
+const createAsyncLocalStorage = () => {
+  if (!_AsyncLocalStorageClass) return null;
+  return new _AsyncLocalStorageClass();
+};
+let async_local_storage = _AsyncLocalStorageClass ? new _AsyncLocalStorageClass() : null;
+const captureAsyncContext = () => {
+  if (!async_local_storage) {
+    return null;
+  }
+  return async_local_storage.getStore() ?? null;
+};
+const _runWithAsyncContext = (context, fn) => {
+  if (!async_local_storage) {
+    return fn();
+  }
+  return async_local_storage.run(context ?? void 0, fn);
+};
+const hasAsyncLocalStorage = () => async_local_storage !== null;
+//# sourceMappingURL=async_context.js.map

package/dist/cjs/async_context.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/async_context.ts"],
+  "sourcesContent": ["declare const process: { versions?: { node?: string } } | undefined\n\ntype AsyncLocalStorageLike = {\n  getStore(): unknown\n  run<T>(store: unknown, callback: () => T): T\n  enterWith?(store: unknown): void\n}\n\nexport type { AsyncLocalStorageLike }\n\n// Cache the AsyncLocalStorage constructor so multiple modules can create separate instances.\nlet _AsyncLocalStorageClass: (new () => AsyncLocalStorageLike) | null = null\n\nconst is_node = typeof process !== 'undefined' && typeof process.versions !== 'undefined' && typeof process.versions.node === 'string'\n\nconst loadAsyncLocalStorageClass = (): (new () => AsyncLocalStorageLike) | null => {\n  if (!is_node) return null\n\n  // Prefer process.getBuiltinModule when available (works in ESM and CJS without top-level await).\n  const maybe_process = (globalThis as { process?: { getBuiltinModule?: (name: string) => unknown } }).process\n  const get_builtin_module = maybe_process?.getBuiltinModule\n  if (typeof get_builtin_module === 'function') {\n    const mod = get_builtin_module('node:async_hooks') as { AsyncLocalStorage?: new () => AsyncLocalStorageLike } | undefined\n    if (mod?.AsyncLocalStorage) {\n      return mod.AsyncLocalStorage\n    }\n  }\n\n  // Fallback for older Node runtimes where require is available.\n  try {\n    const maybe_require = Function('return typeof require === \"function\" ? require : undefined')() as\n      | ((specifier: string) => { AsyncLocalStorage?: new () => AsyncLocalStorageLike })\n      | undefined\n    const mod = maybe_require?.('node:async_hooks')\n    if (mod?.AsyncLocalStorage) {\n      return mod.AsyncLocalStorage\n    }\n  } catch {\n    return null\n  }\n\n  return null\n}\n\n_AsyncLocalStorageClass = loadAsyncLocalStorageClass()\n\n/** Create a new AsyncLocalStorage instance, or null if unavailable (e.g. in browsers). */\nexport const createAsyncLocalStorage = (): AsyncLocalStorageLike | null => {\n  if (!_AsyncLocalStorageClass) return null\n  return new _AsyncLocalStorageClass()\n}\n\n// The primary AsyncLocalStorage instance used for event dispatch context propagation.\nexport let async_local_storage: AsyncLocalStorageLike | null = _AsyncLocalStorageClass ? new _AsyncLocalStorageClass() : null\n\nexport const captureAsyncContext = (): unknown | null => {\n  if (!async_local_storage) {\n    return null\n  }\n  return async_local_storage.getStore() ?? null\n}\n\nexport const _runWithAsyncContext = <T>(context: unknown | null, fn: () => T): T => {\n  if (!async_local_storage) {\n    return fn()\n  }\n  return async_local_storage.run(context ?? undefined, fn)\n}\n\nexport const hasAsyncLocalStorage = (): boolean => async_local_storage !== null\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAWA,IAAI,0BAAoE;AAExE,MAAM,UAAU,OAAO,YAAY,eAAe,OAAO,QAAQ,aAAa,eAAe,OAAO,QAAQ,SAAS,SAAS;AAE9H,MAAM,6BAA6B,MAAgD;AACjF,MAAI,CAAC,QAAS,QAAO;AAGrB,QAAM,gBAAiB,WAA8E;AACrG,QAAM,qBAAqB,eAAe;AAC1C,MAAI,OAAO,uBAAuB,YAAY;AAC5C,UAAM,MAAM,mBAAmB,kBAAkB;AACjD,QAAI,KAAK,mBAAmB;AAC1B,aAAO,IAAI;AAAA,IACb;AAAA,EACF;AAGA,MAAI;AACF,UAAM,gBAAgB,SAAS,4DAA4D,EAAE;AAG7F,UAAM,MAAM,gBAAgB,kBAAkB;AAC9C,QAAI,KAAK,mBAAmB;AAC1B,aAAO,IAAI;AAAA,IACb;AAAA,EACF,QAAQ;AACN,WAAO;AAAA,EACT;AAEA,SAAO;AACT;AAEA,0BAA0B,2BAA2B;AAG9C,MAAM,0BAA0B,MAAoC;AACzE,MAAI,CAAC,wBAAyB,QAAO;AACrC,SAAO,IAAI,wBAAwB;AACrC;AAGO,IAAI,sBAAoD,0BAA0B,IAAI,wBAAwB,IAAI;AAElH,MAAM,sBAAsB,MAAsB;AACvD,MAAI,CAAC,qBAAqB;AACxB,WAAO;AAAA,EACT;AACA,SAAO,oBAAoB,SAAS,KAAK;AAC3C;AAEO,MAAM,uBAAuB,CAAI,SAAyB,OAAmB;AAClF,MAAI,CAAC,qBAAqB;AACxB,WAAO,GAAG;AAAA,EACZ;AACA,SAAO,oBAAoB,IAAI,WAAW,QAAW,EAAE;AACzD;AAEO,MAAM,uBAAuB,MAAe,wBAAwB;",
+  "names": []
+}

package/dist/cjs/base_event.d.ts

@@ -0,0 +1,207 @@
+import { z } from 'zod';
+import { EventBus } from './event_bus.js';
+import { EventResult } from './event_result.js';
+import { EventHandler } from './event_handler.js';
+import type { EventConcurrencyMode, EventHandlerConcurrencyMode, EventHandlerCompletionMode, Deferred } from './lock_manager.js';
+import { AsyncLock } from './lock_manager.js';
+import type { EventHandlerCallable, EventResultType } from './types.js';
+export declare const BaseEventSchema: z.ZodObject<{
+    event_id: z.ZodString;
+    event_created_at: z.ZodString;
+    event_type: z.ZodString;
+    event_version: z.ZodDefault<z.ZodString>;
+    event_timeout: z.ZodNullable<z.ZodNumber>;
+    event_slow_timeout: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    event_handler_timeout: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    event_handler_slow_timeout: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    event_parent_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    event_path: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    event_result_type: z.ZodOptional<z.ZodUnknown>;
+    event_emitted_by_handler_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    event_pending_bus_count: z.ZodOptional<z.ZodNumber>;
+    event_status: z.ZodOptional<z.ZodEnum<{
+        pending: "pending";
+        started: "started";
+        completed: "completed";
+    }>>;
+    event_started_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    event_completed_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    event_results: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+    event_concurrency: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        "global-serial": "global-serial";
+        "bus-serial": "bus-serial";
+        parallel: "parallel";
+    }>>>;
+    event_handler_concurrency: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        parallel: "parallel";
+        serial: "serial";
+    }>>>;
+    event_handler_completion: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        all: "all";
+        first: "first";
+    }>>>;
+}, z.core.$loose>;
+export type BaseEventData = z.infer<typeof BaseEventSchema>;
+export type BaseEventJSON = BaseEventData & Record<string, unknown>;
+type BaseEventFields = Pick<BaseEventData, 'event_id' | 'event_created_at' | 'event_type' | 'event_version' | 'event_timeout' | 'event_slow_timeout' | 'event_handler_timeout' | 'event_handler_slow_timeout' | 'event_parent_id' | 'event_path' | 'event_result_type' | 'event_emitted_by_handler_id' | 'event_pending_bus_count' | 'event_status' | 'event_started_at' | 'event_completed_at' | 'event_results' | 'event_concurrency' | 'event_handler_concurrency' | 'event_handler_completion'>;
+export type BaseEventInit<TFields extends Record<string, unknown>> = TFields & Partial<BaseEventFields>;
+type BaseEventSchemaShape = typeof BaseEventSchema.shape;
+export type EventSchema<TShape extends z.ZodRawShape> = z.ZodObject<BaseEventSchemaShape & TShape>;
+type EventPayload<TShape extends z.ZodRawShape> = TShape extends Record<string, never> ? {} : z.infer<z.ZodObject<TShape>>;
+type EventInput<TShape extends z.ZodRawShape> = z.input<EventSchema<TShape>>;
+export type EventInit<TShape extends z.ZodRawShape> = Omit<EventInput<TShape>, keyof BaseEventFields> & Partial<BaseEventFields>;
+type EventWithResultSchema<TResult> = BaseEvent & {
+    __event_result_type__?: TResult;
+};
+type ResultTypeFromEventResultTypeInput<TInput> = TInput extends z.ZodTypeAny ? z.infer<TInput> : TInput extends StringConstructor ? string : TInput extends NumberConstructor ? number : TInput extends BooleanConstructor ? boolean : TInput extends ArrayConstructor ? unknown[] : TInput extends ObjectConstructor ? Record<string, unknown> : unknown;
+type ResultSchemaFromShape<TShape> = TShape extends {
+    event_result_type: infer S;
+} ? ResultTypeFromEventResultTypeInput<S> : unknown;
+type EventResultsListInclude<TEvent extends BaseEvent> = (result: EventResultType<TEvent> | undefined, event_result: EventResult<TEvent>) => boolean;
+type EventResultsListOptions<TEvent extends BaseEvent> = {
+    timeout?: number | null;
+    include?: EventResultsListInclude<TEvent>;
+    raise_if_any?: boolean;
+    raise_if_none?: boolean;
+};
+type EventDoneOptions = {
+    raise_if_any?: boolean;
+};
+type EventResultUpdateOptions<TEvent extends BaseEvent> = {
+    eventbus?: EventBus;
+    status?: 'pending' | 'started' | 'completed' | 'error';
+    result?: EventResultType<TEvent> | BaseEvent | undefined;
+    error?: unknown;
+};
+export type EventFactory<TShape extends z.ZodRawShape, TResult = unknown> = {
+    (data: EventInit<TShape>): EventWithResultSchema<TResult> & EventPayload<TShape>;
+    new (data: EventInit<TShape>): EventWithResultSchema<TResult> & EventPayload<TShape>;
+    schema: EventSchema<TShape>;
+    class?: new (data: EventInit<TShape>) => EventWithResultSchema<TResult> & EventPayload<TShape>;
+    event_type?: string;
+    event_version?: string;
+    event_result_type?: z.ZodTypeAny;
+    fromJSON?: (data: unknown) => EventWithResultSchema<TResult> & EventPayload<TShape>;
+};
+type ZodShapeFrom<TShape extends Record<string, unknown>> = {
+    [K in keyof TShape as K extends 'event_result_type' ? never : TShape[K] extends z.ZodTypeAny ? K : never]: Extract<TShape[K], z.ZodTypeAny>;
+};
+export declare class BaseEvent {
+    event_id: string;
+    event_created_at: string;
+    event_type: string;
+    event_version: string;
+    event_timeout: number | null;
+    event_slow_timeout?: number | null;
+    event_handler_timeout?: number | null;
+    event_handler_slow_timeout?: number | null;
+    event_parent_id: string | null;
+    event_path: string[];
+    event_result_type?: z.ZodTypeAny;
+    event_results: Map<string, EventResult<this>>;
+    event_emitted_by_handler_id: string | null;
+    event_pending_bus_count: number;
+    event_status: 'pending' | 'started' | 'completed';
+    event_started_at: string | null;
+    event_completed_at: string | null;
+    event_concurrency?: EventConcurrencyMode | null;
+    event_handler_concurrency?: EventHandlerConcurrencyMode | null;
+    event_handler_completion?: EventHandlerCompletionMode | null;
+    static event_type?: string;
+    static event_version: string;
+    static schema: z.ZodObject<{
+        event_id: z.ZodString;
+        event_created_at: z.ZodString;
+        event_type: z.ZodString;
+        event_version: z.ZodDefault<z.ZodString>;
+        event_timeout: z.ZodNullable<z.ZodNumber>;
+        event_slow_timeout: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        event_handler_timeout: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        event_handler_slow_timeout: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        event_parent_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        event_path: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        event_result_type: z.ZodOptional<z.ZodUnknown>;
+        event_emitted_by_handler_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        event_pending_bus_count: z.ZodOptional<z.ZodNumber>;
+        event_status: z.ZodOptional<z.ZodEnum<{
+            pending: "pending";
+            started: "started";
+            completed: "completed";
+        }>>;
+        event_started_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        event_completed_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        event_results: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+        event_concurrency: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+            "global-serial": "global-serial";
+            "bus-serial": "bus-serial";
+            parallel: "parallel";
+        }>>>;
+        event_handler_concurrency: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+            parallel: "parallel";
+            serial: "serial";
+        }>>>;
+        event_handler_completion: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+            all: "all";
+            first: "first";
+        }>>>;
+    }, z.core.$loose>;
+    bus?: EventBus;
+    _event_original?: BaseEvent;
+    _event_dispatch_context?: unknown | null;
+    _event_completed_signal: Deferred<this> | null;
+    _lock_for_event_handler: AsyncLock | null;
+    get event_bus(): EventBus;
+    constructor(data?: BaseEventInit<Record<string, unknown>>);
+    toString(): string;
+    static extend<TShape extends z.ZodRawShape>(event_type: string, shape?: TShape): EventFactory<TShape, ResultSchemaFromShape<TShape>>;
+    static extend<TShape extends Record<string, unknown>>(event_type: string, shape?: TShape): EventFactory<ZodShapeFrom<TShape>, ResultSchemaFromShape<TShape>>;
+    static fromJSON<T extends typeof BaseEvent>(this: T, data: unknown): InstanceType<T>;
+    static toJSONArray(events: Iterable<BaseEvent>): BaseEventJSON[];
+    static fromJSONArray(data: unknown): BaseEvent[];
+    toJSON(): BaseEventJSON;
+    _createSlowEventWarningTimer(): ReturnType<typeof setTimeout> | null;
+    eventResultUpdate(handler: EventHandler | EventHandlerCallable<this>, options?: EventResultUpdateOptions<this>): EventResult<this>;
+    _createPendingHandlerResults(bus: EventBus): Array<{
+        handler: EventHandler;
+        result: EventResult;
+    }>;
+    private _collectPendingResults;
+    private _isFirstModeWinningResult;
+    private _markFirstModeWinnerIfNeeded;
+    private _runHandlerWithLock;
+    _runHandlers(pending_entries?: Array<{
+        handler: EventHandler;
+        result: EventResult;
+    }>): Promise<void>;
+    _getHandlerLock(default_concurrency?: EventHandlerConcurrencyMode): AsyncLock | null;
+    _setHandlerLock(lock: AsyncLock | null): void;
+    _getDispatchContext(): unknown | null | undefined;
+    _setDispatchContext(dispatch_context: unknown | null | undefined): void;
+    get event_parent(): BaseEvent | undefined;
+    get event_children(): BaseEvent[];
+    get event_descendants(): BaseEvent[];
+    _cancelPendingChildProcessing(reason: unknown): void;
+    _markRemainingFirstModeResultCancelled(winner: EventResult): void;
+    _markCancelled(cause: Error): void;
+    _notifyEventParentsOfCompletion(): void;
+    done(options?: EventDoneOptions): Promise<this>;
+    first(): Promise<EventResultType<this> | undefined>;
+    eventResultsList(include: EventResultsListInclude<this>, options?: EventResultsListOptions<this>): Promise<Array<EventResultType<this> | undefined>>;
+    eventResultsList(options?: EventResultsListOptions<this>): Promise<Array<EventResultType<this> | undefined>>;
+    eventCompleted(): Promise<this>;
+    _markPending(): this;
+    eventReset(): this;
+    _markStarted(started_at?: string | null, notify_hook?: boolean): void;
+    _markCompleted(force?: boolean, notify_parents?: boolean): void;
+    private dropFromZeroHistoryBuses;
+    get event_errors(): unknown[];
+    private _isFirstModeControlError;
+    _firstProcessingError(options?: {
+        ignore_first_mode_control_errors?: boolean;
+    }): unknown | undefined;
+    get event_result(): EventResultType<this> | undefined;
+    _areAllChildrenComplete(): boolean;
+    private _notifyDoneListeners;
+    _gc(): void;
+}
+export {};