@doeixd/machine 0.0.17 → 0.0.19

package/dist/types/matcher.d.ts

@@ -0,0 +1,318 @@
+/**
+ * @file Advanced Pattern Matching for State Machines
+ * @description
+ * Provides type-safe pattern matching utilities for discriminating between machine types.
+ * Supports three complementary APIs: type guards, exhaustive pattern matching, and simple matching.
+ *
+ * @example
+ * ```typescript
+ * // Define a matcher for class-based machines
+ * const match = createMatcher(
+ *   classCase('idle', IdleMachine),
+ *   classCase('loading', LoadingMachine),
+ *   classCase('success', SuccessMachine)
+ * );
+ *
+ * // API 1: Type Guards
+ * if (match.is.loading(machine)) {
+ *   // machine is narrowed to LoadingMachine
+ * }
+ *
+ * // API 2: Exhaustive Pattern Matching
+ * const result = match.when(machine).is<string>(
+ *   match.case.idle(() => 'idle'),
+ *   match.case.loading(() => 'loading'),
+ *   match.case.success(m => m.context.data),
+ *   match.exhaustive
+ * );
+ *
+ * // API 3: Simple Match
+ * const name = match(machine); // 'idle' | 'loading' | 'success' | null
+ * ```
+ */
+import type { Machine, Context } from './index';
+/**
+ * A matcher case tuple that defines a state pattern.
+ *
+ * @template Name - The unique name for this case (used for type guards and pattern matching)
+ * @template M - The machine type this case matches
+ * @template Pred - The predicate function that determines if a machine matches this case
+ */
+export type MatcherCase<Name extends string, M, Pred extends (m: any) => m is M> = readonly [
+    name: Name,
+    machineType: M,
+    predicate: Pred
+];
+/**
+ * Extracts the machine type from a MatcherCase.
+ */
+type CaseToMachine<C> = C extends MatcherCase<any, infer M, any> ? M : never;
+/**
+ * Extracts the case name from a MatcherCase.
+ */
+type CaseToName<C> = C extends MatcherCase<infer Name, any, any> ? Name : never;
+/**
+ * Builds a mapping from case names to their machine types.
+ */
+export type CasesToMapping<Cases extends readonly MatcherCase<any, any, any>[]> = {
+    [C in Cases[number] as CaseToName<C>]: CaseToMachine<C>;
+};
+/**
+ * Creates a union of all possible machine types from the cases.
+ */
+export type MatcherUnion<Cases extends readonly MatcherCase<any, any, any>[]> = Cases[number] extends MatcherCase<any, infer M, any> ? M : never;
+/**
+ * Extracts the union of all case names.
+ */
+export type CaseNames<Cases extends readonly MatcherCase<any, any, any>[]> = CaseToName<Cases[number]>;
+/**
+ * A branded type representing a case handler in pattern matching.
+ * This is used internally to track which cases have been handled.
+ */
+export type CaseHandler<Name extends string, M, R> = {
+    readonly __brand: 'CaseHandler';
+    readonly __name: Name;
+    readonly __machine: M;
+    readonly __return: R;
+    readonly handler: (machine: M) => R;
+};
+/**
+ * Exhaustiveness marker - signals that all cases must be handled.
+ */
+export type ExhaustivenessMarker = {
+    readonly __exhaustive: true;
+};
+/**
+ * Extracts machine types from an array of case handlers.
+ */
+type HandledMachines<Handlers extends readonly any[]> = Handlers extends readonly [infer H, ...infer Rest] ? (H extends CaseHandler<any, infer M, any> ? M : never) | HandledMachines<Rest> : never;
+/**
+ * Checks if all machine types in Union have been handled.
+ * Returns true if exhaustive, otherwise returns an error type with missing cases.
+ */
+export type IsExhaustive<Union, Handled> = Exclude<Union, Handled> extends never ? true : {
+    readonly __error: 'Non-exhaustive match - missing cases';
+    readonly __missing: Exclude<Union, Handled>;
+};
+/**
+ * Pattern matching builder returned by matcher.when().
+ */
+export interface WhenBuilder<_Cases extends readonly MatcherCase<any, any, any>[], M> {
+    /**
+     * Execute pattern matching with exhaustiveness checking.
+     *
+     * @template R - The return type of all handlers
+     * @param handlers - Array of case handlers followed by exhaustiveness marker
+     * @returns The result of the matched handler, or compile error if not exhaustive
+     *
+     * @example
+     * ```typescript
+     * match.when(machine).is<string>(
+     *   match.case.idle(() => 'idle'),
+     *   match.case.loading(() => 'loading'),
+     *   match.exhaustive
+     * );
+     * ```
+     */
+    is<R>(...handlers: [...any[], ExhaustivenessMarker]): IsExhaustive<M, HandledMachines<typeof handlers>> extends true ? R : IsExhaustive<M, HandledMachines<typeof handlers>>;
+}
+/**
+ * The main Matcher interface with three APIs.
+ */
+export interface Matcher<Cases extends readonly MatcherCase<any, any, any>[]> {
+    /**
+     * API 1: Type guard access via dynamic properties.
+     *
+     * @example
+     * ```typescript
+     * if (match.is.loading(machine)) {
+     *   // machine is narrowed to LoadingMachine
+     * }
+     * ```
+     */
+    readonly is: {
+        [Name in CaseNames<Cases>]: <M>(machine: M) => machine is Extract<M, CasesToMapping<Cases>[Name]>;
+    };
+    /**
+     * API 2a: Pattern matching builder.
+     *
+     * @example
+     * ```typescript
+     * match.when(machine).is<string>(
+     *   match.case.idle(() => 'idle'),
+     *   match.case.loading(() => 'loading'),
+     *   match.exhaustive
+     * );
+     * ```
+     */
+    when: <M>(machine: M) => WhenBuilder<Cases, M>;
+    /**
+     * API 2b: Case handler creator for pattern matching.
+     *
+     * @example
+     * ```typescript
+     * match.case.loading((m) => `Loading: ${m.context.startTime}`)
+     * ```
+     */
+    readonly case: {
+        [Name in CaseNames<Cases>]: <R>(handler: (machine: CasesToMapping<Cases>[Name]) => R) => CaseHandler<Name, CasesToMapping<Cases>[Name], R>;
+    };
+    /**
+     * API 2c: Exhaustiveness marker for pattern matching.
+     */
+    readonly exhaustive: ExhaustivenessMarker;
+    /**
+     * API 3: Simple match - returns the name of the matched case or null.
+     *
+     * @example
+     * ```typescript
+     * const name = match(machine); // 'idle' | 'loading' | 'success' | null
+     * ```
+     */
+    <M>(machine: M): M extends MatcherUnion<Cases> ? CaseNames<Cases> | null : null;
+}
+/**
+ * Creates a type-safe matcher for discriminating between machine types.
+ *
+ * @template Cases - Tuple of [name, MachineType, predicate] configurations
+ * @param cases - Array of matcher case definitions
+ * @returns A matcher object with three APIs: is (type guards), when (pattern matching), and direct call (simple match)
+ *
+ * @example
+ * ```typescript
+ * // Class-based matching
+ * const match = createMatcher(
+ *   ['idle', IdleMachine, (m): m is IdleMachine => m instanceof IdleMachine],
+ *   ['loading', LoadingMachine, (m): m is LoadingMachine => m instanceof LoadingMachine]
+ * );
+ *
+ * // Or use helper functions
+ * const match = createMatcher(
+ *   classCase('idle', IdleMachine),
+ *   classCase('loading', LoadingMachine)
+ * );
+ * ```
+ */
+export declare function createMatcher<const Cases extends readonly MatcherCase<string, any, (m: any) => m is any>[]>(...cases: Cases): Matcher<Cases>;
+/**
+ * Creates a class-based matcher case using instanceof checking.
+ * This is the most common pattern for Type-State machines.
+ *
+ * @template Name - The unique name for this case
+ * @template T - The class constructor
+ * @param name - The name to use for this case
+ * @param machineClass - The class to check with instanceof
+ * @returns A matcher case tuple
+ *
+ * @example
+ * ```typescript
+ * const match = createMatcher(
+ *   classCase('idle', IdleMachine),
+ *   classCase('loading', LoadingMachine),
+ *   classCase('success', SuccessMachine)
+ * );
+ * ```
+ */
+export declare function classCase<Name extends string, T extends abstract new (...args: any[]) => any>(name: Name, machineClass: T): MatcherCase<Name, InstanceType<T>, (m: any) => m is InstanceType<T>>;
+/**
+ * Creates a discriminated union matcher case based on a context property.
+ * This integrates with the existing hasState utility for context-based discrimination.
+ *
+ * @template Name - The unique name for this case
+ * @template M - The machine type (use Machine<YourContextUnion> for proper narrowing)
+ * @template K - The context key to check
+ * @template V - The value to match
+ * @param name - The name to use for this case
+ * @param key - The context property to check
+ * @param value - The value the property should equal
+ * @returns A matcher case tuple
+ *
+ * @example
+ * ```typescript
+ * type FetchContext =
+ *   | { status: 'idle' }
+ *   | { status: 'loading' }
+ *   | { status: 'success'; data: string };
+ *
+ * const match = createMatcher(
+ *   discriminantCase<'idle', Machine<FetchContext>, 'status', 'idle'>('idle', 'status', 'idle'),
+ *   discriminantCase<'loading', Machine<FetchContext>, 'status', 'loading'>('loading', 'status', 'loading'),
+ *   discriminantCase<'success', Machine<FetchContext>, 'status', 'success'>('success', 'status', 'success')
+ * );
+ * ```
+ */
+export declare function discriminantCase<Name extends string, M extends Machine<any> = Machine<any>, K extends keyof Context<M> = any, V extends Context<M>[K] = any>(name: Name, key: K, value: V): MatcherCase<Name, M & {
+    context: Extract<Context<M>, {
+        [P in K]: V;
+    }>;
+}, (m: M) => m is M & {
+    context: Extract<Context<M>, {
+        [P in K]: V;
+    }>;
+}>;
+/**
+ * Creates a custom matcher case with a user-defined predicate.
+ * For advanced matching logic beyond instanceof or discriminants.
+ *
+ * @template Name - The unique name for this case
+ * @template M - The machine type this case matches (inferred from predicate)
+ * @param name - The name to use for this case
+ * @param predicate - A type guard function that determines if a machine matches
+ * @returns A matcher case tuple
+ *
+ * @example
+ * ```typescript
+ * const match = createMatcher(
+ *   customCase('complex', (m): m is ComplexMachine => {
+ *     return m.context.value > 10 && m.context.status === 'active';
+ *   })
+ * );
+ * ```
+ */
+export declare function customCase<const Name extends string, M>(name: Name, predicate: (m: any) => m is M): MatcherCase<Name, M, (m: any) => m is M>;
+/**
+ * Creates a discriminated matcher builder for a specific context union type.
+ * Provides better type inference by capturing the context type upfront.
+ *
+ * @template C - The discriminated union context type
+ * @returns A builder object with a `case` method for defining cases with less boilerplate
+ *
+ * @example
+ * ```typescript
+ * type FetchContext =
+ *   | { status: 'idle' }
+ *   | { status: 'loading'; startTime: number }
+ *   | { status: 'success'; data: string };
+ *
+ * const builder = forContext<FetchContext>();
+ *
+ * const match = createMatcher(
+ *   builder.case('idle', 'status', 'idle'),
+ *   builder.case('loading', 'status', 'loading'),
+ *   builder.case('success', 'status', 'success')
+ * );
+ *
+ * // Full type inference and narrowing works!
+ * if (match.is.success(machine)) {
+ *   console.log(machine.context.data); // ✓ TypeScript knows data exists
+ * }
+ * ```
+ */
+export declare function forContext<C extends object>(): {
+    /**
+     * Creates a discriminated union case with full type inference.
+     */
+    case<Name extends string, K extends keyof C, V extends C[K]>(name: Name, key: K, value: V): MatcherCase<Name, {
+        readonly context: C;
+    } & {
+        context: Extract<C, { [P in K]: V; }>;
+    }, (m: {
+        readonly context: C;
+    }) => m is {
+        readonly context: C;
+    } & {
+        context: Extract<C, { [P in K]: V; }>;
+    }>;
+};
+export {};
+//# sourceMappingURL=matcher.d.ts.map

package/dist/types/matcher.d.ts.map

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@doeixd/machine",
-  "version": "0.0.17",
+  "version": "0.0.19",
   "files": [
     "dist",
     "src"
@@ -115,12 +115,24 @@
       },
       "require": "./dist/cjs/production/core.js",
       "import": "./dist/esm/production/core.js"
+    },
+    "./extract": {
+      "types": "./dist/types/extract.d.ts",
+      "development": {
+        "require": "./dist/cjs/development/extract.js",
+        "import": "./dist/esm/development/extract.js"
+      },
+      "require": "./dist/cjs/production/extract.js",
+      "import": "./dist/esm/production/extract.js"
     }
   },
   "typesVersions": {
     "*": {
       "core": [
         "./dist/types/core.d.ts"
+      ],
+      "extract": [
+        "./dist/types/extract.d.ts"
       ]
     }
   },

package/src/extract.ts

@@ -106,8 +106,8 @@ export interface ExtractionConfig {
  * @returns A JSON-compatible value (string, number, object, array).
  * @internal
  */
-// @ts-expect-error - verbose parameter is used but TypeScript doesn't detect it
-function _typeToJson(type: Type, verbose = false): any {
+
+export function _typeToJson(type: Type, verbose = false): any {
   // --- Terminal Types ---
   const symbol = type.getSymbol();
   if (symbol && symbol.getDeclarations().some(Node.isClassDeclaration)) {
@@ -324,65 +324,65 @@ function extractFromCallExpression(call: Node, verbose = false): any | null {
       break;
 
     case 'action':
-       // Args: (action, transition)
-       if (args[0]) {
-         const actionMeta = parseObjectLiteral(args[0]);
-         if (Object.keys(actionMeta).length > 0) {
-           metadata.actions = [actionMeta];
-         }
-       }
-       // Recurse into wrapped transition
-       if (args[1] && Node.isCallExpression(args[1])) {
-         const nested = extractFromCallExpression(args[1], verbose);
-         if (nested) {
-           Object.assign(metadata, nested);
-         }
-       }
-       break;
-
-     case 'guard':
-       // Args: (condition, transition, options?)
-       // Extract description from options object (third argument)
-       if (args[2]) {
-         const options = parseObjectLiteral(args[2]);
-         if (options.description) {
-           metadata.description = options.description;
-         }
-       }
-       // Add a generic guard condition for static analysis
-       metadata.guards = [{ name: 'runtime_guard', description: metadata.description || 'Synchronous condition check' }];
-       // Recurse into the transition (second argument)
-       if (args[1] && Node.isCallExpression(args[1])) {
-         const nested = extractFromCallExpression(args[1], verbose);
-         if (nested) {
-           Object.assign(metadata, nested);
-         }
-       }
-       break;
-
-     case 'guardAsync':
-       // Args: (condition, transition, options?)
-       // Extract description from options object (third argument)
-       if (args[2]) {
-         const options = parseObjectLiteral(args[2]);
-         if (options.description) {
-           metadata.description = options.description;
-         }
-       }
-       // Add a generic guard condition for static analysis
-       metadata.guards = [{ name: 'runtime_guard_async', description: metadata.description || 'Asynchronous condition check' }];
-       // Recurse into the transition (second argument)
-       if (args[1] && Node.isCallExpression(args[1])) {
-         const nested = extractFromCallExpression(args[1], verbose);
-         if (nested) {
-           Object.assign(metadata, nested);
-         }
-       }
-       break;
-
-     default:
-       // Not a DSL primitive we recognize
-       return null;
+      // Args: (action, transition)
+      if (args[0]) {
+        const actionMeta = parseObjectLiteral(args[0]);
+        if (Object.keys(actionMeta).length > 0) {
+          metadata.actions = [actionMeta];
+        }
+      }
+      // Recurse into wrapped transition
+      if (args[1] && Node.isCallExpression(args[1])) {
+        const nested = extractFromCallExpression(args[1], verbose);
+        if (nested) {
+          Object.assign(metadata, nested);
+        }
+      }
+      break;
+
+    case 'guard':
+      // Args: (condition, transition, options?)
+      // Extract description from options object (third argument)
+      if (args[2]) {
+        const options = parseObjectLiteral(args[2]);
+        if (options.description) {
+          metadata.description = options.description;
+        }
+      }
+      // Add a generic guard condition for static analysis
+      metadata.guards = [{ name: 'runtime_guard', description: metadata.description || 'Synchronous condition check' }];
+      // Recurse into the transition (second argument)
+      if (args[1] && Node.isCallExpression(args[1])) {
+        const nested = extractFromCallExpression(args[1], verbose);
+        if (nested) {
+          Object.assign(metadata, nested);
+        }
+      }
+      break;
+
+    case 'guardAsync':
+      // Args: (condition, transition, options?)
+      // Extract description from options object (third argument)
+      if (args[2]) {
+        const options = parseObjectLiteral(args[2]);
+        if (options.description) {
+          metadata.description = options.description;
+        }
+      }
+      // Add a generic guard condition for static analysis
+      metadata.guards = [{ name: 'runtime_guard_async', description: metadata.description || 'Asynchronous condition check' }];
+      // Recurse into the transition (second argument)
+      if (args[1] && Node.isCallExpression(args[1])) {
+        const nested = extractFromCallExpression(args[1], verbose);
+        if (nested) {
+          Object.assign(metadata, nested);
+        }
+      }
+      break;
+
+    default:
+      // Not a DSL primitive we recognize
+      return null;
   }
 
   return Object.keys(metadata).length > 0 ? metadata : null;

package/src/generators.ts

@@ -135,12 +135,12 @@ export function run<C extends any = any, M extends { context: C } & Record<strin
 
     // If the generator has returned (done), we have our final value
     if (done) {
-      return value;
+      return value as T;
     }
 
     // Otherwise, the yielded value becomes our new current state
     // This state will be sent back into the generator on the next iteration
-    current = value;
+    current = value as M;
   }
 }
 
@@ -346,10 +346,10 @@ export function runWithDebug<C extends any = any, M extends { context: C } & Rec
 
     if (done) {
       console.log('Final:', value);
-      return value;
+      return value as T;
     }
 
-    current = value;
+    current = value as M;
     stepCount++;
     logger(stepCount, current);
   }
@@ -391,10 +391,10 @@ export async function runAsync<C extends any = any, M extends { context: C } & R
     const { value, done } = await generator.next(current);
 
     if (done) {
-      return value;
+      return value as T;
     }
 
-    current = value;
+    current = value as M;
   }
 }