@treenity/react 3.0.1 → 3.0.2

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);
-  });
-});

package/src/remote-tree.test.ts

@@ -1,142 +0,0 @@
-import type { NodeData } from '@treenity/core';
-import { withCache } from '@treenity/core/tree/cache';
-import assert from 'node:assert/strict';
-import { describe, it } from 'node:test';
-import { createRemoteTree } from './remote-tree';
-
-// ── Mock tRPC client ──
-
-function createMockTrpc(backing: Map<string, NodeData>) {
-  let getCalls = 0;
-
-  const mock = {
-    get getCalls() { return getCalls; },
-    resetCalls() { getCalls = 0; },
-
-    get: {
-      query: async ({ path }: { path: string }) => {
-        getCalls++;
-        return backing.get(path);
-      },
-    },
-    getChildren: {
-      query: async ({ path, limit, offset }: { path: string; limit?: number; offset?: number }) => {
-        getCalls++;
-        const prefix = path === '/' ? '/' : path + '/';
-        const items = [...backing.values()].filter(
-          n => n.$path.startsWith(prefix) && n.$path !== path
-            && n.$path.slice(prefix.length).indexOf('/') === -1,
-        );
-        const start = offset ?? 0;
-        const sliced = limit ? items.slice(start, start + limit) : items.slice(start);
-        return { items: sliced, total: items.length };
-      },
-    },
-    set: {
-      mutate: async ({ node }: { node: Record<string, unknown> }) => {
-        backing.set(node.$path as string, node as NodeData);
-      },
-    },
-    remove: {
-      mutate: async ({ path }: { path: string }) => {
-        backing.delete(path);
-      },
-    },
-  };
-
-  return mock;
-}
-
-// ── Tests ──
-
-describe('createRemoteTree — method mapping', () => {
-  it('get delegates to trpc.get.query', async () => {
-    const data = new Map<string, NodeData>();
-    data.set('/a', { $path: '/a', $type: 'test', v: 1 } as NodeData);
-    const mock = createMockTrpc(data);
-    const store = createRemoteTree(mock as any);
-
-    const node = await store.get('/a');
-    assert.equal(node?.$path, '/a');
-    assert.equal((node as any).v, 1);
-    assert.equal(mock.getCalls, 1);
-  });
-
-  it('get returns undefined for missing path', async () => {
-    const store = createRemoteTree(createMockTrpc(new Map()) as any);
-    const node = await store.get('/missing');
-    assert.equal(node, undefined);
-  });
-
-  it('getChildren delegates to trpc.getChildren.query', async () => {
-    const data = new Map<string, NodeData>();
-    data.set('/p', { $path: '/p', $type: 'dir' } as NodeData);
-    data.set('/p/a', { $path: '/p/a', $type: 'test' } as NodeData);
-    data.set('/p/b', { $path: '/p/b', $type: 'test' } as NodeData);
-    const store = createRemoteTree(createMockTrpc(data) as any);
-
-    const result = await store.getChildren('/p');
-    assert.equal(result.items.length, 2);
-    assert.equal(result.total, 2);
-  });
-
-  it('set delegates to trpc.set.mutate', async () => {
-    const data = new Map<string, NodeData>();
-    const store = createRemoteTree(createMockTrpc(data) as any);
-
-    await store.set({ $path: '/x', $type: 'test', v: 42 } as NodeData);
-    assert.ok(data.has('/x'));
-    assert.equal((data.get('/x') as any).v, 42);
-  });
-
-  it('remove delegates to trpc.remove.mutate', async () => {
-    const data = new Map<string, NodeData>();
-    data.set('/x', { $path: '/x', $type: 'test' } as NodeData);
-    const store = createRemoteTree(createMockTrpc(data) as any);
-
-    const result = await store.remove('/x');
-    assert.equal(result, true);
-    assert.ok(!data.has('/x'));
-  });
-});
-
-describe('withCache(remoteStore) — client pipeline', () => {
-  it('caches get results — second call skips tRPC', async () => {
-    const data = new Map<string, NodeData>();
-    data.set('/a', { $path: '/a', $type: 'test' } as NodeData);
-    const mock = createMockTrpc(data);
-    const store = withCache(createRemoteTree(mock as any));
-
-    await store.get('/a');
-    mock.resetCalls();
-    await store.get('/a'); // should hit cache
-    assert.equal(mock.getCalls, 0);
-  });
-
-  it('write-populate: set warms cache for next get', async () => {
-    const data = new Map<string, NodeData>();
-    const mock = createMockTrpc(data);
-    const store = withCache(createRemoteTree(mock as any));
-
-    await store.set({ $path: '/a', $type: 'test', v: 1 } as NodeData);
-    mock.resetCalls();
-
-    const node = await store.get('/a'); // should hit cache (write-populated)
-    assert.equal(mock.getCalls, 0);
-    assert.equal((node as any).v, 1);
-  });
-
-  it('inflight dedup: concurrent gets produce single tRPC call', async () => {
-    const data = new Map<string, NodeData>();
-    data.set('/a', { $path: '/a', $type: 'test', v: 99 } as NodeData);
-    const mock = createMockTrpc(data);
-    const store = withCache(createRemoteTree(mock as any));
-
-    const results = await Promise.all(
-      Array.from({ length: 5 }, () => store.get('/a')),
-    );
-
-    assert.equal(mock.getCalls, 1);
-    for (const r of results) assert.equal((r as any).v, 99);
-  });
-});