@pyreon/state-tree 0.24.4 → 0.24.6

package/src/tests/comprehensive.test.ts

@@ -1,485 +0,0 @@
-import { computed, effect } from '@pyreon/reactivity'
-import type { Patch } from '../index'
-import {
-  addMiddleware,
-  applyPatch,
-  applySnapshot,
-  getSnapshot,
-  model,
-  onPatch,
-  resetAllHooks,
-  resetHook,
-} from '../index'
-
-// ─── Fixtures ─────────────────────────────────────────────────────────────────
-
-const Counter = model({
-  state: { count: 0 },
-  views: (self) => ({
-    doubled: computed(() => self.count() * 2),
-  }),
-  actions: (self) => ({
-    inc: () => self.count.update((c: number) => c + 1),
-    dec: () => self.count.update((c: number) => c - 1),
-    add: (n: number) => self.count.update((c: number) => c + n),
-    reset: () => self.count.set(0),
-  }),
-})
-
-const Profile = model({
-  state: { name: '', bio: '' },
-  actions: (self) => ({
-    rename: (n: string) => self.name.set(n),
-    setBio: (b: string) => self.bio.set(b),
-  }),
-})
-
-const App = model({
-  state: { profile: Profile, title: 'My App' },
-  actions: (self) => ({
-    setTitle: (t: string) => self.title.set(t),
-  }),
-})
-
-// ─── getSnapshot — JSON-serializable output ────────────────────────────────
-
-describe('getSnapshot — JSON-serializable output', () => {
-  it("returns a plain object that can be JSON.stringify'd and parsed back", () => {
-    const c = Counter.create({ count: 42 })
-    const snap = getSnapshot(c)
-    const json = JSON.stringify(snap)
-    const parsed = JSON.parse(json)
-    expect(parsed).toEqual({ count: 42 })
-  })
-
-  it('snapshot contains no signal functions', () => {
-    const c = Counter.create({ count: 5 })
-    const snap = getSnapshot(c)
-    for (const val of Object.values(snap)) {
-      expect(typeof val).not.toBe('function')
-    }
-  })
-
-  it('nested model snapshot is fully serializable', () => {
-    const app = App.create({
-      profile: { name: 'Alice', bio: 'dev' },
-      title: 'Test',
-    })
-    const snap = getSnapshot(app)
-    const json = JSON.stringify(snap)
-    const parsed = JSON.parse(json)
-    expect(parsed).toEqual({
-      profile: { name: 'Alice', bio: 'dev' },
-      title: 'Test',
-    })
-  })
-
-  it('snapshot does not include views or actions', () => {
-    const c = Counter.create({ count: 3 })
-    const snap = getSnapshot(c)
-    expect(snap).toEqual({ count: 3 })
-    expect(snap).not.toHaveProperty('doubled')
-    expect(snap).not.toHaveProperty('inc')
-  })
-})
-
-// ─── applySnapshot — restores model state ──────────────────────────────────
-
-describe('applySnapshot — restores model state', () => {
-  it('restores a complete snapshot', () => {
-    const c = Counter.create({ count: 99 })
-    applySnapshot(c, { count: 0 })
-    expect(c.count()).toBe(0)
-  })
-
-  it('restores partial snapshot — only specified keys', () => {
-    const M = model({ state: { a: 1, b: 2, c: 3 } })
-    const m = M.create({ a: 10, b: 20, c: 30 })
-    applySnapshot(m, { b: 99 })
-    expect(m.a()).toBe(10)
-    expect(m.b()).toBe(99)
-    expect(m.c()).toBe(30)
-  })
-
-  it('restores nested model state recursively', () => {
-    const app = App.create({
-      profile: { name: 'Alice', bio: 'dev' },
-      title: 'Old',
-    })
-    applySnapshot(app, {
-      profile: { name: 'Bob', bio: 'engineer' },
-      title: 'New',
-    })
-    expect(app.profile().name()).toBe('Bob')
-    expect(app.profile().bio()).toBe('engineer')
-    expect(app.title()).toBe('New')
-  })
-
-  it('roundtrips: getSnapshot -> applySnapshot produces same state', () => {
-    const app = App.create({
-      profile: { name: 'Carol', bio: 'designer' },
-      title: 'Portfolio',
-    })
-    const snap = getSnapshot(app)
-
-    const app2 = App.create()
-    applySnapshot(app2, snap)
-    expect(getSnapshot(app2)).toEqual(snap)
-  })
-
-  it('batches updates — effect fires once for multi-field snapshot', () => {
-    const M = model({ state: { x: 0, y: 0, z: 0 } })
-    const m = M.create()
-    let effectRuns = 0
-    effect(() => {
-      m.x()
-      m.y()
-      m.z()
-      effectRuns++
-    })
-    effectRuns = 0
-    applySnapshot(m, { x: 1, y: 2, z: 3 })
-    expect(effectRuns).toBe(1)
-  })
-})
-
-// ─── onPatch — listener receives correct format ────────────────────────────
-
-describe('onPatch — patch format', () => {
-  it('patch has op, path, and value fields', () => {
-    const c = Counter.create()
-    const patches: Patch[] = []
-    onPatch(c, (p) => patches.push(p))
-    c.inc()
-    expect(patches).toHaveLength(1)
-    expect(patches[0]).toHaveProperty('op', 'replace')
-    expect(patches[0]).toHaveProperty('path', '/count')
-    expect(patches[0]).toHaveProperty('value', 1)
-  })
-
-  it('path uses JSON pointer format with leading slash', () => {
-    const c = Counter.create()
-    const patches: Patch[] = []
-    onPatch(c, (p) => patches.push(p))
-    c.add(5)
-    expect(patches[0]!.path).toMatch(/^\//)
-  })
-
-  it('nested model patches have composite paths', () => {
-    const app = App.create({ profile: { name: 'A', bio: '' }, title: '' })
-    const patches: Patch[] = []
-    onPatch(app, (p) => patches.push(p))
-
-    app.profile().rename('B')
-    expect(patches[0]!.path).toBe('/profile/name')
-  })
-
-  it('value contains new value after mutation, not old', () => {
-    const c = Counter.create({ count: 10 })
-    const patches: Patch[] = []
-    onPatch(c, (p) => patches.push(p))
-
-    c.add(5)
-    expect(patches[0]!.value).toBe(15)
-  })
-
-  it('emits patches for each signal write in sequence', () => {
-    const c = Counter.create()
-    const patches: Patch[] = []
-    onPatch(c, (p) => patches.push(p))
-
-    c.inc()
-    c.inc()
-    c.add(10)
-
-    expect(patches).toHaveLength(3)
-    expect(patches.map((p) => p.value)).toEqual([1, 2, 12])
-  })
-})
-
-// ─── applyPatch — applies patches correctly ────────────────────────────────
-
-describe('applyPatch — applies patches', () => {
-  it('applies a single replace patch to top-level field', () => {
-    const c = Counter.create()
-    applyPatch(c, { op: 'replace', path: '/count', value: 42 })
-    expect(c.count()).toBe(42)
-  })
-
-  it('applies array of patches in order', () => {
-    const c = Counter.create()
-    applyPatch(c, [
-      { op: 'replace', path: '/count', value: 5 },
-      { op: 'replace', path: '/count', value: 10 },
-    ])
-    expect(c.count()).toBe(10)
-  })
-
-  it('applies patches to nested model instances', () => {
-    const app = App.create({
-      profile: { name: 'A', bio: 'b' },
-      title: 't',
-    })
-    applyPatch(app, { op: 'replace', path: '/profile/name', value: 'B' })
-    expect(app.profile().name()).toBe('B')
-  })
-
-  it('roundtrip: record patches with onPatch, replay on fresh instance', () => {
-    const original = Counter.create()
-    const patches: Patch[] = []
-    onPatch(original, (p) => patches.push({ ...p }))
-
-    original.inc()
-    original.add(10)
-    original.dec()
-
-    const replica = Counter.create()
-    applyPatch(replica, patches)
-    expect(replica.count()).toBe(original.count())
-    expect(getSnapshot(replica)).toEqual(getSnapshot(original))
-  })
-
-  it('throws for unsupported op', () => {
-    const c = Counter.create()
-    expect(() => applyPatch(c, { op: 'add' as any, path: '/count', value: 1 })).toThrow(
-      'unsupported op',
-    )
-  })
-
-  it('throws for empty path', () => {
-    const c = Counter.create()
-    expect(() => applyPatch(c, { op: 'replace', path: '', value: 1 })).toThrow('empty path')
-  })
-
-  it('throws for unknown key', () => {
-    const c = Counter.create()
-    expect(() => applyPatch(c, { op: 'replace', path: '/unknown', value: 1 })).toThrow(
-      'unknown state key',
-    )
-  })
-
-  it('throws for non-model instance', () => {
-    expect(() => applyPatch({}, { op: 'replace', path: '/x', value: 1 })).toThrow(
-      'not a model instance',
-    )
-  })
-})
-
-// ─── addMiddleware — intercepts actions ────────────────────────────────────
-
-describe('addMiddleware — intercepts actions', () => {
-  it('captures action name and args', () => {
-    const c = Counter.create()
-    const calls: { name: string; args: unknown[] }[] = []
-    addMiddleware(c, (call, next) => {
-      calls.push({ name: call.name, args: [...call.args] })
-      return next(call)
-    })
-    c.add(5)
-    expect(calls).toEqual([{ name: 'add', args: [5] }])
-  })
-
-  it('middleware can block action by not calling next', () => {
-    const c = Counter.create()
-    addMiddleware(c, () => {
-      /* intentionally block */
-    })
-    c.inc()
-    expect(c.count()).toBe(0)
-  })
-
-  it('middleware can modify args', () => {
-    const c = Counter.create()
-    addMiddleware(c, (call, next) => {
-      if (call.name === 'add') {
-        return next({ ...call, args: [(call.args[0] as number) * 3] })
-      }
-      return next(call)
-    })
-    c.add(5)
-    expect(c.count()).toBe(15) // 5 * 3
-  })
-
-  it('unsub removes the middleware', () => {
-    const c = Counter.create()
-    const log: string[] = []
-    const unsub = addMiddleware(c, (call, next) => {
-      log.push(call.name)
-      return next(call)
-    })
-    c.inc()
-    expect(log).toHaveLength(1)
-
-    unsub()
-    c.inc()
-    expect(log).toHaveLength(1) // no new entries
-  })
-
-  it('multiple middlewares execute in Koa-style onion order', () => {
-    const c = Counter.create()
-    const log: string[] = []
-    addMiddleware(c, (call, next) => {
-      log.push('A:before')
-      const r = next(call)
-      log.push('A:after')
-      return r
-    })
-    addMiddleware(c, (call, next) => {
-      log.push('B:before')
-      const r = next(call)
-      log.push('B:after')
-      return r
-    })
-    c.inc()
-    expect(log).toEqual(['A:before', 'B:before', 'B:after', 'A:after'])
-  })
-})
-
-// ─── Nested model composition ──────────────────────────────────────────────
-
-describe('nested model composition', () => {
-  it('deeply nested models work correctly', () => {
-    const Leaf = model({
-      state: { val: 0 },
-      actions: (self) => ({
-        set: (v: number) => self.val.set(v),
-      }),
-    })
-    const Branch = model({
-      state: { leaf: Leaf, tag: '' },
-      actions: (self) => ({
-        setTag: (t: string) => self.tag.set(t),
-      }),
-    })
-    const Root = model({
-      state: { branch: Branch, name: 'root' },
-    })
-
-    const root = Root.create({
-      branch: { leaf: { val: 42 }, tag: 'test' },
-      name: 'myRoot',
-    })
-
-    expect(root.branch().leaf().val()).toBe(42)
-    expect(root.branch().tag()).toBe('test')
-    expect(root.name()).toBe('myRoot')
-  })
-
-  it('nested model patches propagate up with correct paths', () => {
-    const Leaf = model({
-      state: { val: 0 },
-      actions: (self) => ({
-        setVal: (v: number) => self.val.set(v),
-      }),
-    })
-    const Branch = model({
-      state: { leaf: Leaf },
-    })
-    const Root = model({
-      state: { branch: Branch },
-    })
-
-    const root = Root.create()
-    const patches: Patch[] = []
-    onPatch(root, (p) => patches.push(p))
-
-    root.branch().leaf().setVal(99)
-    expect(patches).toHaveLength(1)
-    expect(patches[0]!.path).toBe('/branch/leaf/val')
-    expect(patches[0]!.value).toBe(99)
-  })
-
-  it('nested getSnapshot serializes all levels', () => {
-    const Leaf = model({ state: { x: 1 } })
-    const Mid = model({ state: { leaf: Leaf, y: 2 } })
-    const Top = model({ state: { mid: Mid, z: 3 } })
-
-    const top = Top.create()
-    expect(getSnapshot(top)).toEqual({
-      mid: { leaf: { x: 1 }, y: 2 },
-      z: 3,
-    })
-  })
-
-  it('applyPatch to deeply nested path works', () => {
-    const Leaf = model({ state: { x: 0 } })
-    const Mid = model({ state: { leaf: Leaf } })
-    const Top = model({ state: { mid: Mid } })
-
-    const top = Top.create()
-    applyPatch(top, { op: 'replace', path: '/mid/leaf/x', value: 999 })
-    expect(top.mid().leaf().x()).toBe(999)
-  })
-})
-
-// ─── asHook — singleton hook ───────────────────────────────────────────────
-
-describe('asHook — creates singleton hook', () => {
-  afterEach(() => resetAllHooks())
-
-  it('returns the same instance every time', () => {
-    const useC = Counter.asHook('hook-same')
-    const a = useC()
-    const b = useC()
-    expect(a).toBe(b)
-  })
-
-  it('state mutations persist across calls', () => {
-    const useC = Counter.asHook('hook-persist')
-    useC().add(10)
-    expect(useC().count()).toBe(10)
-  })
-
-  it('different ids yield independent instances', () => {
-    const useA = Counter.asHook('hook-id-a')
-    const useB = Counter.asHook('hook-id-b')
-    useA().add(5)
-    expect(useA().count()).toBe(5)
-    expect(useB().count()).toBe(0)
-  })
-
-  it('resetHook clears specific singleton', () => {
-    const useC = Counter.asHook('hook-reset-2')
-    useC().add(100)
-    resetHook('hook-reset-2')
-    expect(useC().count()).toBe(0)
-  })
-
-  it('resetAllHooks clears all singletons', () => {
-    const useA = Counter.asHook('hook-all-1')
-    const useB = Counter.asHook('hook-all-2')
-    useA().add(5)
-    useB().add(10)
-
-    resetAllHooks()
-
-    expect(useA().count()).toBe(0)
-    expect(useB().count()).toBe(0)
-  })
-})
-
-// ─── Effect reactivity ─────────────────────────────────────────────────────
-
-describe('effect reactivity with model instances', () => {
-  it('effect tracks signal reads from model instance', () => {
-    const c = Counter.create()
-    const observed: number[] = []
-    effect(() => {
-      observed.push(c.count())
-    })
-    c.inc()
-    c.inc()
-    expect(observed).toEqual([0, 1, 2])
-  })
-
-  it('effect tracks computed views', () => {
-    const c = Counter.create({ count: 1 })
-    const observed: number[] = []
-    effect(() => {
-      observed.push(c.doubled())
-    })
-    c.inc()
-    c.add(5)
-    expect(observed).toEqual([2, 4, 14])
-  })
-})

package/src/tests/devtools.test.ts

@@ -1,163 +0,0 @@
-import {
-  _resetDevtools,
-  getActiveModels,
-  getModelInstance,
-  getModelSnapshot,
-  onModelChange,
-  registerInstance,
-  unregisterInstance,
-} from '../devtools'
-import { model } from '../index'
-
-const Counter = model({
-  state: { count: 0 },
-  actions: (self) => ({
-    inc: () => self.count.update((c: number) => c + 1),
-  }),
-})
-
-afterEach(() => _resetDevtools())
-
-describe('state-tree devtools', () => {
-  test('getActiveModels returns empty initially', () => {
-    expect(getActiveModels()).toEqual([])
-  })
-
-  test('registerInstance makes model visible', () => {
-    const counter = Counter.create()
-    registerInstance('app-counter', counter)
-    expect(getActiveModels()).toEqual(['app-counter'])
-  })
-
-  test('getModelInstance returns the registered instance', () => {
-    const counter = Counter.create()
-    registerInstance('app-counter', counter)
-    expect(getModelInstance('app-counter')).toBe(counter)
-  })
-
-  test('getModelInstance returns undefined for unregistered name', () => {
-    expect(getModelInstance('nope')).toBeUndefined()
-  })
-
-  test('unregisterInstance removes the model', () => {
-    const counter = Counter.create()
-    registerInstance('app-counter', counter)
-    unregisterInstance('app-counter')
-    expect(getActiveModels()).toEqual([])
-  })
-
-  test('getModelSnapshot returns current snapshot', () => {
-    const counter = Counter.create({ count: 5 })
-    registerInstance('app-counter', counter)
-    expect(getModelSnapshot('app-counter')).toEqual({ count: 5 })
-  })
-
-  test('getModelSnapshot reflects mutations', () => {
-    const counter = Counter.create()
-    registerInstance('app-counter', counter)
-    counter.inc()
-    counter.inc()
-    expect(getModelSnapshot('app-counter')).toEqual({ count: 2 })
-  })
-
-  test('getModelSnapshot returns undefined for unregistered name', () => {
-    expect(getModelSnapshot('nope')).toBeUndefined()
-  })
-
-  test('onModelChange fires on register', () => {
-    const calls: number[] = []
-    const unsub = onModelChange(() => calls.push(1))
-
-    const counter = Counter.create()
-    registerInstance('app-counter', counter)
-    expect(calls.length).toBe(1)
-
-    unsub()
-  })
-
-  test('onModelChange fires on unregister', () => {
-    const counter = Counter.create()
-    registerInstance('app-counter', counter)
-
-    const calls: number[] = []
-    const unsub = onModelChange(() => calls.push(1))
-    unregisterInstance('app-counter')
-    expect(calls.length).toBe(1)
-
-    unsub()
-  })
-
-  test('onModelChange unsubscribe stops notifications', () => {
-    const calls: number[] = []
-    const unsub = onModelChange(() => calls.push(1))
-    unsub()
-
-    registerInstance('app-counter', Counter.create())
-    expect(calls.length).toBe(0)
-  })
-
-  test('multiple instances are tracked', () => {
-    registerInstance('a', Counter.create())
-    registerInstance('b', Counter.create())
-    expect(getActiveModels().sort()).toEqual(['a', 'b'])
-  })
-
-  test("getModelInstance returns undefined and cleans up when WeakRef target is GC'd", () => {
-    // We simulate a GC'd WeakRef by monkey-patching the registered WeakRef's deref.
-    const counter = Counter.create()
-    registerInstance('gc-test', counter)
-
-    // Verify it's accessible
-    expect(getModelInstance('gc-test')).toBe(counter)
-
-    // Now register a new entry with a fake WeakRef-like object that returns undefined.
-    // Since _activeModels is a Map<string, WeakRef<object>>, we can re-register
-    // to overwrite the entry, but registerInstance creates a real WeakRef.
-    // Instead, we'll unregister and then test getModelInstance on a missing key.
-    // But that tests the !ref branch (line 53), not the !instance branch (lines 55-57).
-
-    // The only way to test lines 55-57 is to have a WeakRef whose deref() returns undefined.
-    // We achieve this by creating the WeakRef with the mocked constructor before registering.
-    _resetDevtools()
-
-    const OriginalWeakRef = globalThis.WeakRef
-    let collected = false
-    class GCWeakRef {
-      _target: any
-      constructor(target: any) {
-        this._target = target
-      }
-      deref() {
-        return collected ? undefined : this._target
-      }
-    }
-    globalThis.WeakRef = GCWeakRef as any
-
-    try {
-      const c2 = Counter.create()
-      registerInstance('gc-victim', c2)
-
-      // Before GC
-      expect(getModelInstance('gc-victim')).toBe(c2)
-      expect(getActiveModels()).toContain('gc-victim')
-
-      // Simulate GC
-      collected = true
-
-      // getActiveModels cleans up dead refs first (line 43 branch)
-      expect(getActiveModels()).not.toContain('gc-victim')
-
-      // Re-register to test getModelInstance's GC cleanup path (lines 55-57)
-      registerInstance('gc-victim-2', Counter.create())
-      collected = true
-
-      // getModelInstance hits lines 55-57: instance is undefined, deletes entry, returns undefined
-      expect(getModelInstance('gc-victim-2')).toBeUndefined()
-
-      // getModelSnapshot returns undefined for GC'd instance
-      expect(getModelSnapshot('gc-victim-2')).toBeUndefined()
-    } finally {
-      globalThis.WeakRef = OriginalWeakRef
-    }
-  })
-})