vestjs-runtime 1.7.0 → 2.0.1

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

@@ -0,0 +1,170 @@
+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);
+  });
+});

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

@@ -0,0 +1,111 @@
+import { CB } from 'vest-utils';
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+
+import { IsolateReorderable } from '../IsolateReorderable';
+import { IsolateInspector } from '../IsolateInspector';
+import { IsolateKeys } from '../IsolateKeys';
+import { VestRuntime, IReconciler, Isolate } from '../../vestjs-runtime';
+
+describe('IsolateReorderable', () => {
+  let stateRef: any;
+  // Mock reconciler to test reordering enforcement
+  const testReconciler = vi.fn((currentNode: any, historyNode: any) => {
+    // Simple check: if keys don't match, verify if reorder is allowed
+    if (currentNode.key !== historyNode.key) {
+      if (!IsolateInspector.canReorder(currentNode)) {
+        throw new Error('Reorder violation');
+      }
+    }
+    return currentNode;
+  });
+
+  beforeEach(() => {
+    testReconciler.mockClear();
+    stateRef = VestRuntime.createRef(
+      testReconciler as unknown as IReconciler,
+      v => v,
+    );
+  });
+
+  function withRunTime<T>(fn: CB<T>) {
+    return VestRuntime.Run(stateRef, () => {
+      return fn();
+    });
+  }
+
+  it('Should return an isolate with allowReorder set to true', () => {
+    const isolate = withRunTime(() => IsolateReorderable(() => {}));
+    expect(isolate[IsolateKeys.AllowReorder]).toBe(true);
+  });
+
+  it('Should set the type to "Reorderable" by default', () => {
+    const isolate = withRunTime(() => IsolateReorderable(() => {}));
+    expect(isolate[IsolateKeys.Type]).toBe('Reorderable');
+  });
+
+  it('Should allow overriding the type', () => {
+    const isolate = withRunTime(() =>
+      IsolateReorderable(() => {}, 'CustomType'),
+    );
+    expect(isolate[IsolateKeys.Type]).toBe('CustomType');
+  });
+
+  it('Should set the payload', () => {
+    const payload = { foo: 'bar' };
+    const isolate = withRunTime(() =>
+      IsolateReorderable(() => {}, 'Type', payload),
+    );
+    expect(isolate[IsolateKeys.Data]).toMatchObject(payload);
+  });
+
+  it('Should run the callback', () => {
+    const spy = vi.fn();
+    withRunTime(() => IsolateReorderable(spy));
+    expect(spy).toHaveBeenCalled();
+  });
+
+  describe('Reordering', () => {
+    describe('When the isolate is reorderable', () => {
+      it('Should allow reordering', () => {
+        withRunTime(() => {
+          IsolateReorderable(() => {
+            Isolate.create('Child', () => {}, {}, 'A');
+            Isolate.create('Child', () => {}, {}, 'B');
+          });
+        });
+
+        expect(() => {
+          withRunTime(() => {
+            IsolateReorderable(() => {
+              // Swapped order
+              Isolate.create('Child', () => {}, {}, 'B');
+              Isolate.create('Child', () => {}, {}, 'A');
+            });
+          });
+        }).not.toThrow();
+      });
+    });
+
+    describe('Sanity (Failure case)', () => {
+      it('Should NOT allow reordering when parent is not Reorderable', () => {
+        withRunTime(() => {
+          // Standard Isolate does not allow reordering
+          Isolate.create('Parent', () => {
+            Isolate.create('Child', () => {}, {}, 'A');
+            Isolate.create('Child', () => {}, {}, 'B');
+          });
+        });
+
+        expect(() => {
+          withRunTime(() => {
+            Isolate.create('Parent', () => {
+              // Swapped order
+              Isolate.create('Child', () => {}, {}, 'B');
+              Isolate.create('Child', () => {}, {}, 'A');
+            });
+          });
+        }).toThrow('Reorder violation');
+      });
+    });
+  });
+});

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

@@ -0,0 +1,72 @@
+import { describe, it, expect } from 'vitest';
+import {
+  isIsolateType,
+  isSameIsolateType,
+  isSameIsolateIdentity,
+} from '../IsolateSelectors';
+import { IsolateKeys } from '../IsolateKeys';
+
+describe('IsolateSelectors', () => {
+  const type = 'TEST_TYPE';
+  const otherType = 'OTHER_TYPE';
+
+  const isolate1 = { [IsolateKeys.Type]: type, key: 'key1' };
+  const isolate2 = { [IsolateKeys.Type]: type, key: 'key1' };
+  const isolate3 = { [IsolateKeys.Type]: type, key: 'key2' };
+  const isolate4 = { [IsolateKeys.Type]: otherType, key: 'key1' };
+  const nullIsolate = null;
+  const undefinedIsolate = undefined;
+
+  describe('isIsolateType', () => {
+    it('should return true if type matches', () => {
+      // @ts-ignore
+      expect(isIsolateType(isolate1, type)).toBe(true);
+    });
+
+    it('should return false if type matches', () => {
+      // @ts-ignore
+      expect(isIsolateType(isolate1, otherType)).toBe(false);
+    });
+
+    it('should return false if node is null/undefined', () => {
+      // @ts-ignore
+      expect(isIsolateType(nullIsolate, type)).toBe(false);
+      // @ts-ignore
+      expect(isIsolateType(undefinedIsolate, type)).toBe(false);
+    });
+  });
+
+  describe('isSameIsolateType', () => {
+    it('should return true if type matches', () => {
+      // @ts-ignore
+      expect(isSameIsolateType(isolate1, isolate2)).toBe(true);
+    });
+
+    it('should return false if type matches', () => {
+      // @ts-ignore
+      expect(isSameIsolateType(isolate1, isolate4)).toBe(false);
+    });
+  });
+
+  describe('isSameIsolateIdentity', () => {
+    it('should return true if strictly equal', () => {
+      // @ts-ignore
+      expect(isSameIsolateIdentity(isolate1, isolate1)).toBe(true);
+    });
+
+    it('should return true if type and key match', () => {
+      // @ts-ignore
+      expect(isSameIsolateIdentity(isolate1, isolate2)).toBe(true);
+    });
+
+    it('should return false if keys differ', () => {
+      // @ts-ignore
+      expect(isSameIsolateIdentity(isolate1, isolate3)).toBe(false);
+    });
+
+    it('should return false if types differ', () => {
+      // @ts-ignore
+      expect(isSameIsolateIdentity(isolate1, isolate4)).toBe(false);
+    });
+  });
+});

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

@@ -0,0 +1,44 @@
+import { Isolate, IsolateStatus, TIsolate, VestRuntime } from 'vestjs-runtime';
+import { describe, it, expect } from 'vitest';
+
+describe('Isolate Status Transitions', () => {
+  it('Should initialize with INITIAL status', () => {
+    VestRuntime.Run(VestRuntime.createRef({} as any, {} as any), () => {
+      Isolate.create('Test', isolate => {
+        expect(isolate.status).toBe(IsolateStatus.INITIAL);
+      });
+    });
+  });
+
+  it('Should transition to DONE for sync callbacks', () => {
+    VestRuntime.Run(VestRuntime.createRef({} as any, {} as any), () => {
+      const isolate = Isolate.create('Test', () => {});
+      expect(isolate.status).toBe(IsolateStatus.DONE);
+    });
+  });
+
+  it('Should transition to PENDING then DONE for async callbacks', async () => {
+    let resolve: (_value?: unknown) => void = () => {};
+    const promise = new Promise(r => (resolve = r));
+    const isolate = await new Promise<TIsolate>(done => {
+      VestRuntime.Run(VestRuntime.createRef({} as any, {} as any), () => {
+        const createdIsolate = Isolate.create('AsyncTest', async () => {
+          await promise;
+        });
+        done(createdIsolate);
+      });
+    });
+
+    // Since Isolate.create runs the callback, for async it returns the isolate
+    // which should be PENDING state before the promise resolves
+    expect(isolate.status).toBe(IsolateStatus.PENDING);
+
+    resolve();
+    await promise;
+
+    // Wait for microtasks
+    await new Promise(process.nextTick);
+
+    expect(isolate.status).toBe(IsolateStatus.DONE);
+  });
+});

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

@@ -0,0 +1,58 @@
+import { describe, it, expect } from 'vitest';
+import { CB } from 'vest-utils';
+
+import { IReconciler } from '../../Reconciler';
+import { IsolateTransient } from '../IsolateTransient';
+import * as VestRuntime from '../../VestRuntime';
+import { IsolateKeys } from '../IsolateKeys';
+import { Isolate } from '../Isolate';
+
+describe('IsolateTransient', () => {
+  function withRunTime<T>(fn: CB<T>) {
+    return VestRuntime.Run(
+      VestRuntime.createRef((() => null) as unknown as IReconciler, v => v),
+      () => fn(),
+    );
+  }
+
+  it('should create an isolate with transient flag set to true', () => {
+    let node: any;
+    withRunTime(() => {
+      Isolate.create('Root', () => {
+        node = IsolateTransient(() => {});
+      });
+    });
+    expect(node[IsolateKeys.Transient]).toBe(true);
+  });
+
+  it('should use default type "Transient" when no type is provided', () => {
+    let node: any;
+    withRunTime(() => {
+      Isolate.create('Root', () => {
+        node = IsolateTransient(() => {});
+      });
+    });
+    expect(node[IsolateKeys.Type]).toBe('Transient');
+  });
+
+  it('should accept a custom type', () => {
+    let node: any;
+    withRunTime(() => {
+      Isolate.create('Root', () => {
+        node = IsolateTransient(() => {}, 'Debounce');
+      });
+    });
+    expect(node[IsolateKeys.Type]).toBe('Debounce');
+  });
+
+  it('should merge custom payload with transient flag', () => {
+    let node: any;
+    withRunTime(() => {
+      Isolate.create('Root', () => {
+        node = IsolateTransient(() => {}, 'Custom', { myData: 42 });
+      });
+    });
+    expect(node[IsolateKeys.Transient]).toBe(true);
+    expect(node[IsolateKeys.Data]).toEqual({ myData: 42 });
+  });
+});

package/src/Isolate/__tests__/__snapshots__/asyncIsolate.test.ts.snap

@@ -0,0 +1,71 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`AsyncIsolate > It should resolve async isolate into the parent 2`] = `
+IsolateInstance {
+  "$type": "URoot",
+  "abortController": null,
+  "allowReorder": undefined,
+  "children": [
+    IsolateInstance {
+      "$type": "UChild_1",
+      "abortController": null,
+      "allowReorder": undefined,
+      "children": [
+        IsolateInstance {
+          "$type": "UGrandChild_1",
+          "abortController": null,
+          "allowReorder": undefined,
+          "children": null,
+          "data": {},
+          "key": null,
+          "keys": null,
+          "output": undefined,
+          "parent": [Circular],
+          "status": "DONE",
+          "transient": undefined,
+        },
+        IsolateInstance {
+          "$type": "UGrandChild_2",
+          "abortController": null,
+          "allowReorder": undefined,
+          "children": null,
+          "data": {},
+          "key": null,
+          "keys": null,
+          "output": undefined,
+          "parent": [Circular],
+          "status": "DONE",
+          "transient": undefined,
+        },
+        IsolateInstance {
+          "$type": "UGrandChild_3",
+          "abortController": null,
+          "allowReorder": undefined,
+          "children": null,
+          "data": {},
+          "key": null,
+          "keys": null,
+          "output": undefined,
+          "parent": [Circular],
+          "status": "DONE",
+          "transient": undefined,
+        },
+      ],
+      "data": {},
+      "key": null,
+      "keys": null,
+      "output": undefined,
+      "parent": [Circular],
+      "status": "DONE",
+      "transient": undefined,
+    },
+  ],
+  "data": {},
+  "key": null,
+  "keys": null,
+  "output": Promise {},
+  "parent": null,
+  "status": "DONE",
+  "transient": undefined,
+}
+`;

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

@@ -0,0 +1,85 @@
+import { useBus } from '../../Bus';
+import { Isolate, TIsolate } from '../Isolate';
+import { CB } from 'vest-utils';
+import { describe, vi, it, expect, test } from 'vitest';
+import wait from 'wait';
+
+import { VestRuntime, IReconciler } from '../../vestjs-runtime';
+
+describe('AsyncIsolate', () => {
+  test('It should resolve async isolate into the parent', async () => {
+    let root = {} as TIsolate;
+    withRunTime(() => {
+      // Create root isolate from which all others will be created
+      root = Isolate.create('URoot', genChildren);
+    });
+    expect(root).toMatchInlineSnapshot(`
+      IsolateInstance {
+        "$type": "URoot",
+        "abortController": null,
+        "allowReorder": undefined,
+        "children": null,
+        "data": {},
+        "key": null,
+        "keys": null,
+        "output": Promise {},
+        "parent": null,
+        "status": "PENDING",
+        "transient": undefined,
+      }
+    `);
+    await wait(10);
+    expect(root?.children?.[0]?.$type).toBe('UChild_1');
+    expect(root?.children?.[0].parent).toBe(root);
+    expect(root?.children?.[0]?.children?.[0]?.$type).toBe('UGrandChild_1');
+    expect(root?.children?.[0]?.children?.[0].parent).toBe(root?.children?.[0]);
+    expect(root?.children?.[0]?.children?.[1]?.$type).toBe('UGrandChild_2');
+    expect(root?.children?.[0]?.children?.[1].parent).toBe(root?.children?.[0]);
+    expect(root?.children?.[0]?.children?.[2]?.$type).toBe('UGrandChild_3');
+    expect(root?.children?.[0]?.children?.[2].parent).toBe(root?.children?.[0]);
+    expect(root).toMatchSnapshot();
+  });
+
+  it('Should emit an event when an async isolate is done running', async () => {
+    const cb = vi.fn();
+    let child = {} as TIsolate;
+    withRunTime(() => {
+      // Create root isolate from which all others will be created
+      Isolate.create('URoot', () => {
+        const bus = useBus();
+        bus.on('ISOLATE_DONE', cb);
+
+        expect(cb).not.toHaveBeenCalled();
+        child = Isolate.create('UChild_1', async () => {
+          await wait(10);
+        });
+        expect(cb).not.toHaveBeenCalled();
+      });
+    });
+    expect(cb).not.toHaveBeenCalledWith(child);
+    await wait(10);
+    expect(cb).toHaveBeenCalledWith(child);
+  });
+});
+
+function withRunTime<T>(fn: CB<T>) {
+  return VestRuntime.Run(
+    VestRuntime.createRef({} as IReconciler, v => v),
+    () => {
+      return fn();
+    },
+  );
+}
+
+async function genChildren() {
+  await wait(10);
+  // Create first child isolate
+  return withRunTime(() =>
+    Isolate.create('UChild_1', () => {
+      // Create three grandchildren
+      Isolate.create('UGrandChild_1', () => {});
+      Isolate.create('UGrandChild_2', () => {});
+      Isolate.create('UGrandChild_3', () => {});
+    }),
+  );
+}