vestjs-runtime 1.6.0 → 1.7.0

package/src/__tests__/IsolateWalker.test.ts

@@ -1,418 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import { makeResult } from 'vest-utils';
-
-import { TIsolate } from '../Isolate/Isolate';
-import {
-  walk,
-  reduce,
-  findAll,
-  find,
-  every,
-  has,
-  some,
-  pluck,
-  closest,
-  closestExists,
-  findClosest,
-} from '../IsolateWalker';
-
-type WalkedNode = TIsolate<{ id: string }>;
-
-describe('walk', () => {
-  let tree = {} as unknown as WalkedNode;
-  beforeEach(() => {
-    tree = {
-      data: { id: '0' },
-      children: [
-        {
-          data: { id: '0.0' },
-          children: [
-            { data: { id: '0.0.0' } },
-            {
-              data: { id: '0.0.1' },
-              children: [
-                { data: { id: '0.0.1.0' } },
-                { data: { id: '0.0.1.1' } },
-              ],
-            },
-            { data: { id: '0.0.2' } },
-          ],
-        },
-        { data: { id: '0.1' } },
-      ],
-    } as unknown as WalkedNode;
-  });
-
-  it('Should walk through the tree', () => {
-    const visited: Set<string> = new Set();
-    walk(tree, isolate => {
-      visited.add(isolate.data.id);
-      return makeResult.Ok(undefined);
-    });
-
-    expect(visited).toEqual(
-      new Set([
-        '0.0.0',
-        '0.0.1.0',
-        '0.0.1.1',
-        '0.0.1',
-        '0.0.2',
-        '0.0',
-        '0.1',
-        '0',
-      ]),
-    );
-  });
-
-  it('Should traverse the tree in a depth-first order', () => {
-    const visited: string[] = [];
-    walk(tree, isolate => {
-      visited.push(isolate.data.id);
-      return makeResult.Ok(undefined);
-    });
-
-    expect(visited).toEqual([
-      '0',
-      '0.0',
-      '0.0.0',
-      '0.0.1',
-      '0.0.1.0',
-      '0.0.1.1',
-      '0.0.2',
-      '0.1',
-    ]);
-  });
-
-  describe('Breakout', () => {
-    it('Should stop the walk when breakout is called', () => {
-      const visited: Array<string> = [];
-      walk(tree, isolate => {
-        visited.push(isolate.data.id);
-        if (isolate.data.id === '0.0.1') {
-          return makeResult.Err(undefined);
-        }
-        return makeResult.Ok(undefined);
-      });
-
-      expect(visited).toEqual(['0', '0.0', '0.0.0', '0.0.1']);
-    });
-  });
-
-  describe('VisitOnly', () => {
-    it('Should only visit nodes that satisfy the predicate', () => {
-      const visited: Array<string> = [];
-      walk(
-        tree,
-        isolate => {
-          visited.push(isolate.data.id);
-          return makeResult.Ok(undefined);
-        },
-        isolate => isolate.data.id.endsWith('1'),
-      );
-
-      expect(visited).toEqual(['0.0.1', '0.0.1.1', '0.1']);
-    });
-  });
-});
-
-describe('reduce', () => {
-  let node = {} as unknown as TIsolate<{ value: number }>;
-  beforeEach(() => {
-    node = {
-      data: { value: 1 },
-      children: [
-        {
-          data: { value: 2 },
-          children: [
-            { data: { value: 1 }, $type: 's' },
-            {
-              data: { value: 2 },
-              children: [{ data: { value: 0 } }, { data: { value: 1 } }],
-            },
-            { data: { value: 1 }, $type: 's' },
-          ],
-        },
-        { data: { value: 0 } },
-      ],
-    } as unknown as TIsolate<{ value: number }>;
-  });
-
-  it('Should return the accumulated value of the tree', () => {
-    const sum = reduce(
-      node,
-      (acc, isolate) => makeResult.Ok(acc + isolate.data.value),
-      0,
-    );
-    expect(sum).toBe(8);
-  });
-
-  it('Should traverse the tree in a depth-first order', () => {
-    const visited: string[] = [];
-    reduce(
-      node,
-      (acc, isolate) => {
-        visited.push(isolate.data.value);
-        return makeResult.Ok(acc);
-      },
-      '',
-    );
-
-    expect(visited).toEqual([1, 2, 1, 2, 0, 1, 1, 0]);
-  });
-
-  describe('Breakout', () => {
-    it('Should stop the walk when breakout is called', () => {
-      const visited: Array<number> = [];
-      reduce(
-        node,
-        (acc, isolate) => {
-          visited.push(isolate.data.value);
-          if (isolate.data.value === 2) {
-            return makeResult.Err(acc);
-          }
-          return makeResult.Ok(acc);
-        },
-        '',
-      );
-
-      expect(visited).toEqual([1, 2]);
-    });
-  });
-
-  describe('VisitOnly', () => {
-    it('Should only visit nodes that satisfy the predicate', () => {
-      const output = reduce(
-        node,
-        (acc, isolate) => {
-          return makeResult.Ok(acc + isolate.data.value);
-        },
-        0,
-        isolate => isolate.$type === 's',
-      );
-
-      expect(output).toBe(2);
-    });
-  });
-});
-
-describe('findAll', () => {
-  let node = {} as unknown as TIsolate<{ value: number }>;
-  beforeEach(() => {
-    node = {
-      data: { value: 100 },
-      children: [
-        {
-          data: { value: 2 },
-          children: [
-            { data: { value: 100 }, $type: 's' },
-            {
-              data: { value: 2 },
-              children: [{ data: { value: 0 } }, { data: { value: 100 } }],
-            },
-            { data: { value: 1 }, $type: 's' },
-          ],
-        },
-        { data: { value: 0 } },
-      ],
-    } as unknown as TIsolate<{ value: number }>;
-  });
-
-  it('Should return all nodes that satisfy the predicate', () => {
-    const output = findAll(node, isolate => isolate.data.value === 100);
-
-    expect(output).toEqual([
-      node,
-      node.children?.[0]?.children?.[0],
-      node.children?.[0]?.children?.[1]?.children?.[1],
-    ]);
-  });
-});
-
-describe('find', () => {
-  let node = {} as unknown as TIsolate<{ value: number }>;
-  beforeEach(() => {
-    node = {
-      data: { value: 1 },
-      children: [
-        {
-          data: { value: 2 },
-          children: [{ data: { value: 3 } }, { data: { value: 4 } }],
-        },
-      ],
-    } as unknown as TIsolate<{ value: number }>;
-  });
-
-  it('should return null if no node matches', () => {
-    expect(find(node, n => n.data.value === 999)).toBeNull();
-  });
-
-  it('should return the first node that matches', () => {
-    const found = find(node, n => n.data.value === 3);
-    expect(found).toBeDefined();
-    expect(found?.data.value).toBe(3);
-  });
-});
-
-describe('some', () => {
-  let node = {} as unknown as TIsolate<{ value: number }>;
-  beforeEach(() => {
-    node = {
-      data: { value: 1 },
-      children: [{ data: { value: 2 } }],
-    } as unknown as TIsolate<{ value: number }>;
-  });
-
-  it('should return true if any node matches', () => {
-    expect(some(node, n => n.data.value === 2)).toBe(true);
-  });
-
-  it('should return false if no node matches', () => {
-    expect(some(node, n => n.data.value === 3)).toBe(false);
-  });
-});
-
-describe('every', () => {
-  let node = {} as unknown as TIsolate<{ value: number }>;
-  beforeEach(() => {
-    node = {
-      data: { value: 1 },
-      children: [{ data: { value: 2 } }],
-    } as unknown as TIsolate<{ value: number }>;
-  });
-
-  it('should return true if all nodes match', () => {
-    expect(every(node, n => n.data.value > 0)).toBe(true);
-  });
-
-  it('should return false if any node fails match', () => {
-    expect(every(node, n => n.data.value === 1)).toBe(false);
-  });
-});
-
-describe('has', () => {
-  let node = {} as unknown as TIsolate<{ value: number }>;
-  beforeEach(() => {
-    node = {
-      data: { value: 1 },
-      children: [{ data: { value: 2 } }],
-    } as unknown as TIsolate<{ value: number }>;
-  });
-
-  it('should return true if a node matching visitOnly exists', () => {
-    expect(has(node, n => n.data.value === 2)).toBe(true);
-  });
-
-  it('should return false if no node matches visitOnly', () => {
-    expect(has(node, n => n.data.value === 3)).toBe(false);
-  });
-});
-
-describe('pluck', () => {
-  let node: TIsolate<{ value: number }>;
-
-  beforeEach(() => {
-    const child1 = { data: { value: 2 }, children: [] } as unknown as TIsolate<{
-      value: number;
-    }>;
-    const child2 = { data: { value: 3 }, children: [] } as unknown as TIsolate<{
-      value: number;
-    }>;
-
-    node = {
-      data: { value: 1 },
-      children: [child1, child2],
-    } as unknown as TIsolate<{ value: number }>;
-
-    // Set parents
-    child1.parent = node;
-    child2.parent = node;
-  });
-
-  it('should remove nodes that satisfy predicate', () => {
-    pluck(node, n => n.data.value === 2);
-    expect(node.children).toHaveLength(1);
-    expect(node.children![0].data.value).toBe(3);
-  });
-});
-
-describe('closest', () => {
-  let root: TIsolate<{ value: number }>;
-  let child: TIsolate<{ value: number }>;
-  let grandchild: TIsolate<{ value: number }>;
-
-  beforeEach(() => {
-    root = { data: { value: 1 } } as unknown as TIsolate<{ value: number }>;
-    child = { data: { value: 2 }, parent: root } as unknown as TIsolate<{
-      value: number;
-    }>;
-    grandchild = { data: { value: 3 }, parent: child } as unknown as TIsolate<{
-      value: number;
-    }>;
-  });
-
-  it('should find closest ancestor satisfying predicate', () => {
-    expect(closest(grandchild, n => n.data.value === 1)).toBe(root);
-  });
-
-  it('should return the node itself if it satisfies', () => {
-    expect(closest(grandchild, n => n.data.value === 3)).toBe(grandchild);
-  });
-
-  it('should return null if not found', () => {
-    expect(closest(grandchild, n => n.data.value === 999)).toBeNull();
-  });
-});
-
-describe('closestExists', () => {
-  let root: TIsolate<{ value: number }>;
-  let child: TIsolate<{ value: number }>;
-
-  beforeEach(() => {
-    root = { data: { value: 1 } } as unknown as TIsolate<{ value: number }>;
-    child = { data: { value: 2 }, parent: root } as unknown as TIsolate<{
-      value: number;
-    }>;
-  });
-
-  it('should return true if ancestor exists', () => {
-    expect(closestExists(child, n => n.data.value === 1)).toBe(true);
-  });
-
-  it('should return false if no ancestor matches', () => {
-    expect(closestExists(child, n => n.data.value === 999)).toBe(false);
-  });
-});
-
-describe('findClosest', () => {
-  let root: TIsolate<{ value: number }>;
-  let child: TIsolate<{ value: number }>;
-  let sibling: TIsolate<{ value: number }>;
-
-  beforeEach(() => {
-    root = { data: { value: 1 }, children: [] } as unknown as TIsolate<{
-      value: number;
-    }>;
-
-    child = {
-      data: { value: 2 },
-      parent: root,
-      children: [],
-    } as unknown as TIsolate<{ value: number }>;
-    sibling = {
-      data: { value: 3 },
-      parent: root,
-      children: [],
-    } as unknown as TIsolate<{ value: number }>;
-
-    root.children = [child, sibling];
-  });
-
-  it('should find a sibling (descendant of ancestor)', () => {
-    // Start from child, find sibling (which is child of root)
-    expect(findClosest(child, n => n.data.value === 3)).toBe(sibling);
-  });
-
-  it('should return null if not found', () => {
-    expect(findClosest(child, n => n.data.value === 999)).toBeNull();
-  });
-});

package/src/__tests__/Reconciler.test.ts

@@ -1,193 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import * as VestRuntime from '../VestRuntime';
-import { Reconciler } from '../Reconciler';
-import { TIsolate } from '../Isolate/Isolate';
-import { IsolateInspector } from '../Isolate/IsolateInspector';
-import { IsolateMutator } from '../Isolate/IsolateMutator';
-
-vi.mock('../VestRuntime', () => ({
-  useHistoryIsolateAtCurrentPosition: vi.fn(),
-  useReconciler: vi.fn(),
-  useHistoryKey: vi.fn(),
-  useSetIsolateKey: vi.fn(),
-  useIsolate: vi.fn(),
-  useHistoryIsolate: vi.fn(),
-}));
-
-vi.mock('../Isolate/IsolateInspector', () => ({
-  IsolateInspector: {
-    usesKey: vi.fn(),
-    cursor: vi.fn(),
-  },
-}));
-
-vi.mock('../Isolate/IsolateMutator', () => ({
-  IsolateMutator: {
-    slice: vi.fn(),
-  },
-}));
-
-describe('Reconciler', () => {
-  beforeEach(() => {
-    vi.resetAllMocks();
-  });
-
-  describe('reconcile', () => {
-    let node: TIsolate;
-    let historyNode: TIsolate;
-    let mockReconciler: any;
-
-    beforeEach(() => {
-      node = { $type: 'TypeA' } as TIsolate;
-      historyNode = { $type: 'TypeA' } as TIsolate;
-      mockReconciler = vi.fn();
-
-      vi.mocked(VestRuntime.useHistoryIsolateAtCurrentPosition).mockReturnValue(
-        historyNode,
-      );
-      vi.mocked(VestRuntime.useReconciler).mockReturnValue(mockReconciler);
-    });
-
-    it('Should return the result of the reconciler function', () => {
-      const nextNode = { $type: 'TypeA' } as TIsolate;
-      mockReconciler.mockReturnValue(nextNode);
-
-      expect(Reconciler.reconcile(node)).toBe(nextNode);
-      expect(mockReconciler).toHaveBeenCalledWith(node, historyNode);
-    });
-
-    it('Should use BaseReconciler if reconciler returns nullish', () => {
-      mockReconciler.mockReturnValue(null);
-      // BaseReconciler returns node if historyNode is nullish,
-      // or node if types match (implicit in BaseReconciler implementation being simple in the file I read?)
-      // Wait, BaseReconciler implementation in file:
-      // function BaseReconciler(currentNode, historyNode) {
-      //   if (isNullish(historyNode)) return currentNode;
-      //   return currentNode;
-      // }
-      // So it always returns currentNode.
-
-      expect(Reconciler.reconcile(node)).toBe(node);
-    });
-
-    it('Should return node if history node is null', () => {
-      vi.mocked(VestRuntime.useHistoryIsolateAtCurrentPosition).mockReturnValue(
-        null,
-      );
-      expect(Reconciler.reconcile(node)).toBe(node);
-    });
-
-    it('Should return node if types mismatch', () => {
-      const differentTypeNode = { $type: 'TypeB' } as TIsolate;
-      // We need to make sure isSameIsolateType returns false.
-      // It seems to check $type equality.
-      vi.mocked(VestRuntime.useHistoryIsolateAtCurrentPosition).mockReturnValue(
-        differentTypeNode,
-      );
-
-      expect(Reconciler.reconcile(node)).toBe(node);
-      expect(mockReconciler).not.toHaveBeenCalled();
-    });
-  });
-
-  describe('dropNextNodesOnReorder', () => {
-    it('Should return false if not reordered', () => {
-      const reorderLogic = vi.fn().mockReturnValue(false);
-      expect(
-        Reconciler.dropNextNodesOnReorder(
-          reorderLogic,
-          {} as TIsolate,
-          {} as TIsolate,
-        ),
-      ).toBe(false);
-    });
-
-    it('Should return true and slice history if reordered', () => {
-      const reorderLogic = vi.fn().mockReturnValue(true);
-      const current = {} as TIsolate;
-      const history = {} as TIsolate;
-
-      vi.mocked(VestRuntime.useIsolate).mockReturnValue(current);
-      vi.mocked(VestRuntime.useHistoryIsolate).mockReturnValue(history);
-      vi.mocked(IsolateInspector.cursor).mockReturnValue(5);
-
-      expect(
-        Reconciler.dropNextNodesOnReorder(
-          reorderLogic,
-          {} as TIsolate,
-          {} as TIsolate,
-        ),
-      ).toBe(true);
-      expect(IsolateMutator.slice).toHaveBeenCalledWith(history, 5);
-    });
-  });
-
-  describe('handleIsolateNodeWithKey', () => {
-    it('Should return existing node if found in history by key', () => {
-      const node = { key: 'key1' } as TIsolate;
-      const prevNode = { key: 'key1', old: true } as unknown as TIsolate;
-      const historyParent = { children: [prevNode] } as unknown as TIsolate;
-
-      vi.mocked(IsolateInspector.usesKey).mockReturnValue(true);
-      vi.mocked(VestRuntime.useHistoryIsolate).mockReturnValue(historyParent);
-
-      expect(Reconciler.handleIsolateNodeWithKey(node, false)).toBe(prevNode);
-      expect(VestRuntime.useSetIsolateKey).toHaveBeenCalledWith(
-        'key1',
-        prevNode,
-      );
-    });
-
-    it('Should return new node if not found in history', () => {
-      const node = { key: 'key1' } as TIsolate;
-      const historyParent = { children: [] } as unknown as TIsolate;
-
-      vi.mocked(IsolateInspector.usesKey).mockReturnValue(true);
-      vi.mocked(VestRuntime.useHistoryIsolate).mockReturnValue(historyParent);
-
-      expect(Reconciler.handleIsolateNodeWithKey(node, false)).toBe(node);
-      expect(VestRuntime.useSetIsolateKey).toHaveBeenCalledWith('key1', node);
-    });
-  });
-
-  describe('When history node is missing (handleNoHistoryNode)', () => {
-    it('Should handle keyed node when history is missing', () => {
-      const node = { key: 'alert' } as TIsolate;
-      vi.mocked(VestRuntime.useHistoryIsolateAtCurrentPosition).mockReturnValue(
-        null,
-      );
-      // Only usesKey true triggers the branch
-      vi.mocked(IsolateInspector.usesKey).mockReturnValue(true);
-      // We need handleIsolateNodeWithKey mock behavior or reliance on real impl?
-      // Reconciler is the class under test, so its static methods are real.
-      // But handleIsolateNodeWithKey is static on Reconciler.
-
-      // Let's spy on handleIsolateNodeWithKey if we can, or just trust the integration.
-      // Since it calls handleIsolateNodeWithKey, let's ensure it flows there.
-      // handleIsolateNodeWithKey calls useHistoryKey etc.
-      vi.mocked(VestRuntime.useHistoryKey).mockReturnValue(null);
-
-      const result = Reconciler.reconcile(node);
-      expect(result).toBe(node);
-      expect(IsolateInspector.usesKey).toHaveBeenCalledWith(node);
-    });
-  });
-
-  describe('dropNextNodesOnReorder guard', () => {
-    it('Should return early if history or current node are missing', () => {
-      const reorderLogic = vi.fn().mockReturnValue(true);
-      vi.mocked(VestRuntime.useIsolate).mockReturnValue(null); // Force null
-      vi.mocked(VestRuntime.useHistoryIsolate).mockReturnValue(null);
-
-      expect(
-        Reconciler.dropNextNodesOnReorder(
-          reorderLogic,
-          {} as TIsolate,
-          {} as TIsolate,
-        ),
-      ).toBe(true);
-      // Should NOT call slice
-      expect(IsolateMutator.slice).not.toHaveBeenCalled();
-    });
-  });
-});