@doeixd/machine 0.0.11 → 0.0.13

package/README.md

@@ -112,6 +112,29 @@ counter.increment();
 console.log(counter.context.count); // 1 (mutated in place)
 ```
 
+### Smart State Creation with `state()`
+
+The `state()` function automatically chooses between traditional and functional patterns:
+
+```typescript
+import { state } from "@doeixd/machine";
+
+// Traditional pattern (like createMachine)
+const counter1 = state({ count: 0 }, {
+  increment() { return state({ count: this.context.count + 1 }, this); }
+});
+
+// Functional pattern (like createFunctionalMachine)
+const createCounter = state({ count: 0 });
+const counter2 = createCounter({
+  increment: ctx => ({ count: ctx.count + 1 }),
+  add: (ctx, n: number) => ({ count: ctx.count + n })
+});
+
+console.log(counter1.increment().context.count); // 1
+console.log(counter2.increment().add(5).context.count); // 6
+```
+
 This shows the **flexibility** of the library: immutability is the default pattern because it's safer, but you can choose mutability when it makes sense for your use case.
 
 ### Type-State Programming (Compile-Time State Safety)

package/dist/cjs/development/index.js

@@ -38,9 +38,11 @@ __export(src_exports, {
   createAsyncMachine: () => createAsyncMachine,
   createCustomMiddleware: () => createCustomMiddleware,
   createEnsemble: () => createEnsemble,
+  createEnsembleFactory: () => createEnsembleFactory,
   createEvent: () => createEvent,
   createFetchMachine: () => createFetchMachine,
   createFlow: () => createFlow,
+  createFunctionalMachine: () => createFunctionalMachine,
   createMachine: () => createMachine,
   createMachineBuilder: () => createMachineBuilder,
   createMachineFactory: () => createMachineFactory,
@@ -51,6 +53,9 @@ __export(src_exports, {
   createParallelMachine: () => createParallelMachine,
   createPipeline: () => createPipeline,
   createRunner: () => createRunner,
+  createTransition: () => createTransition,
+  createTransitionExtender: () => createTransitionExtender,
+  createTransitionFactory: () => createTransitionFactory,
   delegateToChild: () => delegateToChild,
   describe: () => describe,
   extendTransitions: () => extendTransitions,
@@ -85,6 +90,7 @@ __export(src_exports, {
   runWithEnsemble: () => runWithEnsemble,
   runWithRunner: () => runWithRunner,
   setContext: () => setContext,
+  state: () => state,
   step: () => step,
   stepAsync: () => stepAsync,
   toggle: () => toggle,
@@ -935,6 +941,11 @@ function createEnsemble(store, factories, getDiscriminant) {
     actions
   };
 }
+function createEnsembleFactory(store, getDiscriminant) {
+  return function withFactories(factories) {
+    return createEnsemble(store, factories, getDiscriminant);
+  };
+}
 function runWithRunner(flow, initialMachine) {
   const runner = createRunner(initialMachine);
   const generator = flow(runner);
@@ -2084,6 +2095,12 @@ function logState(machine, label) {
   }
   return machine;
 }
+function createTransition(getTransitions, transformer) {
+  return function(...args) {
+    const nextContext = transformer(this.context, ...args);
+    return createMachine(nextContext, getTransitions());
+  };
+}
 function call(fn, context, ...args) {
   return fn.apply(context, args);
 }
@@ -2131,6 +2148,51 @@ var BoundMachine = class _BoundMachine {
   }
 };
 
+// src/functional-combinators.ts
+function createTransitionFactory() {
+  return function createTransition2(transformer) {
+    return function(...args) {
+      const nextContext = transformer(this.context, ...args);
+      return createMachine(nextContext, this);
+    };
+  };
+}
+function createTransitionExtender(machine) {
+  return {
+    machine,
+    addTransition: function(name, transformer) {
+      const transitionFn = function(...args) {
+        const nextContext = transformer(this.context, ...args);
+        return createMachine(nextContext, this);
+      };
+      const newMachine = extendTransitions(machine, { [name]: transitionFn });
+      return createTransitionExtender(newMachine);
+    }
+  };
+}
+function createFunctionalMachine(initialContext) {
+  return function withTransitions(transformers) {
+    const transitions = {};
+    const machineTransitions = Object.fromEntries(
+      Object.entries(transformers).map(([key, transformer]) => [
+        key,
+        function(...args) {
+          const nextContext = transformer(this.context, ...args);
+          return createMachine(nextContext, transitions);
+        }
+      ])
+    );
+    Object.assign(transitions, machineTransitions);
+    return createMachine(initialContext, transitions);
+  };
+}
+function state(context, transitions) {
+  if (transitions !== void 0) {
+    return createMachine(context, transitions);
+  }
+  return createFunctionalMachine(context);
+}
+
 // src/index.ts
 function createMachine(context, fns) {
   const transitions = "context" in fns ? Object.fromEntries(