@treenity/react 3.0.1 → 3.0.3

package/src/bind/bind.test.ts

@@ -1,316 +0,0 @@
-import type { NodeData } from '@treenity/core';
-import assert from 'node:assert/strict';
-import { describe, it } from 'node:test';
-import { clearComputed, getComputed, setComputed, subscribeComputed } from './computed';
-import { evaluateRef, extractArgPaths, hasOnce, isCollectionRef } from './eval';
-import { isRefArg, parseMapExpr } from './parse';
-
-// ── Parser ──
-
-describe('parseMapExpr', () => {
-  it('parses pipe with field chain', () => {
-    const expr = parseMapExpr('last().value | div(5)');
-    assert.deepEqual(expr.steps, [
-      { type: 'pipe', name: 'last', args: [] },
-      { type: 'field', name: 'value' },
-      { type: 'pipe', name: 'div', args: [5] },
-    ]);
-  });
-
-  it('parses bare pipe (no parens)', () => {
-    const expr = parseMapExpr('round');
-    assert.deepEqual(expr.steps, [
-      { type: 'pipe', name: 'round', args: [] },
-    ]);
-  });
-
-  it('parses multiple args', () => {
-    const expr = parseMapExpr('clamp(0, 10)');
-    assert.deepEqual(expr.steps, [
-      { type: 'pipe', name: 'clamp', args: [0, 10] },
-    ]);
-  });
-
-  it('parses field-only chain', () => {
-    const expr = parseMapExpr('.status');
-    assert.deepEqual(expr.steps, [
-      { type: 'field', name: 'status' },
-    ]);
-  });
-
-  it('parses complex chain', () => {
-    const expr = parseMapExpr('last().value | sub(20) | abs | div(10)');
-    assert.deepEqual(expr.steps, [
-      { type: 'pipe', name: 'last', args: [] },
-      { type: 'field', name: 'value' },
-      { type: 'pipe', name: 'sub', args: [20] },
-      { type: 'pipe', name: 'abs', args: [] },
-      { type: 'pipe', name: 'div', args: [10] },
-    ]);
-  });
-
-  it('parses map pipe', () => {
-    const expr = parseMapExpr('map(value) | avg');
-    assert.deepEqual(expr.steps, [
-      { type: 'pipe', name: 'map', args: ['value'] },
-      { type: 'pipe', name: 'avg', args: [] },
-    ]);
-  });
-
-  it('parses #field as step (self lookup)', () => {
-    const expr = parseMapExpr('#width | mul(#height)');
-    assert.deepEqual(expr.steps, [
-      { type: 'field', name: 'width' },
-      { type: 'pipe', name: 'mul', args: [{ $ref: '.', fields: ['height'] }] },
-    ]);
-  });
-
-  it('parses #/path.field ref arg', () => {
-    const expr = parseMapExpr('#price | mul(#/config/tax.rate)');
-    const mulStep = expr.steps[1];
-    assert.equal(mulStep.type, 'pipe');
-    if (mulStep.type === 'pipe') {
-      assert.equal(isRefArg(mulStep.args[0]), true);
-      assert.deepEqual(mulStep.args[0], { $ref: '/config/tax', fields: ['rate'] });
-    }
-  });
-
-  it('parses #/path without field (whole node)', () => {
-    const expr = parseMapExpr('count(#/sensors)');
-    const step = expr.steps[0];
-    if (step.type === 'pipe') {
-      assert.deepEqual(step.args[0], { $ref: '/sensors', fields: [] });
-    }
-  });
-
-  it('parses #/path.deep.field', () => {
-    const expr = parseMapExpr('mul(#/config.tax.rate)');
-    const step = expr.steps[0];
-    if (step.type === 'pipe') {
-      assert.deepEqual(step.args[0], { $ref: '/config', fields: ['tax', 'rate'] });
-    }
-  });
-});
-
-// ── Evaluator ──
-
-describe('evaluateRef', () => {
-  const config = { $path: '/config', $type: 'config', factor: 5, tax: { rate: 0.2 } } as NodeData;
-
-  const sensors = [
-    { $path: '/s/1', $type: 'reading', value: 10, seq: 0 },
-    { $path: '/s/2', $type: 'reading', value: 20, seq: 1 },
-    { $path: '/s/3', $type: 'reading', value: 30, seq: 2 },
-  ] as NodeData[];
-
-  const selfNode = { $path: '/obj', $type: 't3d.object', width: 4, height: 3, price: 100 } as NodeData;
-
-  const allNodes = [...sensors, config, selfNode];
-
-  const ctx = {
-    getNode: (p: string) => allNodes.find(s => s.$path === p),
-    getChildren: (p: string) => p === '/s' ? sensors : [],
-  };
-
-  it('resolves plain ref (no $map)', () => {
-    const result = evaluateRef({ $ref: '/s/2' }, ctx);
-    assert.equal((result as NodeData)?.value, 20);
-  });
-
-  it('resolves last().value | div(5)', () => {
-    const result = evaluateRef({ $ref: '/s', $map: 'last().value | div(5)' }, ctx);
-    assert.equal(result, 6); // 30 / 5
-  });
-
-  it('resolves first().value', () => {
-    const result = evaluateRef({ $ref: '/s', $map: 'first().value' }, ctx);
-    assert.equal(result, 10);
-  });
-
-  it('resolves count()', () => {
-    const result = evaluateRef({ $ref: '/s', $map: 'count()' }, ctx);
-    assert.equal(result, 3);
-  });
-
-  it('resolves map + avg', () => {
-    const result = evaluateRef({ $ref: '/s', $map: 'map(value) | avg' }, ctx);
-    assert.equal(result, 20); // (10+20+30)/3
-  });
-
-  it('resolves map + sum', () => {
-    const result = evaluateRef({ $ref: '/s', $map: 'map(value) | sum' }, ctx);
-    assert.equal(result, 60);
-  });
-
-  it('resolves scalar chain', () => {
-    const result = evaluateRef({ $ref: '/s', $map: 'last().value | sub(20) | abs | div(2)' }, ctx);
-    assert.equal(result, 5); // |30-20| / 2
-  });
-
-  it('resolves clamp', () => {
-    const result = evaluateRef({ $ref: '/s', $map: 'last().value | clamp(0, 25)' }, ctx);
-    assert.equal(result, 25); // 30 clamped to 25
-  });
-
-  it('resolves single node field access (no collection)', () => {
-    const result = evaluateRef({ $ref: '/s/1', $map: '.value | mul(3)' }, ctx);
-    assert.equal(result, 30); // 10 * 3
-  });
-
-  it('returns undefined for empty children', () => {
-    const result = evaluateRef({ $ref: '/empty', $map: 'last().value' }, ctx);
-    assert.equal(result, undefined);
-  });
-
-  // ── Self-ref + #-args ──
-
-  it('resolves #field self lookup', () => {
-    const result = evaluateRef({ $ref: '/obj', $map: '#width | mul(#height)' }, ctx);
-    assert.equal(result, 12); // 4 * 3
-  });
-
-  it('resolves cross-ref #/path.field arg', () => {
-    const result = evaluateRef({ $ref: '/obj', $map: '#price | mul(#/config.tax.rate)' }, ctx);
-    assert.equal(result, 20); // 100 * 0.2
-  });
-
-  it('resolves external source + self arg via #', () => {
-    const result = evaluateRef({ $ref: '/s', $map: 'last().value | div(#/config.factor)' }, ctx);
-    assert.equal(result, 6); // 30 / 5
-  });
-
-  it('returns NaN for missing #ref node (loud failure)', () => {
-    const result = evaluateRef({ $ref: '/obj', $map: '#width | mul(#/missing.value)' }, ctx);
-    assert.equal(Number.isNaN(result), true); // 4 * undefined = NaN
-  });
-});
-
-// ── isCollectionRef ──
-
-describe('isCollectionRef', () => {
-  it('true for last()', () => {
-    assert.equal(isCollectionRef({ $ref: '/s', $map: 'last().value' }), true);
-  });
-
-  it('true for count()', () => {
-    assert.equal(isCollectionRef({ $ref: '/s', $map: 'count()' }), true);
-  });
-
-  it('false for field access', () => {
-    assert.equal(isCollectionRef({ $ref: '/s/1', $map: '.value' }), false);
-  });
-
-  it('false for #field self access', () => {
-    assert.equal(isCollectionRef({ $ref: '.', $map: '#width' }), false);
-  });
-
-  it('false for no $map', () => {
-    assert.equal(isCollectionRef({ $ref: '/s/1' }), false);
-  });
-});
-
-// ── extractArgPaths ──
-
-describe('extractArgPaths', () => {
-  it('returns external paths from #/path args', () => {
-    const paths = extractArgPaths({ $ref: '/obj', $map: '#price | mul(#/config.rate) | add(#/bonus.value)' });
-    assert.deepEqual(paths, ['/config', '/bonus']);
-  });
-
-  it('skips # self refs', () => {
-    const paths = extractArgPaths({ $ref: '.', $map: '#width | mul(#height)' });
-    assert.deepEqual(paths, []);
-  });
-
-  it('returns empty for no $map', () => {
-    assert.deepEqual(extractArgPaths({ $ref: '/x' }), []);
-  });
-});
-
-// ── hasOnce ──
-
-describe('hasOnce', () => {
-  it('true when once in pipe chain', () => {
-    assert.equal(hasOnce({ $ref: '/s', $map: 'last().value | div(5) | once' }), true);
-  });
-
-  it('true when once is only step', () => {
-    assert.equal(hasOnce({ $ref: '/s', $map: 'once' }), true);
-  });
-
-  it('false for normal pipes', () => {
-    assert.equal(hasOnce({ $ref: '/s', $map: 'last().value | div(5)' }), false);
-  });
-
-  it('false for no $map', () => {
-    assert.equal(hasOnce({ $ref: '/s' }), false);
-  });
-});
-
-// ── once pipe (identity) ──
-
-describe('once pipe in evaluation', () => {
-  const nodes = [
-    { $path: '/s/1', $type: 'r', value: 10 },
-    { $path: '/s/2', $type: 'r', value: 20 },
-  ] as NodeData[];
-
-  const ctx = {
-    getNode: (p: string) => nodes.find(n => n.$path === p),
-    getChildren: (p: string) => p === '/s' ? nodes : [],
-  };
-
-  it('once does not alter the computed value', () => {
-    const withOnce = evaluateRef({ $ref: '/s', $map: 'last().value | div(5) | once' }, ctx);
-    const without = evaluateRef({ $ref: '/s', $map: 'last().value | div(5)' }, ctx);
-    assert.equal(withOnce, without);
-    assert.equal(withOnce, 4); // 20 / 5
-  });
-});
-
-// ── Computed store ──
-
-describe('computed store', () => {
-  it('set + get', () => {
-    setComputed('/test', 'sy', 42);
-    const c = getComputed('/test');
-    assert.equal(c?.sy, 42);
-    clearComputed('/test');
-  });
-
-  it('fires subscriber on change', () => {
-    let fired = 0;
-    const unsub = subscribeComputed('/test2', () => { fired++; });
-    setComputed('/test2', 'px', 1);
-    assert.equal(fired, 1);
-    setComputed('/test2', 'px', 2);
-    assert.equal(fired, 2);
-    // No-op same value
-    setComputed('/test2', 'px', 2);
-    assert.equal(fired, 2);
-    unsub();
-    clearComputed('/test2');
-  });
-
-  it('returns new object reference on change (useSyncExternalStore compat)', () => {
-    setComputed('/ref-test', 'a', 1);
-    const snap1 = getComputed('/ref-test');
-    setComputed('/ref-test', 'a', 2);
-    const snap2 = getComputed('/ref-test');
-    // Must be different references — Object.is must see the change
-    assert.notEqual(snap1, snap2);
-    assert.equal(snap2?.a, 2);
-    // Old snapshot retains old value (immutable)
-    assert.equal(snap1?.a, 1);
-    clearComputed('/ref-test');
-  });
-
-  it('unsubscribe stops notifications', () => {
-    let fired = 0;
-    const unsub = subscribeComputed('/test3', () => { fired++; });
-    unsub();
-    setComputed('/test3', 'sy', 99);
-    assert.equal(fired, 0);
-    clearComputed('/test3');
-  });
-});

package/src/cache.test.ts

@@ -1,139 +0,0 @@
-// Cache contract tests — plain Map implementation
-
-import assert from 'node:assert';
-import { beforeEach, describe, it } from 'node:test';
-import * as cache from './cache';
-
-describe('cache', () => {
-  beforeEach(() => {
-    cache.clear();
-  });
-
-  it('put() creates entry, get() returns node', () => {
-    cache.put({ $path: '/a', $type: 'x', v: 1 } as any);
-    const n = cache.get('/a');
-    assert.ok(n);
-    assert.strictEqual(n!.v, 1);
-  });
-
-  it('second put() updates value', () => {
-    cache.put({ $path: '/a', $type: 'x', v: 1 } as any);
-    cache.put({ $path: '/a', $type: 'x', v: 2 } as any);
-    const n = cache.get('/a');
-    assert.strictEqual(n!.v, 2);
-  });
-
-  it('put() with fewer keys replaces node', () => {
-    cache.put({ $path: '/a', $type: 'x', old: 1, keep: 2 } as any);
-    cache.put({ $path: '/a', $type: 'x', keep: 3 } as any);
-    const n = cache.get('/a') as any;
-    assert.strictEqual(n.keep, 3);
-    assert.strictEqual('old' in n, false);
-  });
-
-  it('subscribePath fires on put()', () => {
-    let called = 0;
-    cache.subscribePath('/a', () => called++);
-    cache.put({ $path: '/a', $type: 'x' } as any);
-    assert.strictEqual(called, 1);
-  });
-
-  it('subscribeChildren fires on child put()', () => {
-    let called = 0;
-    cache.subscribeChildren('/', () => called++);
-    cache.put({ $path: '/child', $type: 'x' } as any);
-    assert.ok(called >= 1);
-  });
-
-  it('getSnapshot() returns plain cloneable object', () => {
-    cache.put({ $path: '/a', $type: 'x', v: 42 } as any);
-    const s = cache.getSnapshot('/a');
-    assert.ok(s);
-    assert.strictEqual(s!.v, 42);
-    const cloned = structuredClone(s);
-    assert.strictEqual(cloned.v, 42);
-  });
-
-  it('getSnapshot() returns a copy, not the same reference', () => {
-    cache.put({ $path: '/a', $type: 'x', v: 42 } as any);
-    const s = cache.getSnapshot('/a');
-    assert.notStrictEqual(s, cache.get('/a'));
-  });
-
-  it('notifyPath fires path subs', () => {
-    cache.put({ $path: '/a', $type: 'x' } as any);
-    let called = 0;
-    cache.subscribePath('/a', () => called++);
-    cache.notifyPath('/a');
-    assert.strictEqual(called, 1);
-  });
-
-  it('getChildren returns sorted children', () => {
-    cache.put({ $path: '/b', $type: 'x' } as any);
-    cache.put({ $path: '/a', $type: 'x' } as any);
-    const kids = cache.getChildren('/');
-    assert.strictEqual(kids.length, 2);
-    assert.strictEqual(kids[0].$path, '/a');
-    assert.strictEqual(kids[1].$path, '/b');
-  });
-
-  it('remove() deletes node and fires subs', () => {
-    cache.put({ $path: '/a', $type: 'x' } as any);
-    let called = 0;
-    cache.subscribePath('/a', () => called++);
-    cache.remove('/a');
-    assert.strictEqual(cache.get('/a'), undefined);
-    assert.strictEqual(called, 1);
-  });
-
-  it('putMany() stores all nodes, fires subs', () => {
-    let parentFired = 0;
-    cache.subscribeChildren('/p', () => parentFired++);
-    cache.putMany([
-      { $path: '/p/a', $type: 'x' } as any,
-      { $path: '/p/b', $type: 'x' } as any,
-    ], '/p');
-    assert.ok(cache.get('/p/a'));
-    assert.ok(cache.get('/p/b'));
-    assert.ok(parentFired >= 1);
-  });
-
-  it('direct mutation of get() result changes cached value', () => {
-    cache.put({ $path: '/a', $type: 'x', v: 1 } as any);
-    const n = cache.get('/a') as any;
-    n.v = 99;
-    assert.strictEqual(cache.get('/a')!.v, 99);
-  });
-
-  it('onNodePut callback fires on every put()', () => {
-    const paths: string[] = [];
-    cache.onNodePut((p) => paths.push(p));
-    cache.put({ $path: '/a', $type: 'x' } as any);
-    cache.put({ $path: '/b', $type: 'x' } as any);
-    assert.deepStrictEqual(paths, ['/a', '/b']);
-  });
-
-  it('nested component update works', () => {
-    cache.put({ $path: '/a', $type: 'x', comp: { $type: 'y', count: 0, label: 'hi' } } as any);
-    cache.put({ $path: '/a', $type: 'x', comp: { $type: 'y', count: 5, label: 'hi' } } as any);
-    assert.strictEqual((cache.get('/a') as any).comp.count, 5);
-  });
-
-  it('adding a new nested component', () => {
-    cache.put({ $path: '/a', $type: 'x' } as any);
-    cache.put({ $path: '/a', $type: 'x', comp: { $type: 'y', v: 1 } } as any);
-    assert.strictEqual((cache.get('/a') as any).comp.v, 1);
-  });
-
-  it('removing a nested component', () => {
-    cache.put({ $path: '/a', $type: 'x', comp: { $type: 'y', v: 1 } } as any);
-    cache.put({ $path: '/a', $type: 'x' } as any);
-    assert.strictEqual('comp' in (cache.get('/a') as any), false);
-  });
-
-  it('array replaced wholesale', () => {
-    cache.put({ $path: '/a', $type: 'x', items: [1, 2, 3] } as any);
-    cache.put({ $path: '/a', $type: 'x', items: [4, 5] } as any);
-    assert.deepStrictEqual([...(cache.get('/a') as any).items], [4, 5]);
-  });
-});

package/src/client-tree.test.ts

@@ -1,116 +0,0 @@
-import type { NodeData } from '@treenity/core';
-import assert from 'node:assert/strict';
-import { describe, it } from 'node:test';
-import { createClientTree } from './client-tree';
-
-// ── Mock tRPC client ──
-
-function createMockTrpc(backing: Map<string, NodeData>) {
-  let calls = 0;
-
-  const mock = {
-    get calls() { return calls; },
-    resetCalls() { calls = 0; },
-
-    get: {
-      query: async ({ path }: { path: string }) => {
-        calls++;
-        return backing.get(path);
-      },
-    },
-    getChildren: {
-      query: async ({ path }: { path: string; limit?: number; offset?: number }) => {
-        calls++;
-        const prefix = path === '/' ? '/' : path + '/';
-        const items = [...backing.values()].filter(
-          n => n.$path.startsWith(prefix) && n.$path !== path
-            && n.$path.slice(prefix.length).indexOf('/') === -1,
-        );
-        return { items, total: items.length };
-      },
-    },
-    set: {
-      mutate: async ({ node }: { node: Record<string, unknown> }) => {
-        calls++;
-        backing.set(node.$path as string, node as NodeData);
-      },
-    },
-    remove: {
-      mutate: async ({ path }: { path: string }) => {
-        calls++;
-        backing.delete(path);
-      },
-    },
-  };
-
-  return mock;
-}
-
-// ── Tests ──
-
-describe('createClientTree — unified client tree', () => {
-  it('/local/* paths stay in memory, never hit tRPC', async () => {
-    const mock = createMockTrpc(new Map());
-    const { tree: store } = createClientTree(mock as any);
-
-    await store.set({ $path: '/local/ui/theme', $type: 'theme', dark: true } as NodeData);
-    mock.resetCalls();
-
-    const node = await store.get('/local/ui/theme');
-    assert.equal(mock.calls, 0, 'tRPC should not be called for /local paths');
-    assert.equal(node?.$type, 'theme');
-    assert.equal((node as any).dark, true);
-  });
-
-  it('non-local paths route through tRPC', async () => {
-    const backing = new Map<string, NodeData>();
-    backing.set('/orders/1', { $path: '/orders/1', $type: 'order', total: 42 } as NodeData);
-    const mock = createMockTrpc(backing);
-    const { tree: store } = createClientTree(mock as any);
-
-    const node = await store.get('/orders/1');
-    assert.ok(mock.calls > 0, 'tRPC should be called for remote paths');
-    assert.equal((node as any).total, 42);
-  });
-
-  it('getChildren merges local and remote children', async () => {
-    const backing = new Map<string, NodeData>();
-    backing.set('/cloud', { $path: '/cloud', $type: 'dir' } as NodeData);
-    const mock = createMockTrpc(backing);
-    const { tree: store } = createClientTree(mock as any);
-
-    // Write a local node
-    await store.set({ $path: '/local', $type: 'dir' } as NodeData);
-
-    // getChildren('/') should return both
-    const { items } = await store.getChildren('/');
-    const paths = items.map((n: { $path: string }) => n.$path).sort();
-    assert.ok(paths.includes('/local'), 'should include local children');
-    assert.ok(paths.includes('/cloud'), 'should include remote children');
-  });
-
-  it('remove /local/* does not call tRPC', async () => {
-    const mock = createMockTrpc(new Map());
-    const { tree: store } = createClientTree(mock as any);
-
-    await store.set({ $path: '/local/temp', $type: 'tmp' } as NodeData);
-    mock.resetCalls();
-
-    await store.remove('/local/temp');
-    // filterStore tries both, but remote remove is harmless no-op
-    const node = await store.get('/local/temp');
-    assert.equal(node, undefined, '/local/temp should be gone');
-  });
-
-  it('cached remote: second get skips tRPC', async () => {
-    const backing = new Map<string, NodeData>();
-    backing.set('/x', { $path: '/x', $type: 'test' } as NodeData);
-    const mock = createMockTrpc(backing);
-    const { tree: store } = createClientTree(mock as any);
-
-    await store.get('/x'); // populates cache
-    mock.resetCalls();
-    await store.get('/x'); // should hit cache
-    assert.equal(mock.calls, 0, 'second get should come from cache');
-  });
-});

package/src/optimistic.test.ts

@@ -1,111 +0,0 @@
-// Optimistic prediction tests — predictOptimistic updates cache for sync methods
-
-import { registerType } from '@treenity/core/comp';
-import assert from 'node:assert';
-import { beforeEach, describe, it } from 'node:test';
-import * as cache from './cache';
-import { predictOptimistic } from './hooks';
-
-class Counter {
-  count = 0;
-
-  increment() {
-    this.count++;
-  }
-
-  setCount(data: { count: number }) {
-    this.count = data.count;
-  }
-
-  async asyncAction() {
-    // Simulates server-only async method
-    await Promise.resolve();
-    this.count = 999;
-  }
-
-  broken() {
-    throw new Error('intentional failure');
-  }
-}
-
-registerType('test.counter', Counter);
-
-describe('predictOptimistic', () => {
-  beforeEach(() => {
-    cache.clear();
-  });
-
-  it('sync method updates cache immediately', () => {
-    cache.put({ $path: '/c', $type: 'test.counter', count: 5 } as any);
-
-    predictOptimistic('/c', Counter, undefined, Counter.prototype.increment, undefined);
-
-    const node = cache.get('/c');
-    assert.strictEqual((node as any).count, 6);
-  });
-
-  it('sync method with data updates cache', () => {
-    cache.put({ $path: '/c', $type: 'test.counter', count: 0 } as any);
-
-    predictOptimistic('/c', Counter, undefined, Counter.prototype.setCount, { count: 42 });
-
-    const node = cache.get('/c');
-    assert.strictEqual((node as any).count, 42);
-  });
-
-  it('does not mutate original cached node', () => {
-    cache.put({ $path: '/c', $type: 'test.counter', count: 10 } as any);
-    const before = cache.get('/c');
-
-    predictOptimistic('/c', Counter, undefined, Counter.prototype.increment, undefined);
-
-    const after = cache.get('/c');
-    assert.notStrictEqual(before, after);
-  });
-
-  it('skips async methods', () => {
-    cache.put({ $path: '/c', $type: 'test.counter', count: 0 } as any);
-
-    predictOptimistic('/c', Counter, undefined, Counter.prototype.asyncAction, undefined);
-
-    const node = cache.get('/c');
-    assert.strictEqual((node as any).count, 0);
-  });
-
-  it('skips when path not in cache', () => {
-    predictOptimistic('/missing', Counter, undefined, Counter.prototype.increment, undefined);
-
-    assert.strictEqual(cache.get('/missing'), undefined);
-  });
-
-  it('swallows method errors without updating cache', () => {
-    cache.put({ $path: '/c', $type: 'test.counter', count: 5 } as any);
-
-    predictOptimistic('/c', Counter, undefined, Counter.prototype.broken, undefined);
-
-    const node = cache.get('/c');
-    assert.strictEqual((node as any).count, 5);
-  });
-
-  it('skips when component type not found on node', () => {
-    cache.put({ $path: '/c', $type: 'unknown.type', count: 5 } as any);
-
-    predictOptimistic('/c', Counter, undefined, Counter.prototype.increment, undefined);
-
-    const node = cache.get('/c');
-    assert.strictEqual((node as any).count, 5);
-  });
-
-  it('works with named component key', () => {
-    cache.put({
-      $path: '/n',
-      $type: 'dir',
-      stats: { $type: 'test.counter', count: 3 },
-    } as any);
-
-    predictOptimistic('/n', Counter, 'stats', Counter.prototype.increment, undefined);
-
-    const node = cache.get('/n') as any;
-    assert.strictEqual(node.stats.count, 4);
-  });
-});