vestjs-runtime 1.6.0 → 1.7.0

package/src/Isolate/IsolateMutator.ts

@@ -1,165 +0,0 @@
-import {
-  Nullable,
-  invariant,
-  isNullish,
-  makeResult,
-  Result,
-  isFailure,
-} from 'vest-utils';
-
-import { RuntimeApi } from '../VestRuntime';
-
-import { IsolateStateMachine } from './IsolateStateMachine';
-import { IsolateStatus } from './IsolateStatus';
-import { IsolateInspector } from './IsolateInspector';
-
-import { TIsolate } from './Isolate';
-
-function bubbleUpPending(isolate: Nullable<TIsolate>): void {
-  if (isNullish(isolate)) {
-    return;
-  }
-  // If parent is already HAS_PENDING, we can stop the upward traversal.
-  if (IsolateInspector.isHasPending(isolate)) {
-    return;
-  }
-
-  const result = IsolateMutator.setHasPending(isolate);
-
-  if (isFailure(result)) {
-    return;
-  }
-
-  bubbleUpPending(isolate.parent);
-}
-
-function bubbleUpDone(isolate: Nullable<TIsolate>): void {
-  if (isNullish(isolate)) {
-    return;
-  }
-
-  if (!IsolateInspector.isHasPending(isolate)) {
-    return;
-  }
-
-  const result = IsolateMutator.setStatus(isolate, IsolateStatus.DONE, isolate);
-
-  if (isFailure(result)) {
-    return;
-  }
-
-  bubbleUpDone(isolate.parent);
-}
-
-export class IsolateMutator {
-  static setParent(isolate: TIsolate, parent: Nullable<TIsolate>): TIsolate {
-    isolate.parent = parent;
-    return isolate;
-  }
-
-  static saveOutput(isolate: TIsolate, output: any): TIsolate {
-    isolate.output = output;
-    return isolate;
-  }
-
-  static setKey(isolate: TIsolate, key: Nullable<string>): TIsolate {
-    isolate.key = key;
-    return isolate;
-  }
-
-  static addChild(isolate: TIsolate, child: TIsolate): void {
-    invariant(isolate);
-
-    isolate.children = isolate.children ?? [];
-
-    isolate.children.push(child);
-    IsolateMutator.setParent(child, isolate);
-
-    if (IsolateInspector.hasPending(child)) {
-      bubbleUpPending(isolate);
-    }
-  }
-
-  static removeChild(isolate: TIsolate, node: TIsolate): void {
-    isolate.children =
-      isolate.children?.filter(child => child !== node) ?? null;
-  }
-
-  static addChildKey(isolate: TIsolate, key: string, node: TIsolate): void {
-    invariant(isolate);
-
-    isolate.keys = isolate.keys ?? {};
-
-    isolate.keys[key] = node;
-  }
-
-  static slice(isolate: TIsolate, at: number): void {
-    if (isNullish(isolate.children)) {
-      return;
-    }
-    isolate.children.length = at;
-  }
-
-  static setData(isolate: TIsolate, data: any): void {
-    isolate.data = data;
-  }
-
-  static abort(isolate: TIsolate, reason?: string): void {
-    if (isNullish(isolate.abortController)) {
-      return;
-    }
-    isolate.abortController.abort(reason);
-  }
-
-  static setStatus(
-    isolate: TIsolate,
-    status: IsolateStatus,
-    payload?: any,
-  ): Result<IsolateStatus, string> {
-    if (isolate.status === status) {
-      return makeResult.Err(`Isolate status is already ${status}`);
-    }
-
-    isolate.status = IsolateStateMachine.staticTransition(
-      isolate.status ?? IsolateStatus.INITIAL,
-      status,
-      payload,
-    ) as IsolateStatus;
-
-    return makeResult.Ok(isolate.status);
-  }
-
-  static setPending(isolate: TIsolate): void {
-    const result = IsolateMutator.setStatus(isolate, IsolateStatus.PENDING);
-
-    if (isFailure(result)) {
-      return;
-    }
-
-    RuntimeApi.registerPending(isolate);
-
-    // Bubble up the HAS_PENDING status to all ancestors.
-    bubbleUpPending(isolate.parent);
-  }
-
-  static setHasPending(isolate: TIsolate): Result<IsolateStatus, string> {
-    return IsolateMutator.setStatus(isolate, IsolateStatus.HAS_PENDING);
-  }
-
-  static setDone(isolate: TIsolate): void {
-    const result = IsolateMutator.setStatus(
-      isolate,
-      IsolateStatus.DONE,
-      isolate,
-    );
-
-    if (isFailure(result)) {
-      return;
-    }
-
-    // Bubble up the DONE status to ancestors if no other children are pending.
-    bubbleUpDone(isolate.parent);
-
-    RuntimeApi.removePending(isolate);
-  }
-}

package/src/Isolate/IsolateRegistry.ts

@@ -1,176 +0,0 @@
-import { Nullable, isEmptySet, isNotEmptySet } from 'vest-utils';
-
-import { useAvailableRoot } from '../VestRuntime';
-import { TIsolate } from './Isolate';
-
-/**
- * A registry index, mapping group keys (like field names) to sets of isolates.
- */
-export type RegistryIndex = Map<string, Set<TIsolate>>;
-
-/**
- * Configuration for a registry category.
- */
-export type RegistryCategoryConfig = {
-  predicate: (isolate: TIsolate) => boolean;
-  getKey: (isolate: TIsolate) => string;
-};
-
-/**
- * Updates the registration of an isolate in all relevant indices based on provided predicates.
- *
- * @param isolate - The isolate node to update.
- * @param predicates - A record of category keys and their corresponding predicate configurations.
- */
-export function useUpdateRegistry(
-  isolate: TIsolate,
-  predicates: Record<string, RegistryCategoryConfig>,
-) {
-  const root = useGetAvailableRoot();
-
-  if (!root) return;
-
-  for (const key in predicates) {
-    useUpdateCategoryInRegistry(root, key, predicates[key], isolate);
-  }
-}
-
-/**
- * Retrieves isolates from the registry based on a category and an optional key.
- */
-export function useGetFromRegistry(
-  category: string,
-  key?: string,
-): Set<TIsolate> {
-  const root = useGetAvailableRoot();
-  if (!root) return new Set();
-
-  const index = useEnsureRegistryIndex(root, category);
-
-  if (key) {
-    return index.get(key) ?? new Set();
-  }
-
-  const allNodes = new Set<TIsolate>();
-  index.forEach(set => set.forEach(node => allNodes.add(node)));
-  return allNodes;
-}
-
-/**
- * Checks if the registry contains any isolates for a given category and optional key.
- */
-export function useHasFromRegistry(category: string, key?: string): boolean {
-  return isNotEmptySet(useGetFromRegistry(category, key));
-}
-
-/**
- * Removes all entries for a specific key from the registry.
- */
-export function useRemoveFieldFromRegistry(key: string): void {
-  const root = useGetAvailableRoot();
-
-  if (!root) return;
-
-  useForEachRegistryIndex(root, index => index.delete(key));
-}
-
-/**
- * Clears all registry entries from the root isolate.
- */
-export function useClearRegistry(root: TIsolate) {
-  useForEachRegistryIndex(root, index => index.clear());
-}
-
-// Internal Helpers
-
-const GENERIC_REGISTRY_KEY = '_generic';
-
-function useGetAvailableRoot(): TIsolate | undefined {
-  try {
-    return useAvailableRoot();
-  } catch {
-    return undefined;
-  }
-}
-
-function useUpdateCategoryInRegistry(
-  root: TIsolate,
-  category: string,
-  config: RegistryCategoryConfig,
-  isolate: TIsolate,
-) {
-  const isMatching = config.predicate(isolate);
-  const index = useEnsureRegistryIndex(root, category);
-  const key = config.getKey(isolate);
-
-  if (isMatching) {
-    useAddNodeToRegistryIndex(index, key, isolate);
-  } else {
-    useRemoveNodeFromRegistryIndex(index, key, isolate);
-  }
-}
-
-function useEnsureRegistryIndex(
-  root: TIsolate,
-  category: string,
-): RegistryIndex {
-  const registryKey = `registry_${category}`;
-
-  if (!root.data[registryKey]) {
-    useDefineEnumerable(root.data, registryKey, new Map());
-  }
-
-  return root.data[registryKey];
-}
-
-function useForEachRegistryIndex(
-  root: TIsolate,
-  callback: (index: RegistryIndex) => void,
-) {
-  for (const key in root.data) {
-    if (key.startsWith('registry_')) {
-      callback(root.data[key]);
-    }
-  }
-}
-
-function useAddNodeToRegistryIndex(
-  index: RegistryIndex,
-  key: Nullable<string>,
-  isolate: TIsolate,
-) {
-  const indexKey = key ?? GENERIC_REGISTRY_KEY;
-  let entry = index.get(indexKey);
-
-  if (!entry) {
-    entry = new Set();
-    index.set(indexKey, entry);
-  }
-
-  entry.add(isolate);
-}
-
-function useRemoveNodeFromRegistryIndex(
-  index: RegistryIndex,
-  key: Nullable<string>,
-  isolate: TIsolate,
-) {
-  const indexKey = key ?? GENERIC_REGISTRY_KEY;
-  const entry = index.get(indexKey);
-
-  if (entry) {
-    entry.delete(isolate);
-    if (isEmptySet(entry)) {
-      index.delete(indexKey);
-    }
-  }
-}
-
-function useDefineEnumerable(obj: any, key: string, value: any) {
-  Object.defineProperty(obj, key, {
-    configurable: true,
-    enumerable: true,
-    value,
-    writable: true,
-  });
-}

package/src/Isolate/IsolateReorderable.ts

@@ -1,11 +0,0 @@
-import { CB } from 'vest-utils';
-
-import { Isolate } from './Isolate';
-
-export function IsolateReorderable(
-  callback: CB,
-  type = 'Reorderable',
-  payload: Record<string, any> = {},
-) {
-  return Isolate.create(type, callback, { ...payload, allowReorder: true });
-}

package/src/Isolate/IsolateSelectors.ts

@@ -1,25 +0,0 @@
-import { Maybe } from 'vest-utils';
-
-import { TIsolate } from './Isolate';
-import { IsolateKeys } from './IsolateKeys';
-
-export function isIsolateType<I extends TIsolate>(
-  node: Maybe<TIsolate>,
-  type: string,
-): node is I {
-  return node?.[IsolateKeys.Type] === type;
-}
-
-export function isSameIsolateType<A extends TIsolate, B extends TIsolate>(
-  a: A,
-  b: B,
-): boolean {
-  return isIsolateType(a, b[IsolateKeys.Type]);
-}
-
-export function isSameIsolateIdentity<A extends TIsolate, B extends TIsolate>(
-  a: A,
-  b: B,
-): boolean {
-  return Object.is(a, b) || (isSameIsolateType(a, b) && a.key === b.key);
-}

package/src/Isolate/IsolateStateMachine.ts

@@ -1,30 +0,0 @@
-import { StateMachine, TStateMachine } from 'vest-utils';
-
-import { TIsolate } from './Isolate';
-import { IsolateInspector } from './IsolateInspector';
-
-import { IsolateStatus } from './IsolateStatus';
-
-const machine: TStateMachine<IsolateStatus> = {
-  initial: IsolateStatus.INITIAL,
-  states: {
-    [IsolateStatus.DONE]: {},
-    [IsolateStatus.INITIAL]: {
-      [IsolateStatus.PENDING]: IsolateStatus.PENDING,
-      [IsolateStatus.HAS_PENDING]: IsolateStatus.HAS_PENDING,
-      [IsolateStatus.DONE]: IsolateStatus.DONE,
-    },
-    [IsolateStatus.PENDING]: {
-      [IsolateStatus.DONE]: IsolateStatus.DONE,
-    },
-    [IsolateStatus.HAS_PENDING]: {
-      [IsolateStatus.DONE]: [
-        IsolateStatus.DONE,
-        (isolate: TIsolate) => !IsolateInspector.hasActiveChildren(isolate),
-      ],
-      [IsolateStatus.PENDING]: IsolateStatus.PENDING,
-    },
-  },
-};
-
-export const IsolateStateMachine = StateMachine(machine);

package/src/Isolate/IsolateStatus.ts

@@ -1,8 +0,0 @@
-export const IsolateStatus = {
-  DONE: 'DONE',
-  HAS_PENDING: 'HAS_PENDING',
-  INITIAL: 'INITIAL',
-  PENDING: 'PENDING',
-} as const;
-
-export type IsolateStatus = (typeof IsolateStatus)[keyof typeof IsolateStatus];

package/src/Isolate/IsolateTransient.ts

@@ -1,27 +0,0 @@
-import { CB } from 'vest-utils';
-
-import { Isolate } from './Isolate';
-import type { IsolatePayload, TIsolate } from './IsolateTypes';
-
-/**
- * Creates a transient isolate.
- *
- * Transient isolates are isolates that:
- * 1. Do not persist in the history tree.
- * 2. Are not reconciled with previous runs.
- * 3. Do not appear in the serialized suite dump.
- * 4. Do not interfere with the index of their siblings (they are skipped by the reconciler).
- *
- * This is useful for "structural" isolates that are used for control flow or grouping
- * but do not hold state that needs to be preserved between runs, such as `focused` (skip/only) isolates.
- */
-export function IsolateTransient<Payload extends IsolatePayload>(
-  callback: CB,
-  type = 'Transient',
-  payload: Payload = {} as Payload,
-): TIsolate<Payload> {
-  return Isolate.create<Payload>(type, callback, {
-    ...payload,
-    transient: true,
-  });
-}

package/src/Isolate/IsolateTypes.ts

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

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