vestjs-runtime 1.1.0 → 1.2.1

package/dist/es/IsolateSerializer.production.js.map

@@ -1 +1 @@
-{"version":3,"file":"IsolateSerializer.production.js","sources":["../../src/errors/ErrorStrings.ts","../../src/Isolate/IsolateKeys.ts","../../src/Isolate/IsolateMutator.ts","../../src/exports/IsolateSerializer.ts"],"sourcesContent":["export enum ErrorStrings {\n  NO_ACTIVE_ISOLATE = 'Not within an active isolate',\n  UNABLE_TO_PICK_NEXT_ISOLATE = 'Unable to pick next isolate. This is a bug, please report it to the Vest maintainers.',\n  ENCOUNTERED_THE_SAME_KEY_TWICE = `Encountered the same key \"{key}\" twice. This may lead to inconsistent or overriding of results.`,\n  INVALID_ISOLATE_CANNOT_PARSE = `Invalid isolate was passed to IsolateSerializer. Cannot proceed.`,\n}\n","export enum IsolateKeys {\n  Type = '$type',\n  Keys = 'keys',\n  Key = 'key',\n  Parent = 'parent',\n  Data = 'data',\n  AllowReorder = 'allowReorder',\n  Status = 'status',\n}\n\nenum MinifiedKeys {\n  Type = '$',\n  Keys = 'K',\n  Key = 'k',\n  Parent = 'P',\n  Data = 'D',\n  AllowReorder = 'aR',\n  Status = 'S',\n}\n\nexport const KeyToMinified = {\n  [IsolateKeys.Type]: MinifiedKeys.Type,\n  [IsolateKeys.Keys]: MinifiedKeys.Keys,\n  [IsolateKeys.Parent]: MinifiedKeys.Parent,\n  [IsolateKeys.Data]: MinifiedKeys.Data,\n  [IsolateKeys.Key]: MinifiedKeys.Key,\n  [IsolateKeys.AllowReorder]: MinifiedKeys.AllowReorder,\n  [IsolateKeys.Status]: MinifiedKeys.Status,\n};\n\n// This const is an object that looks like this:\n// {\n//   '$': '$type',\n//   'K': 'keys',\n//   'P': 'parent',\n//   ...\n// }\nexport const MinifiedToKey = Object.entries(KeyToMinified).reduce(\n  (acc, [key, minified]) =>\n    Object.assign(acc, {\n      [minified]: key,\n    }),\n  {} as Record<string, IsolateKeys>\n);\n","import { Nullable, invariant, isNullish } from 'vest-utils';\n\nimport { TIsolate } from 'Isolate';\n\nexport class IsolateMutator {\n  static setParent(isolate: TIsolate, parent: Nullable<TIsolate>): TIsolate {\n    isolate.parent = parent;\n    return isolate;\n  }\n\n  static saveOutput(isolate: TIsolate, output: any): TIsolate {\n    isolate.output = output;\n    return isolate;\n  }\n\n  static setKey(isolate: TIsolate, key: Nullable<string>): TIsolate {\n    isolate.key = key;\n    return isolate;\n  }\n\n  static addChild(isolate: TIsolate, child: TIsolate): void {\n    invariant(isolate);\n\n    isolate.children = isolate.children ?? [];\n\n    isolate.children.push(child);\n    IsolateMutator.setParent(child, isolate);\n  }\n\n  static removeChild(isolate: TIsolate, node: TIsolate): void {\n    isolate.children =\n      isolate.children?.filter(child => child !== node) ?? null;\n  }\n\n  static addChildKey(isolate: TIsolate, key: string, node: TIsolate): void {\n    invariant(isolate);\n\n    isolate.keys = isolate.keys ?? {};\n\n    isolate.keys[key] = node;\n  }\n\n  static slice(isolate: TIsolate, at: number): void {\n    if (isNullish(isolate.children)) {\n      return;\n    }\n    isolate.children.length = at;\n  }\n\n  static setData(isolate: TIsolate, data: any): void {\n    isolate.data = data;\n  }\n}\n","import { ErrorStrings } from 'ErrorStrings';\nimport {\n  Nullable,\n  hasOwnProperty,\n  invariant,\n  isNotNullish,\n  isNullish,\n  isStringValue,\n  text,\n} from 'vest-utils';\n\nimport { TIsolate } from 'Isolate';\nimport { IsolateKeys, KeyToMinified, MinifiedToKey } from 'IsolateKeys';\nimport { IsolateMutator } from 'IsolateMutator';\n\nexport class IsolateSerializer {\n  // eslint-disable-next-line max-statements, complexity\n  static deserialize(node: Record<string, any> | TIsolate | string): TIsolate {\n    // the  assumption is that the tree is built correctly,\n    // but the children are missing the parent property to\n    // avoid circular references during serialization.\n    // in the same way, the parents are missing the `keys` property\n    // to avoid circular references during serialization.\n    // we need to rebuild the tree and add back the parent property to the children\n    // and the keys property to the parents.\n\n    const root = isStringValue(node)\n      ? JSON.parse(node)\n      : ({ ...node } as TIsolate);\n\n    IsolateSerializer.validateIsolate(root);\n\n    const queue = [root];\n\n    while (queue.length) {\n      const current = queue.shift();\n\n      const children = IsolateSerializer.getChildren(current);\n\n      for (const key in MinifiedToKey) {\n        const value = current[key];\n        if (isNotNullish(value)) {\n          current[MinifiedToKey[key]] = value;\n          delete current[key];\n        }\n      }\n\n      if (!children) {\n        continue;\n      }\n\n      current.children = children.map(child => {\n        const nextChild = { ...child };\n\n        IsolateMutator.setParent(nextChild, current);\n        queue.push(nextChild);\n\n        const key = nextChild.key;\n\n        if (key) {\n          current.keys = current.keys ?? {};\n          current.keys[key] = nextChild;\n        }\n\n        return nextChild;\n      });\n    }\n\n    return root as TIsolate;\n  }\n\n  static serialize(isolate: Nullable<TIsolate>): string {\n    if (isNullish(isolate)) {\n      return '';\n    }\n\n    return JSON.stringify(transformIsolate(isolate));\n  }\n\n  static getChildren(node: TIsolate): Nullable<TIsolate[]> {\n    return node.children ? [...node.children] : null;\n  }\n\n  static validateIsolate(node: Record<string, any> | TIsolate): void {\n    invariant(\n      hasOwnProperty(node, IsolateKeys.Type) ||\n        hasOwnProperty(node, KeyToMinified[IsolateKeys.Type]),\n      text(ErrorStrings.INVALID_ISOLATE_CANNOT_PARSE)\n    );\n  }\n}\n\n// eslint-disable-next-line max-statements, complexity\nfunction transformIsolate(isolate: TIsolate): Record<string, any> {\n  const next: Record<string, any> = {};\n\n  if (isolate.children) {\n    next.children = isolate.children.map(transformIsolate);\n  }\n\n  for (const key in isolate) {\n    if (key === 'children') {\n      continue;\n    }\n\n    if (isKeyExcluededFromDump(key)) {\n      continue;\n    }\n    const value = isolate[key as keyof TIsolate];\n\n    if (isNullish(value)) {\n      continue;\n    }\n\n    if (hasOwnProperty(KeyToMinified, key)) {\n      next[KeyToMinified[key]] = value;\n    } else {\n      next[key] = value;\n    }\n  }\n\n  return next;\n}\n\nfunction isKeyExcluededFromDump(key: string): boolean {\n  return [IsolateKeys.Parent, IsolateKeys.Keys].includes(key as IsolateKeys);\n}\n"],"names":["ErrorStrings","IsolateKeys","MinifiedKeys","KeyToMinified","Type","Keys","Parent","Data","Key","AllowReorder","Status","MinifiedToKey","Object","entries","reduce","acc","key","minified","assign","IsolateMutator","static","isolate","parent","output","child","invariant","children","_a","push","setParent","node","_b","filter","keys","at","isNullish","length","data","IsolateSerializer","root","isStringValue","JSON","parse","validateIsolate","queue","current","shift","getChildren","value","isNotNullish","map","nextChild","stringify","transformIsolate","hasOwnProperty","text","INVALID_ISOLATE_CANNOT_PARSE","next","isKeyExcluededFromDump","includes"],"mappings":"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"}
+{"version":3,"file":"IsolateSerializer.production.js","sources":["../../src/errors/ErrorStrings.ts","../../src/Isolate/IsolateKeys.ts","../../src/Isolate/IsolateMutator.ts","../../src/exports/IsolateSerializer.ts"],"sourcesContent":["export enum ErrorStrings {\n  NO_ACTIVE_ISOLATE = 'Not within an active isolate',\n  UNABLE_TO_PICK_NEXT_ISOLATE = 'Unable to pick next isolate. This is a bug, please report it to the Vest maintainers.',\n  ENCOUNTERED_THE_SAME_KEY_TWICE = `Encountered the same key \"{key}\" twice. This may lead to inconsistent or overriding of results.`,\n  INVALID_ISOLATE_CANNOT_PARSE = `Invalid isolate was passed to IsolateSerializer. Cannot proceed.`,\n}\n","import { assign } from 'lodash';\n\nexport enum IsolateKeys {\n  Type = '$type',\n  Keys = 'keys',\n  Key = 'key',\n  Parent = 'parent',\n  Data = 'data',\n  AllowReorder = 'allowReorder',\n  Status = 'status',\n  AbortController = 'abortController',\n  Children = 'children',\n}\n\nexport enum MinifiedKeys {\n  Type = '$',\n  Keys = 'Ks',\n  Key = 'ky',\n  Parent = 'P',\n  Data = 'D',\n  AllowReorder = 'AR',\n  Status = 'S',\n  Children = 'C',\n}\n\nexport const KeyToMinified = {\n  [IsolateKeys.Type]: MinifiedKeys.Type,\n  [IsolateKeys.Keys]: MinifiedKeys.Keys,\n  [IsolateKeys.Parent]: MinifiedKeys.Parent,\n  [IsolateKeys.Data]: MinifiedKeys.Data,\n  [IsolateKeys.Key]: MinifiedKeys.Key,\n  [IsolateKeys.AllowReorder]: MinifiedKeys.AllowReorder,\n  [IsolateKeys.Status]: MinifiedKeys.Status,\n  [IsolateKeys.Children]: MinifiedKeys.Children,\n};\n\n// This const is an object that looks like this:\n// {\n//   '$': '$type',\n//   'K': 'keys',\n//   'P': 'parent',\n//   ...\n// }\nexport const MinifiedToKey = invertKeyMap(KeyToMinified);\n\nexport function invertKeyMap(miniMap: Record<string, string> = {}) {\n  return Object.entries(miniMap).reduce(\n    (acc, [key, minified]) =>\n      assign(acc, {\n        [minified]: key,\n      }),\n    {} as Record<string, string>\n  );\n}\n\nexport const ExcludedFromDump = [\n  IsolateKeys.AbortController,\n  IsolateKeys.Parent,\n  IsolateKeys.Keys,\n  IsolateKeys.Children,\n  IsolateKeys.Data,\n];\n","import { Nullable, invariant, isNullish } from 'vest-utils';\n\nimport { TIsolate } from 'Isolate';\n\nexport class IsolateMutator {\n  static setParent(isolate: TIsolate, parent: Nullable<TIsolate>): TIsolate {\n    isolate.parent = parent;\n    return isolate;\n  }\n\n  static saveOutput(isolate: TIsolate, output: any): TIsolate {\n    isolate.output = output;\n    return isolate;\n  }\n\n  static setKey(isolate: TIsolate, key: Nullable<string>): TIsolate {\n    isolate.key = key;\n    return isolate;\n  }\n\n  static addChild(isolate: TIsolate, child: TIsolate): void {\n    invariant(isolate);\n\n    isolate.children = isolate.children ?? [];\n\n    isolate.children.push(child);\n    IsolateMutator.setParent(child, isolate);\n  }\n\n  static removeChild(isolate: TIsolate, node: TIsolate): void {\n    isolate.children =\n      isolate.children?.filter(child => child !== node) ?? null;\n  }\n\n  static addChildKey(isolate: TIsolate, key: string, node: TIsolate): void {\n    invariant(isolate);\n\n    isolate.keys = isolate.keys ?? {};\n\n    isolate.keys[key] = node;\n  }\n\n  static slice(isolate: TIsolate, at: number): void {\n    if (isNullish(isolate.children)) {\n      return;\n    }\n    isolate.children.length = at;\n  }\n\n  static setData(isolate: TIsolate, data: any): void {\n    isolate.data = data;\n  }\n\n  static abort(isolate: TIsolate, reason?: string): void {\n    if (isNullish(isolate.abortController)) {\n      return;\n    }\n    isolate.abortController.abort(reason);\n  }\n}\n","import { ErrorStrings } from 'ErrorStrings';\nimport {\n  Maybe,\n  Nullable,\n  assign,\n  hasOwnProperty,\n  invariant,\n  isEmpty,\n  isNotNullish,\n  isNullish,\n  isStringValue,\n  text,\n} from 'vest-utils';\n\nimport { TIsolate } from 'Isolate';\nimport {\n  ExcludedFromDump,\n  IsolateKeys,\n  KeyToMinified,\n  MinifiedKeys,\n  MinifiedToKey,\n} from 'IsolateKeys';\nimport { IsolateMutator } from 'IsolateMutator';\n\nexport class IsolateSerializer {\n  // eslint-disable-next-line max-statements, complexity, max-lines-per-function\n  static deserialize(\n    node: Record<string, any> | TIsolate | string,\n    miniMaps: Maybe<MiniMaps>\n  ): TIsolate {\n    // the  assumption is that the tree is built correctly,\n    // but the children are missing the parent property to\n    // avoid circular references during serialization.\n    // in the same way, the parents are missing the `keys` property\n    // to avoid circular references during serialization.\n    // we need to rebuild the tree and add back the parent property to the children\n    // and the keys property to the parents.\n    const inverseMinimap = deeplyInvertKeyMap(miniMaps);\n\n    // Validate the root object\n    const root = isStringValue(node)\n      ? JSON.parse(node)\n      : ({ ...node } as TIsolate);\n\n    IsolateSerializer.validateIsolate(root);\n\n    const queue = [root];\n\n    // Iterate over the queue until it's empty\n    while (queue.length) {\n      // Get the next item from the queue\n      const current = queue.shift();\n\n      // Get the children of the current item\n      const children = IsolateSerializer.expandChildren(current);\n\n      // Iterate over the minified keys\n      for (const key in MinifiedToKey) {\n        // Get the value for the current key\n        const value = current[key];\n\n        // If the value is not null or undefined\n        if (isNotNullish(value)) {\n          // Get the key to use\n          const keyToUse = MinifiedToKey[key];\n\n          // If the key is data, then we may need to transform the keys\n          // eslint-disable-next-line max-depth\n          if (keyToUse === IsolateKeys.Data) {\n            // Transform the keys\n            current[keyToUse] = transformKeys(\n              value,\n              inverseMinimap?.keys?.data\n            );\n          } else {\n            // Otherwise, just set the key\n            current[keyToUse] = transformValueByKey(\n              keyToUse,\n              value,\n              inverseMinimap\n            );\n          }\n\n          // Remove the old key\n          delete current[key];\n        }\n      }\n\n      // If there are no children, nothing to do.\n      if (!children) {\n        continue;\n      }\n\n      // Copy the children and set their parent to the current node.\n      current.children = children.map(child => {\n        const nextChild = { ...child };\n\n        IsolateMutator.setParent(nextChild, current);\n        queue.push(nextChild);\n\n        // If the child has a key, add it to the parent's keys.\n        const key = nextChild.key;\n\n        if (key) {\n          current.keys = current.keys ?? {};\n          current.keys[key] = nextChild;\n        }\n\n        return nextChild;\n      });\n    }\n\n    return root as TIsolate;\n  }\n\n  static serialize(\n    isolate: Nullable<TIsolate>,\n    miniMaps: Maybe<MiniMaps>\n  ): string {\n    if (isNullish(isolate)) {\n      return '';\n    }\n\n    return JSON.stringify(transformIsolate(isolate, miniMaps));\n  }\n\n  static expandChildren(node: Record<string, any>): Nullable<TIsolate[]> {\n    return node[MinifiedKeys.Children]\n      ? [...node[MinifiedKeys.Children]]\n      : null;\n  }\n\n  static validateIsolate(node: Record<string, any> | TIsolate): void {\n    invariant(\n      hasOwnProperty(node, IsolateKeys.Type) ||\n        hasOwnProperty(node, KeyToMinified[IsolateKeys.Type]),\n      text(ErrorStrings.INVALID_ISOLATE_CANNOT_PARSE)\n    );\n  }\n}\n\n// eslint-disable-next-line max-statements, complexity\nfunction transformIsolate(\n  isolate: TIsolate,\n  miniMaps: Maybe<MiniMaps>\n): Record<string, any> {\n  const next: Record<string, any> = {};\n\n  if (isolate.children) {\n    next[MinifiedKeys.Children] = isolate.children.map(isolate =>\n      transformIsolate(isolate, miniMaps)\n    );\n  }\n\n  if (!isEmpty(isolate.data)) {\n    next[MinifiedKeys.Data] = transformKeys(isolate.data, miniMaps?.keys?.data);\n  }\n\n  for (const key in isolate) {\n    // Skip keys that should be excluded from the dump.\n    // While we're excluding children from the dump, they'll actually remain there\n    // due to the fact that we've already transformed them recursively beforehand\n    // thus renaming them to the minified key.\n    if (isKeyExcluededFromDump(key)) {\n      continue;\n    }\n    const value = isolate[key as keyof TIsolate];\n\n    if (isNullish(value)) {\n      continue;\n    }\n\n    const keyToUse = minifyKey(key);\n    next[keyToUse] = transformValueByKey(key, value, miniMaps);\n  }\n\n  return next;\n}\n\nfunction isKeyExcluededFromDump(key: string): boolean {\n  return ExcludedFromDump.includes(key as IsolateKeys);\n}\n\nfunction minifyKey(key: string): string {\n  return KeyToMinified[key as keyof typeof KeyToMinified] ?? key;\n}\n\nfunction transformValueByKey(\n  key: string,\n  value: any,\n  miniMaps: Maybe<MiniMaps>\n): any {\n  if (isNullish(value)) {\n    return value;\n  }\n\n  const keyMap = miniMaps?.values?.[key as keyof MiniMaps['values']];\n\n  return keyMap ? keyMap[value] ?? value : value;\n}\n\nfunction transformKeys(\n  data: Record<string, any>,\n  keyMap: Maybe<MiniMap>\n): Record<string, any> {\n  const next: Record<string, any> = {};\n\n  // Loop over each key in the data.\n  for (const key in data) {\n    // Find the key to use for the next object.\n    // If there is no key map, use the original key.\n    // If there is a key map, use the key map entry for the current key.\n    const keyToUse = (keyMap ? keyMap[key] : key) ?? key;\n\n    // Add the key and value to the next object.\n    next[keyToUse] = data[key];\n  }\n\n  // Return the next object.\n  return next;\n}\n\ntype MiniMap = Record<string, string>;\n\ntype MiniMaps = Partial<{\n  keys: Partial<{\n    [IsolateKeys.Data]: MiniMap;\n  }>;\n  values: Partial<{\n    [IsolateKeys.Status]: MiniMap;\n    [IsolateKeys.Type]: MiniMap;\n  }>;\n}>;\n\nexport function deeplyInvertKeyMap(miniMaps: Maybe<MiniMaps> = {}): MiniMaps {\n  return Object.entries(miniMaps).reduce((acc, [key, value]) => {\n    if (typeof value === 'object') {\n      return assign(acc, {\n        [key]: deeplyInvertKeyMap(value as MiniMaps),\n      });\n    }\n    return assign(acc, {\n      [value]: key,\n    });\n  }, {} as MiniMaps);\n}\n"],"names":["ErrorStrings","IsolateKeys","MinifiedKeys","KeyToMinified","Type","Keys","Parent","Data","Key","AllowReorder","Status","Children","MinifiedToKey","miniMap","Object","entries","reduce","acc","key","minified","assign","invertKeyMap","ExcludedFromDump","AbortController","IsolateMutator","static","isolate","parent","output","child","invariant","children","_a","push","setParent","node","_b","filter","keys","at","isNullish","length","data","reason","abortController","abort","IsolateSerializer","miniMaps","inverseMinimap","deeplyInvertKeyMap","root","isStringValue","JSON","parse","validateIsolate","queue","current","shift","expandChildren","value","isNotNullish","keyToUse","transformKeys","transformValueByKey","map","nextChild","stringify","transformIsolate","hasOwnProperty","text","INVALID_ISOLATE_CANNOT_PARSE","next","isEmpty","isKeyExcluededFromDump","minifyKey","includes","keyMap","values"],"mappings":"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"}

package/dist/es/test-utils.development.js

@@ -1,3 +1,5 @@
+import { assign } from 'lodash';
+
 /******************************************************************************
 Copyright (c) Microsoft Corporation.
 
@@ -41,16 +43,19 @@ var IsolateKeys;
     IsolateKeys["Data"] = "data";
     IsolateKeys["AllowReorder"] = "allowReorder";
     IsolateKeys["Status"] = "status";
+    IsolateKeys["AbortController"] = "abortController";
+    IsolateKeys["Children"] = "children";
 })(IsolateKeys || (IsolateKeys = {}));
 var MinifiedKeys;
 (function (MinifiedKeys) {
     MinifiedKeys["Type"] = "$";
-    MinifiedKeys["Keys"] = "K";
-    MinifiedKeys["Key"] = "k";
+    MinifiedKeys["Keys"] = "Ks";
+    MinifiedKeys["Key"] = "ky";
     MinifiedKeys["Parent"] = "P";
     MinifiedKeys["Data"] = "D";
-    MinifiedKeys["AllowReorder"] = "aR";
+    MinifiedKeys["AllowReorder"] = "AR";
     MinifiedKeys["Status"] = "S";
+    MinifiedKeys["Children"] = "C";
 })(MinifiedKeys || (MinifiedKeys = {}));
 const KeyToMinified = {
     [IsolateKeys.Type]: MinifiedKeys.Type,
@@ -60,6 +65,7 @@ const KeyToMinified = {
     [IsolateKeys.Key]: MinifiedKeys.Key,
     [IsolateKeys.AllowReorder]: MinifiedKeys.AllowReorder,
     [IsolateKeys.Status]: MinifiedKeys.Status,
+    [IsolateKeys.Children]: MinifiedKeys.Children,
 };
 // This const is an object that looks like this:
 // {
@@ -68,9 +74,19 @@ const KeyToMinified = {
 //   'P': 'parent',
 //   ...
 // }
-Object.entries(KeyToMinified).reduce((acc, [key, minified]) => Object.assign(acc, {
-    [minified]: key,
-}), {});
+invertKeyMap(KeyToMinified);
+function invertKeyMap(miniMap = {}) {
+    return Object.entries(miniMap).reduce((acc, [key, minified]) => assign(acc, {
+        [minified]: key,
+    }), {});
+}
+[
+    IsolateKeys.AbortController,
+    IsolateKeys.Parent,
+    IsolateKeys.Keys,
+    IsolateKeys.Children,
+    IsolateKeys.Data,
+];
 
 function genTestIsolate(payload = {}) {
     const { status } = payload, data = __rest(payload, ["status"]);

package/dist/es/test-utils.development.js.map

@@ -1 +1 @@
-{"version":3,"file":"test-utils.development.js","sources":["../../src/Isolate/IsolateKeys.ts","../../src/exports/test-utils.ts"],"sourcesContent":["export enum IsolateKeys {\n  Type = '$type',\n  Keys = 'keys',\n  Key = 'key',\n  Parent = 'parent',\n  Data = 'data',\n  AllowReorder = 'allowReorder',\n  Status = 'status',\n}\n\nenum MinifiedKeys {\n  Type = '$',\n  Keys = 'K',\n  Key = 'k',\n  Parent = 'P',\n  Data = 'D',\n  AllowReorder = 'aR',\n  Status = 'S',\n}\n\nexport const KeyToMinified = {\n  [IsolateKeys.Type]: MinifiedKeys.Type,\n  [IsolateKeys.Keys]: MinifiedKeys.Keys,\n  [IsolateKeys.Parent]: MinifiedKeys.Parent,\n  [IsolateKeys.Data]: MinifiedKeys.Data,\n  [IsolateKeys.Key]: MinifiedKeys.Key,\n  [IsolateKeys.AllowReorder]: MinifiedKeys.AllowReorder,\n  [IsolateKeys.Status]: MinifiedKeys.Status,\n};\n\n// This const is an object that looks like this:\n// {\n//   '$': '$type',\n//   'K': 'keys',\n//   'P': 'parent',\n//   ...\n// }\nexport const MinifiedToKey = Object.entries(KeyToMinified).reduce(\n  (acc, [key, minified]) =>\n    Object.assign(acc, {\n      [minified]: key,\n    }),\n  {} as Record<string, IsolateKeys>\n);\n","import { TIsolate } from 'Isolate';\nimport { IsolateKeys } from 'IsolateKeys';\n\nexport function genTestIsolate(payload: Record<string, any> = {}): TIsolate {\n  const { status, ...data } = payload;\n  return {\n    children: [],\n    data,\n    key: null,\n    keys: {},\n    output: null,\n    parent: null,\n    [IsolateKeys.Type]: 'UnitTest',\n    ...(status && { status }),\n  };\n}\n"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,IAAY,WAQX,CAAA;AARD,CAAA,UAAY,WAAW,EAAA;AACrB,IAAA,WAAA,CAAA,MAAA,CAAA,GAAA,OAAc,CAAA;AACd,IAAA,WAAA,CAAA,MAAA,CAAA,GAAA,MAAa,CAAA;AACb,IAAA,WAAA,CAAA,KAAA,CAAA,GAAA,KAAW,CAAA;AACX,IAAA,WAAA,CAAA,QAAA,CAAA,GAAA,QAAiB,CAAA;AACjB,IAAA,WAAA,CAAA,MAAA,CAAA,GAAA,MAAa,CAAA;AACb,IAAA,WAAA,CAAA,cAAA,CAAA,GAAA,cAA6B,CAAA;AAC7B,IAAA,WAAA,CAAA,QAAA,CAAA,GAAA,QAAiB,CAAA;AACnB,CAAC,EARW,WAAW,KAAX,WAAW,GAQtB,EAAA,CAAA,CAAA,CAAA;AAED,IAAK,YAQJ,CAAA;AARD,CAAA,UAAK,YAAY,EAAA;AACf,IAAA,YAAA,CAAA,MAAA,CAAA,GAAA,GAAU,CAAA;AACV,IAAA,YAAA,CAAA,MAAA,CAAA,GAAA,GAAU,CAAA;AACV,IAAA,YAAA,CAAA,KAAA,CAAA,GAAA,GAAS,CAAA;AACT,IAAA,YAAA,CAAA,QAAA,CAAA,GAAA,GAAY,CAAA;AACZ,IAAA,YAAA,CAAA,MAAA,CAAA,GAAA,GAAU,CAAA;AACV,IAAA,YAAA,CAAA,cAAA,CAAA,GAAA,IAAmB,CAAA;AACnB,IAAA,YAAA,CAAA,QAAA,CAAA,GAAA,GAAY,CAAA;AACd,CAAC,EARI,YAAY,KAAZ,YAAY,GAQhB,EAAA,CAAA,CAAA,CAAA;AAEM,MAAM,aAAa,GAAG;AAC3B,IAAA,CAAC,WAAW,CAAC,IAAI,GAAG,YAAY,CAAC,IAAI;AACrC,IAAA,CAAC,WAAW,CAAC,IAAI,GAAG,YAAY,CAAC,IAAI;AACrC,IAAA,CAAC,WAAW,CAAC,MAAM,GAAG,YAAY,CAAC,MAAM;AACzC,IAAA,CAAC,WAAW,CAAC,IAAI,GAAG,YAAY,CAAC,IAAI;AACrC,IAAA,CAAC,WAAW,CAAC,GAAG,GAAG,YAAY,CAAC,GAAG;AACnC,IAAA,CAAC,WAAW,CAAC,YAAY,GAAG,YAAY,CAAC,YAAY;AACrD,IAAA,CAAC,WAAW,CAAC,MAAM,GAAG,YAAY,CAAC,MAAM;CAC1C,CAAC;AAEF;AACA;AACA;AACA;AACA;AACA;AACA;AAC6B,MAAM,CAAC,OAAO,CAAC,aAAa,CAAC,CAAC,MAAM,CAC/D,CAAC,GAAG,EAAE,CAAC,GAAG,EAAE,QAAQ,CAAC,KACnB,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE;IACjB,CAAC,QAAQ,GAAG,GAAG;CAChB,CAAC,EACJ,EAAiC;;ACvCnB,SAAA,cAAc,CAAC,OAAA,GAA+B,EAAE,EAAA;IAC9D,MAAM,EAAE,MAAM,EAAA,GAAc,OAAO,EAAhB,IAAI,GAAA,MAAA,CAAK,OAAO,EAA7B,CAAmB,QAAA,CAAA,CAAU,CAAC;AACpC,IAAA,OAAA,MAAA,CAAA,MAAA,CAAA,EACE,QAAQ,EAAE,EAAE,EACZ,IAAI,EACJ,GAAG,EAAE,IAAI,EACT,IAAI,EAAE,EAAE,EACR,MAAM,EAAE,IAAI,EACZ,MAAM,EAAE,IAAI,EACZ,CAAC,WAAW,CAAC,IAAI,GAAG,UAAU,EAAA,GAC1B,MAAM,IAAI,EAAE,MAAM,EAAE,EACxB,CAAA;AACJ;;;;"}
+{"version":3,"file":"test-utils.development.js","sources":["../../src/Isolate/IsolateKeys.ts","../../src/exports/test-utils.ts"],"sourcesContent":["import { assign } from 'lodash';\n\nexport enum IsolateKeys {\n  Type = '$type',\n  Keys = 'keys',\n  Key = 'key',\n  Parent = 'parent',\n  Data = 'data',\n  AllowReorder = 'allowReorder',\n  Status = 'status',\n  AbortController = 'abortController',\n  Children = 'children',\n}\n\nexport enum MinifiedKeys {\n  Type = '$',\n  Keys = 'Ks',\n  Key = 'ky',\n  Parent = 'P',\n  Data = 'D',\n  AllowReorder = 'AR',\n  Status = 'S',\n  Children = 'C',\n}\n\nexport const KeyToMinified = {\n  [IsolateKeys.Type]: MinifiedKeys.Type,\n  [IsolateKeys.Keys]: MinifiedKeys.Keys,\n  [IsolateKeys.Parent]: MinifiedKeys.Parent,\n  [IsolateKeys.Data]: MinifiedKeys.Data,\n  [IsolateKeys.Key]: MinifiedKeys.Key,\n  [IsolateKeys.AllowReorder]: MinifiedKeys.AllowReorder,\n  [IsolateKeys.Status]: MinifiedKeys.Status,\n  [IsolateKeys.Children]: MinifiedKeys.Children,\n};\n\n// This const is an object that looks like this:\n// {\n//   '$': '$type',\n//   'K': 'keys',\n//   'P': 'parent',\n//   ...\n// }\nexport const MinifiedToKey = invertKeyMap(KeyToMinified);\n\nexport function invertKeyMap(miniMap: Record<string, string> = {}) {\n  return Object.entries(miniMap).reduce(\n    (acc, [key, minified]) =>\n      assign(acc, {\n        [minified]: key,\n      }),\n    {} as Record<string, string>\n  );\n}\n\nexport const ExcludedFromDump = [\n  IsolateKeys.AbortController,\n  IsolateKeys.Parent,\n  IsolateKeys.Keys,\n  IsolateKeys.Children,\n  IsolateKeys.Data,\n];\n","import { TIsolate } from 'Isolate';\nimport { IsolateKeys } from 'IsolateKeys';\n\nexport function genTestIsolate(payload: Record<string, any> = {}): TIsolate {\n  const { status, ...data } = payload;\n  return {\n    children: [],\n    data,\n    key: null,\n    keys: {},\n    output: null,\n    parent: null,\n    [IsolateKeys.Type]: 'UnitTest',\n    ...(status && { status }),\n  };\n}\n"],"names":[],"mappings":"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"}

package/dist/es/test-utils.production.js

@@ -1,2 +1,2 @@
-var e,t;"function"==typeof SuppressedError&&SuppressedError,function(e){e.Type="$type",e.Keys="keys",e.Key="key",e.Parent="parent",e.Data="data",e.AllowReorder="allowReorder",e.Status="status"}(e||(e={})),function(e){e.Type="$",e.Keys="K",e.Key="k",e.Parent="P",e.Data="D",e.AllowReorder="aR",e.Status="S"}(t||(t={}));const r={[e.Type]:t.Type,[e.Keys]:t.Keys,[e.Parent]:t.Parent,[e.Data]:t.Data,[e.Key]:t.Key,[e.AllowReorder]:t.AllowReorder,[e.Status]:t.Status};function n(t={}){const{status:r}=t,n=function(e,t){var r={};for(var n in e)Object.prototype.hasOwnProperty.call(e,n)&&t.indexOf(n)<0&&(r[n]=e[n]);if(null!=e&&"function"==typeof Object.getOwnPropertySymbols){var a=0;for(n=Object.getOwnPropertySymbols(e);a<n.length;a++)t.indexOf(n[a])<0&&Object.prototype.propertyIsEnumerable.call(e,n[a])&&(r[n[a]]=e[n[a]])}return r}(t,["status"]);return Object.assign({children:[],data:n,key:null,keys:{},output:null,parent:null,[e.Type]:"UnitTest"},r&&{status:r})}Object.entries(r).reduce(((e,[t,r])=>Object.assign(e,{[r]:t})),{});export{n as genTestIsolate};
+import{assign as e}from"lodash";var t,r;"function"==typeof SuppressedError&&SuppressedError,function(e){e.Type="$type",e.Keys="keys",e.Key="key",e.Parent="parent",e.Data="data",e.AllowReorder="allowReorder",e.Status="status",e.AbortController="abortController",e.Children="children"}(t||(t={})),function(e){e.Type="$",e.Keys="Ks",e.Key="ky",e.Parent="P",e.Data="D",e.AllowReorder="AR",e.Status="S",e.Children="C"}(r||(r={}));function n(e={}){const{status:r}=e,n=function(e,t){var r={};for(var n in e)Object.prototype.hasOwnProperty.call(e,n)&&t.indexOf(n)<0&&(r[n]=e[n]);if(null!=e&&"function"==typeof Object.getOwnPropertySymbols){var o=0;for(n=Object.getOwnPropertySymbols(e);o<n.length;o++)t.indexOf(n[o])<0&&Object.prototype.propertyIsEnumerable.call(e,n[o])&&(r[n[o]]=e[n[o]])}return r}(e,["status"]);return Object.assign({children:[],data:n,key:null,keys:{},output:null,parent:null,[t.Type]:"UnitTest"},r&&{status:r})}!function(t={}){Object.entries(t).reduce(((t,[r,n])=>e(t,{[n]:r})),{})}({[t.Type]:r.Type,[t.Keys]:r.Keys,[t.Parent]:r.Parent,[t.Data]:r.Data,[t.Key]:r.Key,[t.AllowReorder]:r.AllowReorder,[t.Status]:r.Status,[t.Children]:r.Children}),t.AbortController,t.Parent,t.Keys,t.Children,t.Data;export{n as genTestIsolate};
 //# sourceMappingURL=test-utils.production.js.map

package/dist/es/test-utils.production.js.map

@@ -1 +1 @@
-{"version":3,"file":"test-utils.production.js","sources":["../../src/Isolate/IsolateKeys.ts","../../src/exports/test-utils.ts"],"sourcesContent":["export enum IsolateKeys {\n  Type = '$type',\n  Keys = 'keys',\n  Key = 'key',\n  Parent = 'parent',\n  Data = 'data',\n  AllowReorder = 'allowReorder',\n  Status = 'status',\n}\n\nenum MinifiedKeys {\n  Type = '$',\n  Keys = 'K',\n  Key = 'k',\n  Parent = 'P',\n  Data = 'D',\n  AllowReorder = 'aR',\n  Status = 'S',\n}\n\nexport const KeyToMinified = {\n  [IsolateKeys.Type]: MinifiedKeys.Type,\n  [IsolateKeys.Keys]: MinifiedKeys.Keys,\n  [IsolateKeys.Parent]: MinifiedKeys.Parent,\n  [IsolateKeys.Data]: MinifiedKeys.Data,\n  [IsolateKeys.Key]: MinifiedKeys.Key,\n  [IsolateKeys.AllowReorder]: MinifiedKeys.AllowReorder,\n  [IsolateKeys.Status]: MinifiedKeys.Status,\n};\n\n// This const is an object that looks like this:\n// {\n//   '$': '$type',\n//   'K': 'keys',\n//   'P': 'parent',\n//   ...\n// }\nexport const MinifiedToKey = Object.entries(KeyToMinified).reduce(\n  (acc, [key, minified]) =>\n    Object.assign(acc, {\n      [minified]: key,\n    }),\n  {} as Record<string, IsolateKeys>\n);\n","import { TIsolate } from 'Isolate';\nimport { IsolateKeys } from 'IsolateKeys';\n\nexport function genTestIsolate(payload: Record<string, any> = {}): TIsolate {\n  const { status, ...data } = payload;\n  return {\n    children: [],\n    data,\n    key: null,\n    keys: {},\n    output: null,\n    parent: null,\n    [IsolateKeys.Type]: 'UnitTest',\n    ...(status && { status }),\n  };\n}\n"],"names":["IsolateKeys","MinifiedKeys","KeyToMinified","Type","Keys","Parent","Data","Key","AllowReorder","Status","genTestIsolate","payload","status","data","__rest","Object","assign","children","key","keys","output","parent","entries","reduce","acc","minified"],"mappings":"AAAA,IAAYA,EAUPC,sDAVL,SAAYD,GACVA,EAAA,KAAA,QACAA,EAAA,KAAA,OACAA,EAAA,IAAA,MACAA,EAAA,OAAA,SACAA,EAAA,KAAA,OACAA,EAAA,aAAA,eACAA,EAAA,OAAA,QACD,CARD,CAAYA,IAAAA,EAQX,CAAA,IAED,SAAKC,GACHA,EAAA,KAAA,IACAA,EAAA,KAAA,IACAA,EAAA,IAAA,IACAA,EAAA,OAAA,IACAA,EAAA,KAAA,IACAA,EAAA,aAAA,KACAA,EAAA,OAAA,GACD,CARD,CAAKA,IAAAA,EAQJ,CAAA,IAEM,MAAMC,EAAgB,CAC3B,CAACF,EAAYG,MAAOF,EAAaE,KACjC,CAACH,EAAYI,MAAOH,EAAaG,KACjC,CAACJ,EAAYK,QAASJ,EAAaI,OACnC,CAACL,EAAYM,MAAOL,EAAaK,KACjC,CAACN,EAAYO,KAAMN,EAAaM,IAChC,CAACP,EAAYQ,cAAeP,EAAaO,aACzC,CAACR,EAAYS,QAASR,EAAaQ,QCxBrB,SAAAC,EAAeC,EAA+B,IAC5D,MAAMC,OAAEA,GAAoBD,EAATE,2UAAIC,CAAKH,EAAtB,CAAmB,WACzB,OAAAI,OAAAC,OAAA,CACEC,SAAU,GACVJ,OACAK,IAAK,KACLC,KAAM,GACNC,OAAQ,KACRC,OAAQ,KACR,CAACrB,EAAYG,MAAO,YAChBS,GAAU,CAAEA,UAEpB,CDsB6BG,OAAOO,QAAQpB,GAAeqB,QACzD,CAACC,GAAMN,EAAKO,KACVV,OAAOC,OAAOQ,EAAK,CACjBC,CAACA,GAAWP,KAEhB,CAAiC"}
+{"version":3,"file":"test-utils.production.js","sources":["../../src/Isolate/IsolateKeys.ts","../../src/exports/test-utils.ts"],"sourcesContent":["import { assign } from 'lodash';\n\nexport enum IsolateKeys {\n  Type = '$type',\n  Keys = 'keys',\n  Key = 'key',\n  Parent = 'parent',\n  Data = 'data',\n  AllowReorder = 'allowReorder',\n  Status = 'status',\n  AbortController = 'abortController',\n  Children = 'children',\n}\n\nexport enum MinifiedKeys {\n  Type = '$',\n  Keys = 'Ks',\n  Key = 'ky',\n  Parent = 'P',\n  Data = 'D',\n  AllowReorder = 'AR',\n  Status = 'S',\n  Children = 'C',\n}\n\nexport const KeyToMinified = {\n  [IsolateKeys.Type]: MinifiedKeys.Type,\n  [IsolateKeys.Keys]: MinifiedKeys.Keys,\n  [IsolateKeys.Parent]: MinifiedKeys.Parent,\n  [IsolateKeys.Data]: MinifiedKeys.Data,\n  [IsolateKeys.Key]: MinifiedKeys.Key,\n  [IsolateKeys.AllowReorder]: MinifiedKeys.AllowReorder,\n  [IsolateKeys.Status]: MinifiedKeys.Status,\n  [IsolateKeys.Children]: MinifiedKeys.Children,\n};\n\n// This const is an object that looks like this:\n// {\n//   '$': '$type',\n//   'K': 'keys',\n//   'P': 'parent',\n//   ...\n// }\nexport const MinifiedToKey = invertKeyMap(KeyToMinified);\n\nexport function invertKeyMap(miniMap: Record<string, string> = {}) {\n  return Object.entries(miniMap).reduce(\n    (acc, [key, minified]) =>\n      assign(acc, {\n        [minified]: key,\n      }),\n    {} as Record<string, string>\n  );\n}\n\nexport const ExcludedFromDump = [\n  IsolateKeys.AbortController,\n  IsolateKeys.Parent,\n  IsolateKeys.Keys,\n  IsolateKeys.Children,\n  IsolateKeys.Data,\n];\n","import { TIsolate } from 'Isolate';\nimport { IsolateKeys } from 'IsolateKeys';\n\nexport function genTestIsolate(payload: Record<string, any> = {}): TIsolate {\n  const { status, ...data } = payload;\n  return {\n    children: [],\n    data,\n    key: null,\n    keys: {},\n    output: null,\n    parent: null,\n    [IsolateKeys.Type]: 'UnitTest',\n    ...(status && { status }),\n  };\n}\n"],"names":["IsolateKeys","MinifiedKeys","genTestIsolate","payload","status","data","__rest","Object","assign","children","key","keys","output","parent","Type","miniMap","entries","reduce","acc","minified","invertKeyMap","Keys","Parent","Data","Key","AllowReorder","Status","Children","AbortController"],"mappings":"gCAEA,IAAYA,EAYAC,sDAZZ,SAAYD,GACVA,EAAA,KAAA,QACAA,EAAA,KAAA,OACAA,EAAA,IAAA,MACAA,EAAA,OAAA,SACAA,EAAA,KAAA,OACAA,EAAA,aAAA,eACAA,EAAA,OAAA,SACAA,EAAA,gBAAA,kBACAA,EAAA,SAAA,UACD,CAVD,CAAYA,IAAAA,EAUX,CAAA,IAED,SAAYC,GACVA,EAAA,KAAA,IACAA,EAAA,KAAA,KACAA,EAAA,IAAA,KACAA,EAAA,OAAA,IACAA,EAAA,KAAA,IACAA,EAAA,aAAA,KACAA,EAAA,OAAA,IACAA,EAAA,SAAA,GACD,CATD,CAAYA,IAAAA,EASX,CAAA,ICpBe,SAAAC,EAAeC,EAA+B,IAC5D,MAAMC,OAAEA,GAAoBD,EAATE,2UAAIC,CAAKH,EAAtB,CAAmB,WACzB,OAAAI,OAAAC,OAAA,CACEC,SAAU,GACVJ,OACAK,IAAK,KACLC,KAAM,GACNC,OAAQ,KACRC,OAAQ,KACR,CAACb,EAAYc,MAAO,YAChBV,GAAU,CAAEA,UAEpB,ED8BgB,SAAaW,EAAkC,IACtDR,OAAOS,QAAQD,GAASE,QAC7B,CAACC,GAAMR,EAAKS,KACVX,EAAOU,EAAK,CACVC,CAACA,GAAWT,KAEhB,CAA4B,EAEhC,CAV6BU,CAlBA,CAC3B,CAACpB,EAAYc,MAAOb,EAAaa,KACjC,CAACd,EAAYqB,MAAOpB,EAAaoB,KACjC,CAACrB,EAAYsB,QAASrB,EAAaqB,OACnC,CAACtB,EAAYuB,MAAOtB,EAAasB,KACjC,CAACvB,EAAYwB,KAAMvB,EAAauB,IAChC,CAACxB,EAAYyB,cAAexB,EAAawB,aACzC,CAACzB,EAAY0B,QAASzB,EAAayB,OACnC,CAAC1B,EAAY2B,UAAW1B,EAAa0B,WAuBrC3B,EAAY4B,gBACZ5B,EAAYsB,OACZtB,EAAYqB,KACZrB,EAAY2B,SACZ3B,EAAYuB"}

package/dist/es/vestjs-runtime.development.js

@@ -1,5 +1,6 @@
-import { isNullish, isNotNullish, invariant, assign, bus, optionalFunctionValue, tinyState, deferThrow, text, isPromise, isStringValue, hasOwnProperty } from 'vest-utils';
+import { isNullish, isNotNullish, invariant, assign, bus, optionalFunctionValue, tinyState, deferThrow, text, isPromise, isStringValue, hasOwnProperty, isEmpty } from 'vest-utils';
 import { createCascade } from 'context';
+import { assign as assign$1 } from 'lodash';
 
 const RuntimeEvents = {
     ISOLATE_ENTER: 'ISOLATE_ENTER',
@@ -128,6 +129,12 @@ class IsolateMutator {
     static setData(isolate, data) {
         isolate.data = data;
     }
+    static abort(isolate, reason) {
+        if (isNullish(isolate.abortController)) {
+            return;
+        }
+        isolate.abortController.abort(reason);
+    }
 }
 
 const PersistedContext = createCascade((stateRef, parentContext) => {
@@ -306,16 +313,19 @@ var IsolateKeys;
     IsolateKeys["Data"] = "data";
     IsolateKeys["AllowReorder"] = "allowReorder";
     IsolateKeys["Status"] = "status";
+    IsolateKeys["AbortController"] = "abortController";
+    IsolateKeys["Children"] = "children";
 })(IsolateKeys || (IsolateKeys = {}));
 var MinifiedKeys;
 (function (MinifiedKeys) {
     MinifiedKeys["Type"] = "$";
-    MinifiedKeys["Keys"] = "K";
-    MinifiedKeys["Key"] = "k";
+    MinifiedKeys["Keys"] = "Ks";
+    MinifiedKeys["Key"] = "ky";
     MinifiedKeys["Parent"] = "P";
     MinifiedKeys["Data"] = "D";
-    MinifiedKeys["AllowReorder"] = "aR";
+    MinifiedKeys["AllowReorder"] = "AR";
     MinifiedKeys["Status"] = "S";
+    MinifiedKeys["Children"] = "C";
 })(MinifiedKeys || (MinifiedKeys = {}));
 const KeyToMinified = {
     [IsolateKeys.Type]: MinifiedKeys.Type,
@@ -325,6 +335,7 @@ const KeyToMinified = {
     [IsolateKeys.Key]: MinifiedKeys.Key,
     [IsolateKeys.AllowReorder]: MinifiedKeys.AllowReorder,
     [IsolateKeys.Status]: MinifiedKeys.Status,
+    [IsolateKeys.Children]: MinifiedKeys.Children,
 };
 // This const is an object that looks like this:
 // {
@@ -333,9 +344,19 @@ const KeyToMinified = {
 //   'P': 'parent',
 //   ...
 // }
-const MinifiedToKey = Object.entries(KeyToMinified).reduce((acc, [key, minified]) => Object.assign(acc, {
-    [minified]: key,
-}), {});
+const MinifiedToKey = invertKeyMap(KeyToMinified);
+function invertKeyMap(miniMap = {}) {
+    return Object.entries(miniMap).reduce((acc, [key, minified]) => assign$1(acc, {
+        [minified]: key,
+    }), {});
+}
+const ExcludedFromDump = [
+    IsolateKeys.AbortController,
+    IsolateKeys.Parent,
+    IsolateKeys.Keys,
+    IsolateKeys.Children,
+    IsolateKeys.Data,
+];
 
 function isIsolateType(node, type) {
     return (node === null || node === void 0 ? void 0 : node[IsolateKeys.Type]) === type;
@@ -477,7 +498,7 @@ function useRunAsNew(localHistoryNode, current, callback) {
 }
 function baseIsolate(type, payload = undefined, key = null) {
     const _a = payload !== null && payload !== void 0 ? payload : {}, { allowReorder, status } = _a, data = __rest(_a, ["allowReorder", "status"]);
-    return Object.assign(Object.assign({ [IsolateKeys.AllowReorder]: allowReorder, [IsolateKeys.Keys]: null, [IsolateKeys.Parent]: null, [IsolateKeys.Type]: type, [IsolateKeys.Data]: data }, (status && { [IsolateKeys.Status]: status })), { children: null, key, output: null });
+    return Object.assign(Object.assign({ [IsolateKeys.AllowReorder]: allowReorder, [IsolateKeys.AbortController]: new AbortController(), [IsolateKeys.Keys]: null, [IsolateKeys.Parent]: null, [IsolateKeys.Type]: type, [IsolateKeys.Data]: data }, (status && { [IsolateKeys.Status]: status })), { children: null, key, output: null });
 }
 
 // eslint-disable-next-line
@@ -612,8 +633,9 @@ var IsolateWalker = /*#__PURE__*/Object.freeze({
 });
 
 class IsolateSerializer {
-    // eslint-disable-next-line max-statements, complexity
-    static deserialize(node) {
+    // eslint-disable-next-line max-statements, complexity, max-lines-per-function
+    static deserialize(node, miniMaps) {
+        var _a;
         // the  assumption is that the tree is built correctly,
         // but the children are missing the parent property to
         // avoid circular references during serialization.
@@ -621,29 +643,52 @@ class IsolateSerializer {
         // to avoid circular references during serialization.
         // we need to rebuild the tree and add back the parent property to the children
         // and the keys property to the parents.
+        const inverseMinimap = deeplyInvertKeyMap(miniMaps);
+        // Validate the root object
         const root = isStringValue(node)
             ? JSON.parse(node)
             : Object.assign({}, node);
         IsolateSerializer.validateIsolate(root);
         const queue = [root];
+        // Iterate over the queue until it's empty
         while (queue.length) {
+            // Get the next item from the queue
             const current = queue.shift();
-            const children = IsolateSerializer.getChildren(current);
+            // Get the children of the current item
+            const children = IsolateSerializer.expandChildren(current);
+            // Iterate over the minified keys
             for (const key in MinifiedToKey) {
+                // Get the value for the current key
                 const value = current[key];
+                // If the value is not null or undefined
                 if (isNotNullish(value)) {
-                    current[MinifiedToKey[key]] = value;
+                    // Get the key to use
+                    const keyToUse = MinifiedToKey[key];
+                    // If the key is data, then we may need to transform the keys
+                    // eslint-disable-next-line max-depth
+                    if (keyToUse === IsolateKeys.Data) {
+                        // Transform the keys
+                        current[keyToUse] = transformKeys(value, (_a = inverseMinimap === null || inverseMinimap === void 0 ? void 0 : inverseMinimap.keys) === null || _a === void 0 ? void 0 : _a.data);
+                    }
+                    else {
+                        // Otherwise, just set the key
+                        current[keyToUse] = transformValueByKey(keyToUse, value, inverseMinimap);
+                    }
+                    // Remove the old key
                     delete current[key];
                 }
             }
+            // If there are no children, nothing to do.
             if (!children) {
                 continue;
             }
+            // Copy the children and set their parent to the current node.
             current.children = children.map(child => {
                 var _a;
                 const nextChild = Object.assign({}, child);
                 IsolateMutator.setParent(nextChild, current);
                 queue.push(nextChild);
+                // If the child has a key, add it to the parent's keys.
                 const key = nextChild.key;
                 if (key) {
                     current.keys = (_a = current.keys) !== null && _a !== void 0 ? _a : {};
@@ -654,14 +699,16 @@ class IsolateSerializer {
         }
         return root;
     }
-    static serialize(isolate) {
+    static serialize(isolate, miniMaps) {
         if (isNullish(isolate)) {
             return '';
         }
-        return JSON.stringify(transformIsolate(isolate));
+        return JSON.stringify(transformIsolate(isolate, miniMaps));
     }
-    static getChildren(node) {
-        return node.children ? [...node.children] : null;
+    static expandChildren(node) {
+        return node[MinifiedKeys.Children]
+            ? [...node[MinifiedKeys.Children]]
+            : null;
     }
     static validateIsolate(node) {
         invariant(hasOwnProperty(node, IsolateKeys.Type) ||
@@ -669,15 +716,20 @@ class IsolateSerializer {
     }
 }
 // eslint-disable-next-line max-statements, complexity
-function transformIsolate(isolate) {
+function transformIsolate(isolate, miniMaps) {
+    var _a;
     const next = {};
     if (isolate.children) {
-        next.children = isolate.children.map(transformIsolate);
+        next[MinifiedKeys.Children] = isolate.children.map(isolate => transformIsolate(isolate, miniMaps));
+    }
+    if (!isEmpty(isolate.data)) {
+        next[MinifiedKeys.Data] = transformKeys(isolate.data, (_a = miniMaps === null || miniMaps === void 0 ? void 0 : miniMaps.keys) === null || _a === void 0 ? void 0 : _a.data);
     }
     for (const key in isolate) {
-        if (key === 'children') {
-            continue;
-        }
+        // Skip keys that should be excluded from the dump.
+        // While we're excluding children from the dump, they'll actually remain there
+        // due to the fact that we've already transformed them recursively beforehand
+        // thus renaming them to the minified key.
         if (isKeyExcluededFromDump(key)) {
             continue;
         }
@@ -685,17 +737,52 @@ function transformIsolate(isolate) {
         if (isNullish(value)) {
             continue;
         }
-        if (hasOwnProperty(KeyToMinified, key)) {
-            next[KeyToMinified[key]] = value;
-        }
-        else {
-            next[key] = value;
-        }
+        const keyToUse = minifyKey(key);
+        next[keyToUse] = transformValueByKey(key, value, miniMaps);
     }
     return next;
 }
 function isKeyExcluededFromDump(key) {
-    return [IsolateKeys.Parent, IsolateKeys.Keys].includes(key);
+    return ExcludedFromDump.includes(key);
+}
+function minifyKey(key) {
+    var _a;
+    return (_a = KeyToMinified[key]) !== null && _a !== void 0 ? _a : key;
+}
+function transformValueByKey(key, value, miniMaps) {
+    var _a, _b;
+    if (isNullish(value)) {
+        return value;
+    }
+    const keyMap = (_a = miniMaps === null || miniMaps === void 0 ? void 0 : miniMaps.values) === null || _a === void 0 ? void 0 : _a[key];
+    return keyMap ? (_b = keyMap[value]) !== null && _b !== void 0 ? _b : value : value;
+}
+function transformKeys(data, keyMap) {
+    var _a;
+    const next = {};
+    // Loop over each key in the data.
+    for (const key in data) {
+        // Find the key to use for the next object.
+        // If there is no key map, use the original key.
+        // If there is a key map, use the key map entry for the current key.
+        const keyToUse = (_a = (keyMap ? keyMap[key] : key)) !== null && _a !== void 0 ? _a : key;
+        // Add the key and value to the next object.
+        next[keyToUse] = data[key];
+    }
+    // Return the next object.
+    return next;
+}
+function deeplyInvertKeyMap(miniMaps = {}) {
+    return Object.entries(miniMaps).reduce((acc, [key, value]) => {
+        if (typeof value === 'object') {
+            return assign(acc, {
+                [key]: deeplyInvertKeyMap(value),
+            });
+        }
+        return assign(acc, {
+            [value]: key,
+        });
+    }, {});
 }
 
 export { Bus, Isolate, IsolateInspector, IsolateMutator, IsolateSelectors, IsolateSerializer, Reconciler, RuntimeEvents, RuntimeApi as VestRuntime, IsolateWalker as Walker };