vestjs-runtime 1.7.0 → 2.0.1

package/src/Isolate/IsolateTypes.ts

@@ -0,0 +1,33 @@
+import { Nullable } from 'vest-utils';
+
+import { IsolateKeys } from './IsolateKeys';
+import { IsolateStatus } from './IsolateStatus';
+
+export type IsolateKey = Nullable<string>;
+
+export type TIsolate<P extends IsolatePayload = IsolatePayload> = {
+  [IsolateKeys.AllowReorder]?: boolean;
+  [IsolateKeys.Transient]?: boolean;
+  [IsolateKeys.Parent]: Nullable<TIsolate>;
+  [IsolateKeys.Type]: string;
+  [IsolateKeys.Keys]: Nullable<Record<string, TIsolate>>;
+  [IsolateKeys.Data]: DataOnly<P>;
+  [IsolateKeys.Status]: IsolateStatus;
+  [IsolateKeys.AbortController]: Nullable<AbortController>;
+  children: Nullable<TIsolate[]>;
+  key: IsolateKey;
+  output: any;
+} & UsedFeaturesOnly<P>;
+
+type DataOnly<P extends IsolatePayload> = Omit<P, keyof IsolateFeatures>;
+type UsedFeaturesOnly<P extends IsolatePayload> = Pick<
+  P,
+  keyof IsolateFeatures
+>;
+
+export type IsolatePayload<P = Record<string, any>> = P & IsolateFeatures;
+export type IsolateFeatures = {
+  [IsolateKeys.AllowReorder]?: boolean;
+  [IsolateKeys.Transient]?: boolean;
+  [IsolateKeys.Status]?: IsolateStatus;
+};

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

@@ -0,0 +1,123 @@
+import { CB } from 'vest-utils';
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+
+import { TIsolate, Isolate } from '../Isolate';
+import { StateRefType, useAvailableRoot } from '../../VestRuntime';
+import { IsolateMutator, VestRuntime, IReconciler } from '../../vestjs-runtime';
+
+enum IsolateType {
+  Isolate = 'Isolate',
+  Child = 'Child',
+}
+
+describe('Isolate', () => {
+  let stateRef: StateRefType;
+
+  beforeEach(() => {
+    stateRef = VestRuntime.createRef({} as IReconciler, v => v);
+  });
+
+  describe('Isolate.create', () => {
+    it('should return an instance of Isolate', () => {
+      const isolate = withRunTime(() => {
+        return Isolate.create(IsolateType.Isolate, () => {});
+      });
+      expect(isolate).toBeInstanceOf(Object);
+    });
+
+    it('Should run the passed callback', () => {
+      const spy = vi.fn();
+      withRunTime(() => {
+        Isolate.create(IsolateType.Isolate, spy);
+      });
+      expect(spy).toHaveBeenCalled();
+    });
+
+    it('Should store the callback result in the output property', () => {
+      const isolate = withRunTime(() => {
+        return Isolate.create(
+          IsolateType.Isolate,
+          () => {
+            return 'foo';
+          },
+          {},
+        );
+      });
+      expect(isolate.output).toBe('foo');
+    });
+
+    describe('When there is no parent', () => {
+      it('Parent should be null', () => {
+        const isolate = withRunTime(() => {
+          return Isolate.create(IsolateType.Isolate, () => {});
+        });
+        expect(isolate.parent).toBeNull();
+      });
+
+      it('Should set the history root to the current isolate', () => {
+        const isolate = withRunTime(() => {
+          const isolate = Isolate.create(IsolateType.Isolate, () => {});
+
+          expect(useAvailableRoot()).toBe(isolate);
+
+          return isolate;
+        });
+        // Just verifying that we did not throw and catch inside the runtime
+        expect(isolate).toBeDefined();
+      });
+    });
+
+    describe('When there is a parent', () => {
+      it('Should add the isolate to the parent children', () => {
+        const [parent, children] = withRunTime(() => {
+          const children = [] as TIsolate[];
+          const parent = Isolate.create(IsolateType.Isolate, () => {
+            children.push(Isolate.create(IsolateType.Child, () => {}));
+            children.push(Isolate.create(IsolateType.Child, () => {}));
+            children.push(Isolate.create(IsolateType.Child, () => {}));
+            children.push(Isolate.create(IsolateType.Child, () => {}));
+          });
+          return [parent, children];
+        });
+        expect(parent.children).toEqual(children);
+      });
+
+      it('Should set the parent property', () => {
+        const [parent, child] = withRunTime(() => {
+          let child = {} as TIsolate;
+          const parent = Isolate.create(IsolateType.Isolate, () => {
+            child = Isolate.create(IsolateType.Child, () => null);
+          });
+
+          return [parent, child];
+        });
+        expect(child.parent).toBe(parent);
+      });
+    });
+  });
+
+  describe('AbortController', () => {
+    it('Should be initially null', () => {
+      const isolate = withRunTime(() => {
+        return Isolate.create(IsolateType.Isolate, () => {});
+      });
+      expect(isolate.abortController).toBeNull();
+    });
+
+    it('Should abort the controller with the passed reason', () => {
+      const isolate = withRunTime(() => {
+        return Isolate.create(IsolateType.Isolate, () => {});
+      });
+      isolate.abortController = new AbortController();
+      const spy = vi.spyOn(isolate.abortController, 'abort');
+      IsolateMutator.abort(isolate, 'foo');
+      expect(spy).toHaveBeenCalledWith('foo');
+    });
+  });
+
+  function withRunTime<T>(fn: CB<T>) {
+    return VestRuntime.Run(stateRef, () => {
+      return fn();
+    });
+  }
+});

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

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

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

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