@doeixd/machine 0.0.13 → 0.0.18

package/src/prototype_functional.ts

@@ -0,0 +1,46 @@
+// Mocking the core types for the prototype
+type Machine<C, T> = { context: C } & T;
+
+function createMachineInternal<C, T>(context: C, transitions: T): Machine<C, T> {
+  return Object.assign({ context }, transitions) as Machine<C, T>;
+}
+
+// Proposed API
+// fn takes a 'transition' helper and returns the transitions object
+export function createMachine<C, T extends Record<string, (this: C, ...args: any[]) => any>>(
+  context: C,
+  fn: (transition: (newContext: C) => Machine<C, T>) => T
+): Machine<C, T> {
+  // We need to handle the circularity:
+  // T depends on the return type of fn.
+  // fn needs 'transition' which returns Machine<C, T>.
+
+  // In runtime:
+  let transitions: T;
+
+  const transition = (newContext: C) => {
+    return createMachineInternal(newContext, transitions);
+  };
+
+  transitions = fn(transition);
+
+  return createMachineInternal(context, transitions);
+}
+
+// Usage Test
+type Context = { count: number };
+
+const machine = createMachine({ count: 0 }, (transition) => ({
+  inc() {
+    // 'this' should be Context
+    return transition({ count: this.count + 1 });
+  },
+  add(n: number) {
+    return transition({ count: this.count + n });
+  }
+}));
+
+// Verify types
+const next = machine.inc(); // Should be Machine<Context, ...>
+const val = next.context.count;
+const next2 = next.add(5);

package/src/reproduce_issue.ts

@@ -0,0 +1,26 @@
+import { createMachine } from './index';
+
+type ContextA = { count: number };
+type ContextB = { text: string };
+
+const machineA = createMachine<ContextA, any>({ count: 0 }, {
+  next() {
+    // Check if this.transitions exists
+    console.log('this.transitions is:', (this as any).transitions);
+
+    // Passing `this` which includes `context: ContextA`
+    // to a machine that expects `ContextB`.
+    return createMachine<ContextB, any>({ text: "hello" }, this);
+  }
+});
+
+// Check the type of machineA.next()
+const machineB = machineA.next();
+
+// machineB.context should be ContextB
+// But if the issue exists, it might have issues.
+const text: string = machineB.context.text;
+
+// Let's try to access a property that shouldn't exist if types are correct
+// @ts-expect-error
+const count: number = machineB.context.count;