@mantaq/core 0.0.1

package/dist/actor-internal-CfZDmHJ3.d.mts

@@ -0,0 +1,89 @@
+//#region src/state.d.ts
+declare function state<const T extends string>(id: T): <Payload = unknown>() => StateRef<T, Payload, false>;
+type AnyStateRef = StateRef<string, unknown, boolean>;
+interface RegionOptions {
+  initial: string;
+  states: Record<string, AnyStateRef>;
+}
+type RegionsOptions = Record<string, RegionOptions>;
+declare class StateRef<T extends string, Payload = unknown, IsFinal extends boolean = false> {
+  readonly name: T;
+  readonly isFinal: IsFinal;
+  /** @internal */ _regions: RegionsOptions | undefined;
+  constructor(name: T, isFinal: IsFinal);
+  regions(options: RegionsOptions): this;
+  final(): StateRef<T, Payload, true>;
+  create(payload: Payload): {
+    state: StateRef<T, Payload, IsFinal>;
+    payload: Payload;
+  };
+}
+//#endregion
+//#region src/event.d.ts
+declare function event<const T extends string>(id: T): <Payload extends object | void = void>() => EventRef<T, Payload>;
+type AnyEventRef = EventRef<string, object | void>;
+type InternalEvent = {
+  id: string;
+} & Record<string, unknown>;
+type CreatedOfEvent<Id extends string, P> = P extends void ? {
+  id: Id;
+} : P & {
+  id: Id;
+};
+declare class EventRef<const T extends string, Payload extends object | void = void> {
+  readonly id: T;
+  constructor(id: T);
+  is(anyEvent: unknown): anyEvent is CreatedOfEvent<T, Payload>;
+  create(): Payload extends void ? {
+    id: T;
+  } : void;
+  create(payload: Payload): Payload extends void ? {
+    id: T;
+  } : Payload & {
+    id: T;
+  };
+}
+//#endregion
+//#region src/clock.d.ts
+interface Clock {
+  setTimeout(ms: number, cb: () => void, options?: {
+    signal?: AbortSignal;
+    eventName?: string;
+  }): number;
+  clearTimeout(id: number): void;
+  setInterval(ms: number, cb: () => void, options?: {
+    signal?: AbortSignal;
+  }): number;
+  clearInterval(id: number): void;
+  now(): number;
+  /** Optional hook for draining queues after clock advances (VirtualClock). */
+  setDrain?(fn: () => void): void;
+}
+//#endregion
+//#region src/actor-internal.d.ts
+interface Snapshot {
+  path: string[];
+  regions: Record<string, Snapshot>;
+  done?: boolean;
+}
+interface AnyActor {
+  state: AnyStateRef;
+  clock: Clock;
+  regions: Record<string, AnyActor>;
+  send(event: AnyEventRef | InternalEvent): void;
+  snapshot(): Snapshot;
+  on(event: "change", fn: (snapshot: Snapshot) => void): () => void;
+  on(event: "done", fn: () => void): () => void;
+  settled(): Promise<void>;
+  context?: Record<string, unknown>;
+  options?: {
+    transitions?: Record<string, Record<string, unknown>>;
+    effects?: Record<string, unknown[]>;
+    states?: ReadonlyArray<{
+      name: string;
+      isFinal: boolean;
+    }>;
+  };
+}
+//#endregion
+export { CreatedOfEvent as a, event as c, state as d, AnyEventRef as i, AnyStateRef as l, Snapshot as n, EventRef as o, Clock as r, InternalEvent as s, AnyActor as t, StateRef as u };

package/dist/index.d.mts

@@ -0,0 +1,151 @@
+import { a as CreatedOfEvent, c as event, d as state, i as AnyEventRef, l as AnyStateRef, n as Snapshot, o as EventRef, r as Clock, s as InternalEvent, t as AnyActor, u as StateRef } from "./actor-internal-CfZDmHJ3.mjs";
+//#region src/real-clock.d.ts
+declare class RealClock implements Clock {
+  #private;
+  now(): number;
+  setTimeout(ms: number, cb: () => void, options?: {
+    signal?: AbortSignal;
+    eventName?: string;
+  }): number;
+  clearTimeout(id: number): void;
+  setInterval(ms: number, cb: () => void, options?: {
+    signal?: AbortSignal;
+  }): number;
+  clearInterval(id: number): void;
+}
+//#endregion
+//#region src/virtual-clock.d.ts
+declare class VirtualClock implements Clock {
+  #private;
+  now(): number;
+  setTimeout(ms: number, cb: () => void, options?: {
+    signal?: AbortSignal;
+    eventName?: string;
+  }): number;
+  clearTimeout(id: number): void;
+  setInterval(ms: number, cb: () => void, options?: {
+    signal?: AbortSignal;
+  }): number;
+  clearInterval(id: number): void;
+  advance(ms: number): void;
+  hasPending(): boolean;
+  pendingTimers(): Array<{
+    id: number;
+    deadline: number;
+    ms: number;
+    eventName?: string;
+  }>;
+  setDrain(fn: () => void): void;
+}
+//#endregion
+//#region src/actor-types.d.ts
+type CreatedOf<E extends AnyEventRef> = E extends EventRef<infer Id, infer P> ? CreatedOfEvent<Id, P> : never;
+type NonFinalStateRef<States extends AnyStateRef[]> = Extract<States[number], {
+  isFinal: false;
+}>;
+interface EffectInput<ActorContext> {
+  signal: AbortSignal;
+  state: {
+    name: string;
+    payload: unknown;
+  };
+  event: InternalEvent;
+  context: ActorContext;
+  emit: (event: InternalEvent) => void;
+  clock: Clock;
+}
+type EffectFn<ActorContext> = (input: EffectInput<ActorContext>) => void;
+type TransitionResult<AllowedState extends AnyStateRef = AnyStateRef, AllowedEmit extends string = string> = {
+  state?: AllowedState | {
+    state: AllowedState;
+    payload?: unknown;
+  };
+  payload?: unknown;
+  emit?: Array<{
+    id: AllowedEmit;
+  }>;
+};
+//#endregion
+//#region src/builder.d.ts
+type EventIdOf<E extends AnyEventRef> = E extends EventRef<infer Id, object | void> ? Id : never;
+type TransitionHandler<States extends readonly AnyStateRef[], ActorContext> = (event: InternalEvent, opts: {
+  context: ActorContext;
+  actor: AnyActor;
+}) => TransitionResult<States[number], string>;
+interface BuiltMaps<States extends readonly AnyStateRef[], ActorContext> {
+  transitions: Record<string, Record<string, TransitionHandler<States, ActorContext>>>;
+  effects: Record<string, Array<EffectFn<ActorContext>>>;
+}
+declare class ActorBuilder<States extends readonly AnyStateRef[], Inputs extends readonly AnyEventRef[], Internal extends readonly AnyEventRef[], Outputs extends readonly AnyEventRef[], ActorContext> {
+  #private;
+  on<S extends States[number], E extends Inputs[number] | Internal[number]>(stateRef: S, eventRef: E, fn: (event: E extends EventRef<infer Id, infer P> ? CreatedOfEvent<Id, P> : never, opts: {
+    context: ActorContext;
+    actor: AnyActor;
+  }) => TransitionResult<States[number], EventIdOf<Outputs[number]>>): this;
+  onAny<E extends Inputs[number] | Internal[number]>(eventRef: E, fn: (event: E extends EventRef<infer Id, infer P> ? CreatedOfEvent<Id, P> : never, opts: {
+    context: ActorContext;
+    actor: AnyActor;
+  }) => TransitionResult<States[number], EventIdOf<Outputs[number]>>): this;
+  effect<S extends States[number]>(stateRef: S, fn: EffectFn<ActorContext>): this;
+  /** @internal */ build(): BuiltMaps<States, ActorContext>;
+}
+type SetupFn<States extends readonly AnyStateRef[], Inputs extends readonly AnyEventRef[], Internal extends readonly AnyEventRef[], Outputs extends readonly AnyEventRef[], ActorContext> = (m: ActorBuilder<States, Inputs, Internal, Outputs, ActorContext>) => void;
+//#endregion
+//#region src/actor.d.ts
+type CreatedOf$1<E extends AnyEventRef> = E extends EventRef<infer Id, infer P> ? (P extends void ? {
+  id: Id;
+} : P & {
+  id: Id;
+}) : never;
+type InitialState<S extends AnyStateRef> = S extends StateRef<infer _N extends string, infer P> ? [unknown] extends [P] ? S | {
+  state: S;
+  payload?: P;
+} : {
+  state: S;
+  payload: P;
+} : never;
+interface ActorOptions<States extends readonly AnyStateRef[], Inputs extends readonly AnyEventRef[], Internal extends readonly AnyEventRef[], Outputs extends readonly AnyEventRef[], ActorContext = Record<string, unknown>> {
+  inputs: Inputs;
+  outputs?: Outputs;
+  internal?: Internal;
+  states: States;
+  context?: ActorContext;
+  initial: InitialState<States[number]>;
+  clock?: Clock;
+  internalBudget?: number;
+  setup: SetupFn<States, Inputs, Internal, Outputs, ActorContext>;
+  regions?: Record<string, AnyActor>;
+}
+interface InternalActorOptions<States extends readonly AnyStateRef[], Inputs extends readonly AnyEventRef[], Internal extends readonly AnyEventRef[], Outputs extends readonly AnyEventRef[], ActorContext = Record<string, unknown>> {
+  inputs: Inputs;
+  outputs?: Outputs;
+  internal?: Internal;
+  states: States;
+  context?: ActorContext;
+  initial: InitialState<States[number]>;
+  clock?: Clock;
+  internalBudget?: number;
+  transitions: TransitionDispatch<States, ActorContext>;
+  effects: Record<string, Array<EffectFn<ActorContext>>>;
+  regions?: Record<string, AnyActor>;
+}
+type TransitionDispatch<States extends readonly AnyStateRef[], ActorContext> = Record<string, Record<string, ((event: InternalEvent, options: {
+  context: ActorContext;
+  actor: AnyActor;
+}) => TransitionResult<States[number], string>) | undefined>>;
+declare class Actor<const States extends readonly AnyStateRef[], const Inputs extends readonly AnyEventRef[], const Internal extends readonly AnyEventRef[] = readonly [], const Outputs extends readonly AnyEventRef[] = readonly [], ActorContext = Record<string, unknown>> {
+  #private;
+  state: States[number];
+  readonly clock: Clock;
+  get context(): ActorContext;
+  get regions(): Record<string, AnyActor>;
+  get options(): InternalActorOptions<States, Inputs, Internal, Outputs, ActorContext>;
+  constructor(options: ActorOptions<States, Inputs, Internal, Outputs, ActorContext>);
+  on(event: "change", fn: (snapshot: Snapshot) => void): () => void;
+  on(event: "done", fn: () => void): () => void;
+  settled(): Promise<void>;
+  send(event: CreatedOf$1<Inputs[number]>): void;
+  snapshot(): Snapshot;
+}
+//#endregion
+export { Actor, type ActorBuilder, type AnyActor, type AnyEventRef, type AnyStateRef, type Clock, type CreatedOf, type CreatedOfEvent, type EffectFn, type EffectInput, EventRef, type InternalEvent, type NonFinalStateRef, RealClock, type SetupFn, type Snapshot, StateRef, VirtualClock, event, state };