coremachine 1.0.0 → 1.0.1

package/dist/index.d.ts

@@ -0,0 +1,80 @@
+import Hypercore from "hypercore";
+import { Duplex } from "streamx";
+export type MachineConfig<TContext extends Record<string, any> = Record<string, any>, TStates extends Record<string, StateConfig<TContext>> = Record<string, StateConfig<TContext>>> = {
+    initial: keyof TStates;
+    context: TContext;
+    states: TStates;
+};
+export type StateConfig<TContext extends Record<string, any>> = {
+    on: Record<string, TransitionConfig<TContext>>;
+};
+export type TransitionConfig<TContext extends Record<string, any>> = {
+    target: string;
+    action: (ctx: TContext, ...args: any[]) => void | Promise<void>;
+};
+export type ExtractContext<T> = T extends MachineConfig<infer C, any> ? C : never;
+export type ExtractStates<T> = T extends MachineConfig<any, infer S> ? keyof S : never;
+type ExtractActions<T> = T extends MachineConfig<any, infer S> ? S extends Record<string, {
+    on: Record<infer E, any>;
+}> ? E : never : never;
+type ExtractActionParams<T, E extends string> = T extends MachineConfig<any, infer S> ? {
+    [K in keyof S]: S[K] extends {
+        on: Record<E, {
+            action: (ctx: any, ...args: infer P) => any;
+        }>;
+    } ? P extends [infer First, ...any[]] ? First : undefined : never;
+}[keyof S] : never;
+type ExtractActionSignatures<T> = T extends MachineConfig<any, infer S> ? {
+    [K in ExtractActions<T>]: ExtractActionParams<T, K extends string ? K : never> extends never ? undefined : ExtractActionParams<T, K extends string ? K : never>;
+} : never;
+export declare function createMachine<TContext extends Record<string, any>, TStates extends Record<string, StateConfig<TContext>>>(config: MachineConfig<TContext, TStates> & {
+    initial: keyof TStates;
+    context: TContext;
+    states: TStates;
+}): MachineConfig<TContext, TStates>;
+export declare function inferActions<T extends MachineConfig<any, any>>(machine: T): ExtractActionSignatures<T>;
+export type Infer<T extends MachineConfig<any, any>> = ReturnType<typeof inferActions<T>>;
+export type ActionMessage<T extends MachineConfig<any, any>> = {
+    [E in ExtractActions<T> & string]: ExtractActionParams<T, E> extends never ? {
+        action: E;
+        value?: undefined;
+    } : undefined extends ExtractActionParams<T, E> ? {
+        action: E;
+        value?: ExtractActionParams<T, E>;
+    } : {
+        action: E;
+        value: ExtractActionParams<T, E>;
+    };
+}[ExtractActions<T> & string];
+export type StateMessage<T extends MachineConfig<any, any>> = {
+    state: ExtractStates<T>;
+    context: ExtractContext<T>;
+};
+interface CoremachineOptions {
+    eager?: boolean;
+}
+export declare class Coremachine<T extends MachineConfig<any, any>> extends Duplex<ActionMessage<T>, StateMessage<T>> {
+    private _core;
+    private _machine;
+    private _state;
+    private _context;
+    private _currentIndex;
+    private _eager;
+    constructor(core: Hypercore, machine: T, opts?: CoremachineOptions);
+    _open(cb: (err?: Error | null) => void): void;
+    _write(chunk: ActionMessage<T>, cb: (err?: Error | null) => void): void;
+    _read(cb: (err?: Error | null) => void): void;
+    _destroy(cb: (err?: Error | null) => void): void;
+    action<E extends ExtractActions<T>>(action: E, value?: ExtractActionParams<T, E extends string ? E : never>): Promise<{
+        state: ExtractStates<T>;
+        context: ExtractContext<T>;
+    }>;
+    forward(): Promise<void>;
+    backward(): Promise<void>;
+    truncate(newLength: number): any;
+    get state(): ExtractStates<T>;
+    get context(): ExtractContext<T>;
+    get isEmpty(): boolean;
+    getAvailableActions(): Array<ExtractActions<T>>;
+}
+export {};

package/dist/index.js

@@ -0,0 +1,120 @@
+import { Duplex } from "streamx";
+// Improved createMachine function with better type inference
+export function createMachine(config) {
+    return config;
+}
+// Utility function to infer action types and payloads
+export function inferActions(machine) {
+    const result = {};
+    // Collect all action names from all states
+    for (const stateName in machine.states) {
+        const state = machine.states[stateName];
+        for (const action in state.on) {
+            result[action] = undefined; // Placeholder for type inference
+        }
+    }
+    return result;
+}
+export class Coremachine extends Duplex {
+    constructor(core, machine, opts = {}) {
+        super();
+        this._currentIndex = null;
+        this._eager = false;
+        this._core = core;
+        this._machine = machine;
+        this._state = machine.initial;
+        this._context = structuredClone(machine.context);
+        this._eager = Boolean(opts.eager);
+    }
+    _open(cb) {
+        this._core
+            .ready()
+            .then(async () => {
+            if (this._core.length > 0) {
+                const lastState = await this._core.get(this._core.length - 1);
+                this._state = lastState.state;
+                this._context = lastState.context;
+                const currentState = this._machine.states[this._state];
+                if (currentState?.on.start?.target) {
+                    this._state = currentState.on.start.target;
+                }
+                if (currentState?.on.start?.action) {
+                    await currentState.on.start.action(this._context, this._state);
+                }
+                if (this._eager) {
+                    // @ts-ignore
+                    this.push({ state: this._state, context: this._context });
+                }
+            }
+            cb();
+        })
+            .catch(cb);
+    }
+    _write(chunk, cb) {
+        this.action(chunk.action, chunk.value).then(() => cb(), cb);
+    }
+    _read(cb) {
+        cb();
+    }
+    _destroy(cb) {
+        this._core.close().then(() => cb(), cb);
+    }
+    async action(action, value) {
+        const currentState = this._machine.states[this._state];
+        const transition = currentState?.on[action] ||
+            this._machine.states.all?.[action];
+        if (!transition) {
+            throw new Error(`Invalid action: ${String(action)} for state ${this._state}`);
+        }
+        const oldState = structuredClone(this._context);
+        await transition.action(this._context, value);
+        await this._core.append({
+            state: transition.target || this._state,
+            context: this._context,
+        });
+        this._state = transition.target || this._state;
+        if (transition.target) {
+            // @ts-ignore
+            this.push({ state: this._state, context: this._context });
+        }
+        return { state: this._state, context: this._context };
+    }
+    async forward() {
+        const newIndex = this._currentIndex === null
+            ? this._core.length - 2
+            : this._currentIndex + 1;
+        if (this._core.length > newIndex && newIndex < this._core.length) {
+            const nextState = await this._core.get(newIndex);
+            this._state = nextState.state;
+            this._context = nextState.context;
+            this._currentIndex = newIndex;
+        }
+    }
+    async backward() {
+        const newIndex = this._currentIndex === null
+            ? this._core.length - 2
+            : this._currentIndex - 1;
+        if (this._core.length > newIndex && newIndex >= 0) {
+            const lastState = await this._core.get(newIndex);
+            this._state = lastState.state;
+            this._context = lastState.context;
+            this._currentIndex = newIndex;
+        }
+    }
+    truncate(newLength) {
+        return this._core.truncate(newLength);
+    }
+    get state() {
+        return this._state;
+    }
+    get context() {
+        return this._context;
+    }
+    get isEmpty() {
+        return this._core.length === 0;
+    }
+    getAvailableActions() {
+        const currentState = this._machine.states[this._state];
+        return Object.keys(currentState?.on || {});
+    }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "coremachine",
   "type": "module",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "author": {
     "name": "Dominic Cassidy",
     "email": "dominic@cassidy.casa",