vestjs-runtime 1.6.0 → 1.7.0

package/src/Isolate/__tests__/IsolateFocused.test.ts

@@ -1,199 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { CB } from 'vest-utils';
-
-import { IReconciler } from '../../Reconciler';
-import {
-  IsolateFocused,
-  FocusModes,
-  FocusSelectors,
-  VestIsolateTypeFocused,
-} from '../IsolateFocused';
-import * as VestRuntime from '../../VestRuntime';
-import { IsolateKeys } from '../IsolateKeys';
-import { Isolate } from '../Isolate';
-
-describe('IsolateFocused', () => {
-  function withRunTime<T>(fn: CB<T>) {
-    return VestRuntime.Run(
-      VestRuntime.createRef((() => null) as unknown as IReconciler, v => v),
-      () => fn(),
-    );
-  }
-
-  describe('Focus Modes', () => {
-    it('Should expose ONLY and SKIP focus modes', () => {
-      expect(FocusModes.ONLY).toBe('only');
-      expect(FocusModes.SKIP).toBe('skip');
-    });
-  });
-
-  describe('Isolate creation', () => {
-    it('Should return undefined if no fields are provided and matchAll is false', () => {
-      let node: any;
-      withRunTime(() => {
-        Isolate.create('Root', () => {
-          node = IsolateFocused(FocusModes.ONLY, []);
-        });
-      });
-      expect(node).toBeUndefined();
-
-      let node2: any;
-      withRunTime(() => {
-        Isolate.create('Root', () => {
-          node2 = IsolateFocused(FocusModes.ONLY);
-        });
-      });
-      expect(node2).toBeUndefined();
-    });
-
-    it('Should create a focused isolate when matchAll is true', () => {
-      let node: any;
-      withRunTime(() => {
-        Isolate.create('Root', () => {
-          node = IsolateFocused(FocusModes.SKIP, true);
-        });
-      });
-      expect(node[IsolateKeys.Type]).toBe(VestIsolateTypeFocused);
-      expect(node[IsolateKeys.Transient]).toBe(true);
-      expect(node.data).toEqual({
-        focusMode: FocusModes.SKIP,
-        match: [],
-        matchAll: true,
-      });
-    });
-
-    it('Should create a focused isolate with specified fields', () => {
-      let node: any;
-      withRunTime(() => {
-        Isolate.create('Root', () => {
-          node = IsolateFocused(FocusModes.ONLY, ['field1', 'field2']);
-        });
-      });
-      expect(node[IsolateKeys.Type]).toBe(VestIsolateTypeFocused);
-      expect(node[IsolateKeys.Transient]).toBe(true);
-      expect(node.data).toEqual({
-        focusMode: FocusModes.ONLY,
-        match: ['field1', 'field2'],
-        matchAll: false,
-      });
-    });
-  });
-
-  describe('FocusSelectors', () => {
-    describe('isIsolateFocused', () => {
-      it('Should correctly identify a focused isolate', () => {
-        let node: any;
-        withRunTime(() => {
-          Isolate.create('Root', () => {
-            node = IsolateFocused(FocusModes.ONLY, ['field1']);
-          });
-        });
-        expect(FocusSelectors.isIsolateFocused(node)).toBe(true);
-      });
-
-      it('Should return false for non-focused isolates', () => {
-        let node: any;
-        withRunTime(() => {
-          node = Isolate.create('Root', () => {});
-        });
-        expect(FocusSelectors.isIsolateFocused(node)).toBe(false);
-      });
-    });
-
-    describe('isSkipFocused', () => {
-      it('Should return false if focus is undefined', () => {
-        expect(FocusSelectors.isSkipFocused(undefined, 'field1')).toBe(false);
-      });
-
-      it('Should return false if focus mode is missing or not SKIP', () => {
-        let node: any;
-        withRunTime(() => {
-          Isolate.create('Root', () => {
-            node = IsolateFocused(FocusModes.ONLY, ['field1']);
-          });
-        });
-        expect(FocusSelectors.isSkipFocused(node, 'field1')).toBe(false);
-      });
-
-      it('Should return true if focus is SKIP and matchAll is true', () => {
-        let node: any;
-        withRunTime(() => {
-          Isolate.create('Root', () => {
-            node = IsolateFocused(FocusModes.SKIP, true);
-          });
-        });
-        expect(FocusSelectors.isSkipFocused(node)).toBe(true);
-        expect(FocusSelectors.isSkipFocused(node, 'anyField')).toBe(true);
-      });
-
-      it('Should return true if focus is SKIP and matches the fieldName', () => {
-        let node: any;
-        withRunTime(() => {
-          Isolate.create('Root', () => {
-            node = IsolateFocused(FocusModes.SKIP, ['field1']);
-          });
-        });
-        expect(FocusSelectors.isSkipFocused(node, 'field1')).toBe(true);
-        expect(FocusSelectors.isSkipFocused(node, 'field2')).toBe(false);
-      });
-
-      it('Should return true if no fieldName is provided but matches exist', () => {
-        let node: any;
-        withRunTime(() => {
-          Isolate.create('Root', () => {
-            node = IsolateFocused(FocusModes.SKIP, ['field1']);
-          });
-        });
-        expect(FocusSelectors.isSkipFocused(node)).toBe(true);
-      });
-    });
-
-    describe('isOnlyFocused', () => {
-      it('Should return false if focus is undefined', () => {
-        expect(FocusSelectors.isOnlyFocused(undefined, 'field1')).toBe(false);
-      });
-
-      it('Should return false if focus mode is missing or not ONLY', () => {
-        let node: any;
-        withRunTime(() => {
-          Isolate.create('Root', () => {
-            node = IsolateFocused(FocusModes.SKIP, ['field1']);
-          });
-        });
-        expect(FocusSelectors.isOnlyFocused(node, 'field1')).toBe(false);
-      });
-
-      it('Should return true if focus is ONLY and matches the fieldName', () => {
-        let node: any;
-        withRunTime(() => {
-          Isolate.create('Root', () => {
-            node = IsolateFocused(FocusModes.ONLY, ['field1', 'field2']);
-          });
-        });
-        expect(FocusSelectors.isOnlyFocused(node, 'field1')).toBe(true);
-        expect(FocusSelectors.isOnlyFocused(node, 'field3')).toBe(false);
-      });
-
-      it('Should return true if focus is ONLY and matchAll is true', () => {
-        let node: any;
-        withRunTime(() => {
-          Isolate.create('Root', () => {
-            node = IsolateFocused(FocusModes.ONLY, true);
-          });
-        });
-        expect(FocusSelectors.isOnlyFocused(node)).toBe(true);
-        expect(FocusSelectors.isOnlyFocused(node, 'anyField')).toBe(true);
-      });
-
-      it('Should return true if no fieldName is provided but matches exist', () => {
-        let node: any;
-        withRunTime(() => {
-          Isolate.create('Root', () => {
-            node = IsolateFocused(FocusModes.ONLY, ['field1']);
-          });
-        });
-        expect(FocusSelectors.isOnlyFocused(node)).toBe(true);
-      });
-    });
-  });
-});

package/src/Isolate/__tests__/IsolateInspector.test.ts

@@ -1,136 +0,0 @@
-import { describe, it, expect } from 'vitest';
-
-import { TIsolate } from '../Isolate';
-import { IsolateInspector } from '../IsolateInspector';
-
-describe('IsolateInspector', () => {
-  describe('at', () => {
-    describe('When the isolate is nullish', () => {
-      it('Should return null', () => {
-        expect(IsolateInspector.at(null, 0)).toBeNull();
-      });
-    });
-
-    describe('When the children are nullish', () => {
-      it('Should return null', () => {
-        const isolate = { children: null } as unknown as TIsolate;
-
-        expect(IsolateInspector.at(isolate, 0)).toBeNull();
-      });
-    });
-
-    describe('When the child does not exist', () => {
-      it('Should return null', () => {
-        const isolate = { children: [] } as unknown as TIsolate;
-
-        expect(IsolateInspector.at(isolate, 0)).toBeNull();
-      });
-    });
-
-    describe('When the child exists', () => {
-      it('Should return the child', () => {
-        const child = {} as TIsolate;
-        const child1 = {} as TIsolate;
-        const isolate = { children: [child, child1] } as unknown as TIsolate;
-
-        expect(IsolateInspector.at(isolate, 0)).toBe(child);
-        expect(IsolateInspector.at(isolate, 1)).toBe(child1);
-      });
-    });
-  });
-
-  describe('cursor', () => {
-    describe('When the isolate is nullish', () => {
-      it('Should return 0', () => {
-        expect(IsolateInspector.cursor(null)).toBe(0);
-      });
-    });
-
-    describe('When the children are nullish', () => {
-      it('Should return 0', () => {
-        const isolate = { children: null } as unknown as TIsolate;
-
-        expect(IsolateInspector.cursor(isolate)).toBe(0);
-      });
-    });
-
-    describe('When the children exist', () => {
-      it('Should return the length of the children', () => {
-        const child = {} as TIsolate;
-        const child1 = {} as TIsolate;
-        const isolate = { children: [child, child1] } as unknown as TIsolate;
-
-        expect(IsolateInspector.cursor(isolate)).toBe(2);
-      });
-    });
-  });
-
-  describe('canReorder', () => {
-    describe('When the isolate is nullish', () => {
-      it('Should return false', () => {
-        expect(IsolateInspector.canReorder(null)).toBe(false);
-      });
-    });
-
-    describe('When the isolate does not allow reordering', () => {
-      it('Should return false', () => {
-        const isolate = { allowReorder: false } as unknown as TIsolate;
-
-        expect(IsolateInspector.canReorder(isolate)).toBe(false);
-      });
-    });
-
-    describe('When the isolate does not allow reordering but a parent does', () => {
-      it('Should return true', () => {
-        const root = { allowReorder: false } as unknown as TIsolate;
-        const parent = {
-          allowReorder: true,
-          parent: root,
-        } as unknown as TIsolate;
-        const isolate = { allowReorder: false, parent } as unknown as TIsolate;
-
-        expect(IsolateInspector.canReorder(isolate)).toBe(true);
-      });
-
-      describe('When only the root allows reordering', () => {
-        it('Should return false', () => {
-          const root = { allowReorder: true } as unknown as TIsolate;
-          const parent = {
-            allowReorder: false,
-            parent: root,
-          } as unknown as TIsolate;
-          const isolate = {
-            allowReorder: false,
-            parent,
-          } as unknown as TIsolate;
-
-          expect(IsolateInspector.canReorder(isolate)).toBe(false);
-        });
-      });
-    });
-  });
-
-  describe('usesKey', () => {
-    describe('When the node is nullish', () => {
-      it('Should return false', () => {
-        expect(IsolateInspector.usesKey(null)).toBe(false);
-      });
-    });
-
-    describe('When the node does not have a key', () => {
-      it('Should return false', () => {
-        const isolate = { key: null } as unknown as TIsolate;
-
-        expect(IsolateInspector.usesKey(isolate)).toBe(false);
-      });
-    });
-
-    describe('When the node has a key', () => {
-      it('Should return true', () => {
-        const isolate = { key: 'key' } as unknown as TIsolate;
-
-        expect(IsolateInspector.usesKey(isolate)).toBe(true);
-      });
-    });
-  });
-});

package/src/Isolate/__tests__/IsolateMutator.test.ts

@@ -1,164 +0,0 @@
-import { TIsolate } from '../Isolate';
-import { IsolateMutator } from '../IsolateMutator';
-import { describe, it, expect, vi } from 'vitest';
-
-describe('IsolateMutator', () => {
-  describe('setParent', () => {
-    it('should set parent', () => {
-      const parent = {} as TIsolate;
-      const isolate = {} as TIsolate;
-
-      expect(isolate.parent).toBeUndefined();
-      expect(IsolateMutator.setParent(isolate, parent)).toBe(isolate);
-      expect(isolate.parent).toBe(parent);
-    });
-
-    describe('When the child already has a parent', () => {
-      it('Should set the new parent of the child', () => {
-        const parent1 = {} as TIsolate;
-        const parent2 = {} as TIsolate;
-        const isolate = {} as TIsolate;
-
-        IsolateMutator.setParent(isolate, parent1);
-        expect(isolate.parent).toBe(parent1);
-        IsolateMutator.setParent(isolate, parent2);
-        expect(isolate.parent).toBe(parent2);
-      });
-    });
-  });
-
-  describe('saveOutput', () => {
-    it('should save output', () => {
-      const isolate = {} as TIsolate;
-      const output = {};
-
-      expect(isolate.output).toBeUndefined();
-      expect(IsolateMutator.saveOutput(isolate, output)).toBe(isolate);
-      expect(isolate.output).toBe(output);
-    });
-  });
-
-  describe('setKey', () => {
-    it('should set key', () => {
-      const isolate = {} as TIsolate;
-      const key = 'foo';
-
-      expect(isolate.key).toBeUndefined();
-      expect(IsolateMutator.setKey(isolate, key)).toBe(isolate);
-      expect(isolate.key).toBe(key);
-    });
-  });
-
-  describe('addChild', () => {
-    it('should add child', () => {
-      const isolate = { children: [] } as unknown as TIsolate;
-      const child1 = {} as TIsolate;
-      const child2 = {} as TIsolate;
-
-      expect(isolate.children).toEqual([]);
-      IsolateMutator.addChild(isolate, child1);
-      expect(isolate.children).toEqual([child1]);
-      IsolateMutator.addChild(isolate, child2);
-      expect(isolate.children).toEqual([child1, child2]);
-    });
-
-    it('should set parent of the child', () => {
-      const isolate = { children: [] } as unknown as TIsolate;
-      const child = {} as TIsolate;
-
-      expect(child.parent).toBeUndefined();
-      IsolateMutator.addChild(isolate, child);
-      expect(child.parent).toBe(isolate);
-    });
-  });
-
-  describe('removeChild', () => {
-    it('Should remove child', () => {
-      const child1 = {} as TIsolate;
-      const child2 = {} as TIsolate;
-      const isolate = { children: [child1, child2] } as unknown as TIsolate;
-
-      expect(isolate.children).toEqual([child1, child2]);
-      IsolateMutator.removeChild(isolate, child1);
-      expect(isolate.children).toEqual([child2]);
-      IsolateMutator.removeChild(isolate, child2);
-      expect(isolate.children).toEqual([]);
-    });
-
-    describe('When the child does not exist', () => {
-      it('Should no-op', () => {
-        const child = {} as TIsolate;
-        const isolate = { children: [] } as unknown as TIsolate;
-
-        expect(isolate.children).toEqual([]);
-        IsolateMutator.removeChild(isolate, child);
-        expect(isolate.children).toEqual([]);
-      });
-    });
-  });
-
-  describe('slice', () => {
-    it('Should slice children', () => {
-      const child1 = {} as TIsolate;
-      const child2 = {} as TIsolate;
-      const isolate = { children: [child1, child2] } as unknown as TIsolate;
-
-      expect(isolate.children).toEqual([child1, child2]);
-      IsolateMutator.slice(isolate, 1);
-      expect(isolate.children).toEqual([child1]);
-    });
-
-    describe('When children are nullish', () => {
-      it('Should no-op', () => {
-        const isolate = { children: null } as unknown as TIsolate;
-
-        expect(isolate.children).toBeNull();
-        IsolateMutator.slice(isolate, 1);
-        expect(isolate.children).toBeNull();
-      });
-    });
-  });
-
-  describe('abort', () => {
-    it('Should abort the controller', () => {
-      const isolate = {
-        abortController: { abort: vi.fn() },
-      } as unknown as TIsolate;
-
-      expect(isolate.abortController!.abort).not.toHaveBeenCalled();
-      IsolateMutator.abort(isolate);
-      expect(isolate.abortController!.abort).toHaveBeenCalled();
-    });
-
-    describe('When the controller is nullish', () => {
-      it('Should no-op', () => {
-        const isolate = { abortController: null } as unknown as TIsolate;
-
-        expect(isolate.abortController).toBeNull();
-        IsolateMutator.abort(isolate);
-        expect(isolate.abortController).toBeNull();
-      });
-    });
-
-    it('Should abort the controller with the passed reason', () => {
-      const isolate = {
-        abortController: { abort: vi.fn() },
-      } as unknown as TIsolate;
-
-      expect(isolate.abortController!.abort).not.toHaveBeenCalled();
-      IsolateMutator.abort(isolate, 'foo');
-      expect(isolate.abortController!.abort).toHaveBeenCalledWith('foo');
-    });
-  });
-
-  describe('setData', () => {
-    it('Should set the data', () => {
-      const isolate = {} as TIsolate;
-      const data = { foo: 'bar' };
-
-      expect(isolate.data).toBeUndefined();
-      IsolateMutator.setData(isolate, data);
-      expect(isolate.data).toBe(data);
-    });
-  });
-});

package/src/Isolate/__tests__/IsolatePropagation.test.ts

@@ -1,170 +0,0 @@
-import {
-  Isolate,
-  IsolateStatus,
-  TIsolate,
-  VestRuntime,
-  IsolateMutator,
-} from 'vestjs-runtime';
-import wait from 'wait';
-import { describe, it, expect, vi } from 'vitest';
-
-function mockRunTime(fn: () => void) {
-  // We mock a minimal runtime context for the test
-  const ref = {
-    historyNode: null,
-    runtimeNode: null,
-    runtimeRoot: null,
-  };
-  return VestRuntime.Run(VestRuntime.createRef(ref as any, vi.fn()), fn);
-}
-
-describe('Isolate Status Propagation (HAS_PENDING)', () => {
-  it('Should set all ancestors to HAS_PENDING when a child is async', async () => {
-    let root!: TIsolate;
-    let parent!: TIsolate;
-    let child!: TIsolate;
-    let resolveChild!: (value?: unknown) => void;
-
-    mockRunTime(() => {
-      root = Isolate.create('Root', () => {
-        parent = Isolate.create('Parent', () => {
-          child = Isolate.create(
-            'Child',
-            () =>
-              new Promise(r => {
-                resolveChild = r;
-              }),
-          );
-        });
-      });
-    });
-
-    expect(child.status).toBe(IsolateStatus.PENDING);
-    expect(parent.status).toBe(IsolateStatus.HAS_PENDING);
-    expect(root.status).toBe(IsolateStatus.HAS_PENDING);
-
-    // This part tests the 'bubbleUpDone' logic (Phase 2 implementation)
-    resolveChild();
-    await wait(1); // Wait for microtask queue
-    await wait(1); // Ensure all callbacks are resolved
-
-    expect(child.status).toBe(IsolateStatus.DONE);
-    expect(parent.status).toBe(IsolateStatus.DONE);
-    expect(root.status).toBe(IsolateStatus.DONE);
-  });
-  it('Should remain HAS_PENDING if a sibling is still pending', async () => {
-    let root!: TIsolate;
-    let parent!: TIsolate;
-    let child1!: TIsolate;
-    let child2!: TIsolate;
-    let resolve1!: (value?: unknown) => void;
-    let resolve2!: (value?: unknown) => void;
-
-    mockRunTime(() => {
-      root = Isolate.create('Root', () => {
-        parent = Isolate.create('Parent', () => {
-          child1 = Isolate.create(
-            'Child1',
-            () =>
-              new Promise(r => {
-                resolve1 = r;
-              }),
-          );
-          child2 = Isolate.create(
-            'Child2',
-            () =>
-              new Promise(r => {
-                resolve2 = r;
-              }),
-          );
-        });
-      });
-    });
-
-    expect(child1.status).toBe(IsolateStatus.PENDING);
-    expect(child2.status).toBe(IsolateStatus.PENDING);
-    expect(parent.status).toBe(IsolateStatus.HAS_PENDING);
-    expect(root.status).toBe(IsolateStatus.HAS_PENDING);
-
-    // Resolve first child
-    resolve1();
-    await wait(1); // Wait for microtask queue
-    await wait(1); // Ensure callbacks
-
-    // Parent should still be HAS_PENDING because Child2 is pending
-    expect(child1.status).toBe(IsolateStatus.DONE);
-    expect(child2.status).toBe(IsolateStatus.PENDING);
-    expect(parent.status).toBe(IsolateStatus.HAS_PENDING);
-    expect(root.status).toBe(IsolateStatus.HAS_PENDING);
-
-    // Resolve second child
-    resolve2();
-    await wait(1); // Wait for microtask queue
-    await wait(1);
-
-    // Parent and root should now transition to DONE
-    expect(child2.status).toBe(IsolateStatus.DONE);
-    expect(parent.status).toBe(IsolateStatus.DONE);
-    expect(root.status).toBe(IsolateStatus.DONE);
-  });
-
-  it('Should remain HAS_PENDING if an indirect descendant is pending', async () => {
-    let parent!: TIsolate;
-    let nestedParent!: TIsolate;
-    let leaf!: TIsolate;
-    let resolveLeaf!: (value?: unknown) => void;
-
-    mockRunTime(() => {
-      parent = Isolate.create('Parent', () => {
-        nestedParent = Isolate.create('NestedParent', () => {
-          leaf = Isolate.create(
-            'Leaf',
-            () =>
-              new Promise(r => {
-                resolveLeaf = r;
-              }),
-          );
-        });
-      });
-    });
-
-    expect(leaf.status).toBe(IsolateStatus.PENDING);
-    expect(nestedParent.status).toBe(IsolateStatus.HAS_PENDING);
-    expect(parent.status).toBe(IsolateStatus.HAS_PENDING);
-
-    // Resolve leaf
-    resolveLeaf();
-    await wait(1); // Wait for microtask queue
-    await wait(1);
-
-    // All should transition to DONE
-    expect(leaf.status).toBe(IsolateStatus.DONE);
-    expect(nestedParent.status).toBe(IsolateStatus.DONE);
-    expect(parent.status).toBe(IsolateStatus.DONE);
-  });
-
-  it('Should prevent manual setDone transition if children are active', async () => {
-    let parent!: TIsolate;
-    let child!: TIsolate;
-
-    mockRunTime(() => {
-      parent = Isolate.create('Parent', () => {
-        child = Isolate.create(
-          'Child',
-          () => new Promise(() => {}), // Never resolves
-        );
-      });
-    });
-
-    expect(child.status).toBe(IsolateStatus.PENDING);
-    expect(parent.status).toBe(IsolateStatus.HAS_PENDING);
-
-    // Try to force setDone on parent
-    mockRunTime(() => {
-      IsolateMutator.setDone(parent);
-    });
-
-    // Should still be HAS_PENDING
-    expect(parent.status).toBe(IsolateStatus.HAS_PENDING);
-  });
-});