@pyreon/machine 0.11.5 → 0.11.6

package/src/tests/guards.test.ts

@@ -1,108 +1,108 @@
-import { signal } from "@pyreon/reactivity"
-import { describe, expect, it, vi } from "vitest"
-import { createMachine } from "../index"
+import { signal } from '@pyreon/reactivity'
+import { describe, expect, it, vi } from 'vitest'
+import { createMachine } from '../index'
 
-describe("createMachine — guard conditions", () => {
-  it("transitions when guard returns true", () => {
+describe('createMachine — guard conditions', () => {
+  it('transitions when guard returns true', () => {
     const m = createMachine({
-      initial: "editing",
+      initial: 'editing',
       states: {
         editing: {
-          on: { SUBMIT: { target: "submitting", guard: () => true } },
+          on: { SUBMIT: { target: 'submitting', guard: () => true } },
         },
         submitting: {},
       },
     })
-    m.send("SUBMIT")
-    expect(m()).toBe("submitting")
+    m.send('SUBMIT')
+    expect(m()).toBe('submitting')
   })
 
-  it("blocks transition when guard returns false", () => {
+  it('blocks transition when guard returns false', () => {
     const m = createMachine({
-      initial: "editing",
+      initial: 'editing',
       states: {
         editing: {
-          on: { SUBMIT: { target: "submitting", guard: () => false } },
+          on: { SUBMIT: { target: 'submitting', guard: () => false } },
         },
         submitting: {},
       },
     })
-    m.send("SUBMIT")
-    expect(m()).toBe("editing")
+    m.send('SUBMIT')
+    expect(m()).toBe('editing')
   })
 
-  it("guard receives event payload", () => {
+  it('guard receives event payload', () => {
     const guardFn = vi.fn((payload?: unknown) => {
       return (payload as any)?.amount > 0
     })
 
     const m = createMachine({
-      initial: "idle",
+      initial: 'idle',
       states: {
         idle: {
-          on: { PAY: { target: "processing", guard: guardFn } },
+          on: { PAY: { target: 'processing', guard: guardFn } },
         },
         processing: {},
       },
     })
 
-    m.send("PAY", { amount: 0 })
-    expect(m()).toBe("idle")
+    m.send('PAY', { amount: 0 })
+    expect(m()).toBe('idle')
     expect(guardFn).toHaveBeenCalledWith({ amount: 0 })
 
-    m.send("PAY", { amount: 100 })
-    expect(m()).toBe("processing")
+    m.send('PAY', { amount: 100 })
+    expect(m()).toBe('processing')
     expect(guardFn).toHaveBeenCalledWith({ amount: 100 })
   })
 
-  it("guard without payload receives undefined", () => {
+  it('guard without payload receives undefined', () => {
     const guardFn = vi.fn(() => true)
 
     const m = createMachine({
-      initial: "idle",
+      initial: 'idle',
       states: {
         idle: {
-          on: { GO: { target: "active", guard: guardFn } },
+          on: { GO: { target: 'active', guard: guardFn } },
         },
         active: {},
       },
     })
 
-    m.send("GO")
+    m.send('GO')
     expect(guardFn).toHaveBeenCalledWith(undefined)
   })
 
-  it("guard with reactive signal dependency", () => {
+  it('guard with reactive signal dependency', () => {
     const isValid = signal(false)
 
     const m = createMachine({
-      initial: "editing",
+      initial: 'editing',
       states: {
         editing: {
           on: {
-            SUBMIT: { target: "submitting", guard: () => isValid.peek() },
+            SUBMIT: { target: 'submitting', guard: () => isValid.peek() },
           },
         },
         submitting: {},
       },
     })
 
-    m.send("SUBMIT")
-    expect(m()).toBe("editing") // guard blocks
+    m.send('SUBMIT')
+    expect(m()).toBe('editing') // guard blocks
 
     isValid.set(true)
-    m.send("SUBMIT")
-    expect(m()).toBe("submitting") // guard passes
+    m.send('SUBMIT')
+    expect(m()).toBe('submitting') // guard passes
   })
 
-  it("guard can check multiple conditions", () => {
+  it('guard can check multiple conditions', () => {
     const m = createMachine({
-      initial: "idle",
+      initial: 'idle',
       states: {
         idle: {
           on: {
             START: {
-              target: "running",
+              target: 'running',
               guard: (payload?: unknown) => {
                 const p = payload as { ready: boolean; count: number } | undefined
                 return p !== undefined && p.ready && p.count > 0
@@ -114,24 +114,24 @@ describe("createMachine — guard conditions", () => {
       },
     })
 
-    m.send("START", { ready: false, count: 5 })
-    expect(m()).toBe("idle")
+    m.send('START', { ready: false, count: 5 })
+    expect(m()).toBe('idle')
 
-    m.send("START", { ready: true, count: 0 })
-    expect(m()).toBe("idle")
+    m.send('START', { ready: true, count: 0 })
+    expect(m()).toBe('idle')
 
-    m.send("START", { ready: true, count: 5 })
-    expect(m()).toBe("running")
+    m.send('START', { ready: true, count: 5 })
+    expect(m()).toBe('running')
   })
 
-  it("different events on same state can have different guards", () => {
+  it('different events on same state can have different guards', () => {
     const m = createMachine({
-      initial: "editing",
+      initial: 'editing',
       states: {
         editing: {
           on: {
-            SAVE: { target: "saved", guard: () => true },
-            PUBLISH: { target: "published", guard: () => false },
+            SAVE: { target: 'saved', guard: () => true },
+            PUBLISH: { target: 'published', guard: () => false },
           },
         },
         saved: {},
@@ -139,40 +139,40 @@ describe("createMachine — guard conditions", () => {
       },
     })
 
-    m.send("PUBLISH")
-    expect(m()).toBe("editing") // guard blocks
+    m.send('PUBLISH')
+    expect(m()).toBe('editing') // guard blocks
 
-    m.send("SAVE")
-    expect(m()).toBe("saved") // guard passes
+    m.send('SAVE')
+    expect(m()).toBe('saved') // guard passes
   })
 
-  it("guard blocks do not fire onEnter or onTransition", () => {
+  it('guard blocks do not fire onEnter or onTransition', () => {
     const m = createMachine({
-      initial: "a",
+      initial: 'a',
       states: {
-        a: { on: { GO: { target: "b", guard: () => false } } },
+        a: { on: { GO: { target: 'b', guard: () => false } } },
         b: {},
       },
     })
 
     const enterFn = vi.fn()
     const transitionFn = vi.fn()
-    m.onEnter("b", enterFn)
+    m.onEnter('b', enterFn)
     m.onTransition(transitionFn)
 
-    m.send("GO")
+    m.send('GO')
     expect(enterFn).not.toHaveBeenCalled()
     expect(transitionFn).not.toHaveBeenCalled()
   })
 
-  it("mixing guarded and non-guarded transitions", () => {
+  it('mixing guarded and non-guarded transitions', () => {
     const m = createMachine({
-      initial: "idle",
+      initial: 'idle',
       states: {
         idle: {
           on: {
-            FETCH: "loading", // no guard
-            ADMIN: { target: "admin", guard: () => false }, // guarded
+            FETCH: 'loading', // no guard
+            ADMIN: { target: 'admin', guard: () => false }, // guarded
           },
         },
         loading: {},
@@ -180,10 +180,10 @@ describe("createMachine — guard conditions", () => {
       },
     })
 
-    m.send("ADMIN")
-    expect(m()).toBe("idle") // blocked
+    m.send('ADMIN')
+    expect(m()).toBe('idle') // blocked
 
-    m.send("FETCH")
-    expect(m()).toBe("loading") // no guard, passes
+    m.send('FETCH')
+    expect(m()).toBe('loading') // no guard, passes
   })
 })

package/src/tests/listeners.test.ts

@@ -1,105 +1,105 @@
-import { describe, expect, it, vi } from "vitest"
-import { createMachine } from "../index"
+import { describe, expect, it, vi } from 'vitest'
+import { createMachine } from '../index'
 
-describe("createMachine — onEnter callbacks", () => {
-  it("fires callback when entering the specified state", () => {
+describe('createMachine — onEnter callbacks', () => {
+  it('fires callback when entering the specified state', () => {
     const m = createMachine({
-      initial: "idle",
+      initial: 'idle',
       states: {
-        idle: { on: { LOAD: "loading" } },
-        loading: { on: { DONE: "idle" } },
+        idle: { on: { LOAD: 'loading' } },
+        loading: { on: { DONE: 'idle' } },
       },
     })
     const entered: string[] = []
 
-    m.onEnter("loading", (event) => {
+    m.onEnter('loading', (event) => {
       entered.push(event.type)
     })
 
-    m.send("LOAD")
-    expect(entered).toEqual(["LOAD"])
+    m.send('LOAD')
+    expect(entered).toEqual(['LOAD'])
   })
 
-  it("does not fire for other state entries", () => {
+  it('does not fire for other state entries', () => {
     const m = createMachine({
-      initial: "a",
+      initial: 'a',
       states: {
-        a: { on: { GO: "b" } },
-        b: { on: { GO: "c" } },
+        a: { on: { GO: 'b' } },
+        b: { on: { GO: 'c' } },
         c: {},
       },
     })
     const fn = vi.fn()
-    m.onEnter("c", fn)
+    m.onEnter('c', fn)
 
-    m.send("GO") // a -> b
+    m.send('GO') // a -> b
     expect(fn).not.toHaveBeenCalled()
 
-    m.send("GO") // b -> c
+    m.send('GO') // b -> c
     expect(fn).toHaveBeenCalledOnce()
   })
 
-  it("receives event payload", () => {
+  it('receives event payload', () => {
     const m = createMachine({
-      initial: "idle",
+      initial: 'idle',
       states: {
-        idle: { on: { SELECT: "selected" } },
+        idle: { on: { SELECT: 'selected' } },
         selected: {},
       },
     })
     let received: unknown = null
 
-    m.onEnter("selected", (event) => {
+    m.onEnter('selected', (event) => {
       received = event.payload
     })
 
-    m.send("SELECT", { id: 42, name: "item" })
-    expect(received).toEqual({ id: 42, name: "item" })
+    m.send('SELECT', { id: 42, name: 'item' })
+    expect(received).toEqual({ id: 42, name: 'item' })
   })
 
-  it("fires on self-transitions", () => {
+  it('fires on self-transitions', () => {
     const m = createMachine({
-      initial: "counting",
+      initial: 'counting',
       states: {
-        counting: { on: { INC: "counting" } },
+        counting: { on: { INC: 'counting' } },
       },
     })
     const fn = vi.fn()
-    m.onEnter("counting", fn)
+    m.onEnter('counting', fn)
 
-    m.send("INC")
-    m.send("INC")
-    m.send("INC")
+    m.send('INC')
+    m.send('INC')
+    m.send('INC')
 
     expect(fn).toHaveBeenCalledTimes(3)
   })
 
-  it("unsubscribe function stops future callbacks", () => {
+  it('unsubscribe function stops future callbacks', () => {
     const m = createMachine({
-      initial: "a",
+      initial: 'a',
       states: {
-        a: { on: { GO: "b" } },
-        b: { on: { GO: "a" } },
+        a: { on: { GO: 'b' } },
+        b: { on: { GO: 'a' } },
       },
     })
     const fn = vi.fn()
-    const unsub = m.onEnter("b", fn)
+    const unsub = m.onEnter('b', fn)
 
-    m.send("GO") // a -> b
+    m.send('GO') // a -> b
     expect(fn).toHaveBeenCalledOnce()
 
     unsub()
 
-    m.send("GO") // b -> a
-    m.send("GO") // a -> b again
+    m.send('GO') // b -> a
+    m.send('GO') // a -> b again
     expect(fn).toHaveBeenCalledOnce() // not called again
   })
 
-  it("multiple listeners for same state all fire", () => {
+  it('multiple listeners for same state all fire', () => {
     const m = createMachine({
-      initial: "idle",
+      initial: 'idle',
       states: {
-        idle: { on: { GO: "active" } },
+        idle: { on: { GO: 'active' } },
         active: {},
       },
     })
@@ -107,40 +107,40 @@ describe("createMachine — onEnter callbacks", () => {
     const fn2 = vi.fn()
     const fn3 = vi.fn()
 
-    m.onEnter("active", fn1)
-    m.onEnter("active", fn2)
-    m.onEnter("active", fn3)
+    m.onEnter('active', fn1)
+    m.onEnter('active', fn2)
+    m.onEnter('active', fn3)
 
-    m.send("GO")
+    m.send('GO')
     expect(fn1).toHaveBeenCalledOnce()
     expect(fn2).toHaveBeenCalledOnce()
     expect(fn3).toHaveBeenCalledOnce()
   })
 
-  it("onEnter for a state that is never entered is never called", () => {
+  it('onEnter for a state that is never entered is never called', () => {
     const m = createMachine({
-      initial: "idle",
+      initial: 'idle',
       states: {
-        idle: { on: { GO: "active" } },
+        idle: { on: { GO: 'active' } },
         active: {},
         unreachable: {},
       },
     })
     const fn = vi.fn()
-    m.onEnter("unreachable", fn)
+    m.onEnter('unreachable', fn)
 
-    m.send("GO")
+    m.send('GO')
     expect(fn).not.toHaveBeenCalled()
   })
 })
 
-describe("createMachine — onTransition callbacks", () => {
-  it("fires on every state transition", () => {
+describe('createMachine — onTransition callbacks', () => {
+  it('fires on every state transition', () => {
     const m = createMachine({
-      initial: "a",
+      initial: 'a',
       states: {
-        a: { on: { NEXT: "b" } },
-        b: { on: { NEXT: "c" } },
+        a: { on: { NEXT: 'b' } },
+        b: { on: { NEXT: 'c' } },
         c: {},
       },
     })
@@ -150,36 +150,36 @@ describe("createMachine — onTransition callbacks", () => {
       transitions.push([from, to, event.type])
     })
 
-    m.send("NEXT") // a -> b
-    m.send("NEXT") // b -> c
+    m.send('NEXT') // a -> b
+    m.send('NEXT') // b -> c
 
     expect(transitions).toEqual([
-      ["a", "b", "NEXT"],
-      ["b", "c", "NEXT"],
+      ['a', 'b', 'NEXT'],
+      ['b', 'c', 'NEXT'],
     ])
   })
 
-  it("does not fire when event is ignored (no valid transition)", () => {
+  it('does not fire when event is ignored (no valid transition)', () => {
     const m = createMachine({
-      initial: "idle",
+      initial: 'idle',
       states: {
-        idle: { on: { START: "running" } },
+        idle: { on: { START: 'running' } },
         running: {},
       },
     })
     const fn = vi.fn()
     m.onTransition(fn)
 
-    m.send("STOP" as any) // invalid
+    m.send('STOP' as any) // invalid
     expect(fn).not.toHaveBeenCalled()
   })
 
-  it("does not fire when guard blocks transition", () => {
+  it('does not fire when guard blocks transition', () => {
     const m = createMachine({
-      initial: "idle",
+      initial: 'idle',
       states: {
         idle: {
-          on: { GO: { target: "active", guard: () => false } },
+          on: { GO: { target: 'active', guard: () => false } },
         },
         active: {},
       },
@@ -187,15 +187,15 @@ describe("createMachine — onTransition callbacks", () => {
     const fn = vi.fn()
     m.onTransition(fn)
 
-    m.send("GO")
+    m.send('GO')
     expect(fn).not.toHaveBeenCalled()
   })
 
-  it("receives event payload", () => {
+  it('receives event payload', () => {
     const m = createMachine({
-      initial: "idle",
+      initial: 'idle',
       states: {
-        idle: { on: { LOAD: "loading" } },
+        idle: { on: { LOAD: 'loading' } },
         loading: {},
       },
     })
@@ -205,56 +205,56 @@ describe("createMachine — onTransition callbacks", () => {
       receivedPayload = event.payload
     })
 
-    m.send("LOAD", { url: "/api/data" })
-    expect(receivedPayload).toEqual({ url: "/api/data" })
+    m.send('LOAD', { url: '/api/data' })
+    expect(receivedPayload).toEqual({ url: '/api/data' })
   })
 
-  it("fires on self-transitions", () => {
+  it('fires on self-transitions', () => {
     const m = createMachine({
-      initial: "counting",
+      initial: 'counting',
       states: {
-        counting: { on: { INC: "counting" } },
+        counting: { on: { INC: 'counting' } },
       },
     })
     const fn = vi.fn()
     m.onTransition(fn)
 
-    m.send("INC")
-    m.send("INC")
+    m.send('INC')
+    m.send('INC')
 
     expect(fn).toHaveBeenCalledTimes(2)
     expect(fn).toHaveBeenCalledWith(
-      "counting",
-      "counting",
-      expect.objectContaining({ type: "INC" }),
+      'counting',
+      'counting',
+      expect.objectContaining({ type: 'INC' }),
     )
   })
 
-  it("unsubscribe stops future callbacks", () => {
+  it('unsubscribe stops future callbacks', () => {
     const m = createMachine({
-      initial: "a",
+      initial: 'a',
       states: {
-        a: { on: { GO: "b" } },
-        b: { on: { GO: "a" } },
+        a: { on: { GO: 'b' } },
+        b: { on: { GO: 'a' } },
       },
     })
     const fn = vi.fn()
     const unsub = m.onTransition(fn)
 
-    m.send("GO")
+    m.send('GO')
     expect(fn).toHaveBeenCalledOnce()
 
     unsub()
-    m.send("GO")
-    m.send("GO")
+    m.send('GO')
+    m.send('GO')
     expect(fn).toHaveBeenCalledOnce()
   })
 
-  it("multiple transition listeners all fire", () => {
+  it('multiple transition listeners all fire', () => {
     const m = createMachine({
-      initial: "idle",
+      initial: 'idle',
       states: {
-        idle: { on: { GO: "active" } },
+        idle: { on: { GO: 'active' } },
         active: {},
       },
     })
@@ -264,25 +264,25 @@ describe("createMachine — onTransition callbacks", () => {
     m.onTransition(fn1)
     m.onTransition(fn2)
 
-    m.send("GO")
+    m.send('GO')
     expect(fn1).toHaveBeenCalledOnce()
     expect(fn2).toHaveBeenCalledOnce()
   })
 
-  it("onTransition fires before onEnter", () => {
+  it('onTransition fires before onEnter', () => {
     const m = createMachine({
-      initial: "idle",
+      initial: 'idle',
       states: {
-        idle: { on: { GO: "active" } },
+        idle: { on: { GO: 'active' } },
         active: {},
       },
     })
     const order: string[] = []
 
-    m.onTransition(() => order.push("transition"))
-    m.onEnter("active", () => order.push("enter"))
+    m.onTransition(() => order.push('transition'))
+    m.onEnter('active', () => order.push('enter'))
 
-    m.send("GO")
-    expect(order).toEqual(["transition", "enter"])
+    m.send('GO')
+    expect(order).toEqual(['transition', 'enter'])
   })
 })