@doeixd/machine 0.0.12 → 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

@@ -90,6 +90,7 @@ __export(src_exports, {
   runWithEnsemble: () => runWithEnsemble,
   runWithRunner: () => runWithRunner,
   setContext: () => setContext,
+  state: () => state,
   step: () => step,
   stepAsync: () => stepAsync,
   toggle: () => toggle,
@@ -2185,6 +2186,12 @@ function createFunctionalMachine(initialContext) {
     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) {