vestjs-runtime 1.6.0 → 1.7.0

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

@@ -1,111 +0,0 @@
-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

@@ -1,72 +0,0 @@
-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

@@ -1,44 +0,0 @@
-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

@@ -1,58 +0,0 @@
-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

@@ -1,71 +0,0 @@
-// 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

@@ -1,85 +0,0 @@
-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', () => {});
-    }),
-  );
-}