@jbrowse/mobx-state-tree 5.7.1 → 5.8.7

package/esm/core/mst-operations.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"mst-operations.js","sourceRoot":"","sources":["../../src/core/mst-operations.ts"],"names":[],"mappings":"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","sourcesContent":["import { isComputedProp, isObservableProp } from \"mobx\"\n\nimport {\n  EMPTY_OBJECT,\n  InvalidReferenceError,\n  asArray,\n  assertArg,\n  assertIsFunction,\n  assertIsNumber,\n  assertIsStateTreeNode,\n  assertIsString,\n  assertIsType,\n  assertIsValidIdentifier,\n  fail,\n  freeze,\n  getRelativePathBetweenNodes,\n  getRunningActionContext,\n  getStateTreeNode,\n  isModelType,\n  isStateTreeNode,\n  normalizeIdentifier,\n  resolveNodeByPath,\n  splitJsonPath\n} from \"../internal.ts\"\n\nimport type {\n  AnyObjectNode,\n  IActionContext,\n  IAnyComplexType,\n  IAnyModelType,\n  IAnyStateTreeNode,\n  IAnyType,\n  IDisposer,\n  IJsonPatch,\n  IStateTreeNode,\n  IType,\n  ReferenceIdentifier,\n  TypeOfValue\n} from \"../internal.ts\"\n\n/** @hidden */\nexport type TypeOrStateTreeNodeToStateTreeNode<\n  T extends IAnyType | IAnyStateTreeNode\n> = T extends IType<any, any, infer TT> ? TT & IStateTreeNode<T> : T\n\n/**\n * Returns the _actual_ type of the given tree node. (Or throws)\n *\n * @param object\n * @returns\n */\nexport function getType(object: IAnyStateTreeNode): IAnyComplexType {\n  assertIsStateTreeNode(object, 1)\n\n  return getStateTreeNode(object).type\n}\n\n/**\n * Returns the _declared_ type of the given sub property of an object, array or map.\n * In the case of arrays and maps the property name is optional and will be ignored.\n *\n * Example:\n * ```ts\n * const Box = types.model({ x: 0, y: 0 })\n * const box = Box.create()\n *\n * console.log(getChildType(box, \"x\").name) // 'number'\n * ```\n *\n * @param object\n * @param propertyName\n * @returns\n */\nexport function getChildType(\n  object: IAnyStateTreeNode,\n  propertyName?: string\n): IAnyType {\n  assertIsStateTreeNode(object, 1)\n\n  return getStateTreeNode(object).getChildType(propertyName)\n}\n\n/**\n * Registers a function that will be invoked for each mutation that is applied to the provided model instance, or to any of its children.\n * See [patches](https://github.com/mobxjs/mobx-state-tree#patches) for more details. onPatch events are emitted immediately and will not await the end of a transaction.\n * Patches can be used to deeply observe a model tree.\n *\n * @param target the model instance from which to receive patches\n * @param callback the callback that is invoked for each patch. The reversePatch is a patch that would actually undo the emitted patch\n * @returns function to remove the listener\n */\nexport function onPatch(\n  target: IAnyStateTreeNode,\n  callback: (patch: IJsonPatch, reversePatch: IJsonPatch) => void\n): IDisposer {\n  // check all arguments\n  assertIsStateTreeNode(target, 1)\n  assertIsFunction(callback, 2)\n\n  return getStateTreeNode(target).onPatch(callback)\n}\n\n/**\n * Registers a function that is invoked whenever a new snapshot for the given model instance is available.\n * The listener will only be fire at the end of the current MobX (trans)action.\n * See [snapshots](https://github.com/mobxjs/mobx-state-tree#snapshots) for more details.\n *\n * @param target\n * @param callback\n * @returns\n */\nexport function onSnapshot<S>(\n  target: IStateTreeNode<IType<any, S, any>>,\n  callback: (snapshot: S) => void\n): IDisposer {\n  // check all arguments\n  assertIsStateTreeNode(target, 1)\n  assertIsFunction(callback, 2)\n\n  return getStateTreeNode(target).onSnapshot(callback)\n}\n\n/**\n * Applies a JSON-patch to the given model instance or bails out if the patch couldn't be applied\n * See [patches](https://github.com/mobxjs/mobx-state-tree#patches) for more details.\n *\n * Can apply a single past, or an array of patches.\n *\n * @param target\n * @param patch\n * @returns\n */\nexport function applyPatch(\n  target: IAnyStateTreeNode,\n  patch: IJsonPatch | ReadonlyArray<IJsonPatch>\n): void {\n  // check all arguments\n  assertIsStateTreeNode(target, 1)\n  assertArg(patch, p => typeof p === \"object\", \"object or array\", 2)\n\n  getStateTreeNode(target).applyPatches(asArray(patch))\n}\n\nexport interface IPatchRecorder {\n  patches: ReadonlyArray<IJsonPatch>\n  inversePatches: ReadonlyArray<IJsonPatch>\n  reversedInversePatches: ReadonlyArray<IJsonPatch>\n  readonly recording: boolean\n  stop(): void\n  resume(): void\n  replay(target?: IAnyStateTreeNode): void\n  undo(target?: IAnyStateTreeNode): void\n}\n\n/**\n * Small abstraction around `onPatch` and `applyPatch`, attaches a patch listener to a tree and records all the patches.\n * Returns a recorder object with the following signature:\n *\n * Example:\n * ```ts\n * export interface IPatchRecorder {\n *      // the recorded patches\n *      patches: IJsonPatch[]\n *      // the inverse of the recorded patches\n *      inversePatches: IJsonPatch[]\n *      // true if currently recording\n *      recording: boolean\n *      // stop recording patches\n *      stop(): void\n *      // resume recording patches\n *      resume(): void\n *      // apply all the recorded patches on the given target (the original subject if omitted)\n *      replay(target?: IAnyStateTreeNode): void\n *      // reverse apply the recorded patches on the given target  (the original subject if omitted)\n *      // stops the recorder if not already stopped\n *      undo(): void\n * }\n * ```\n *\n * The optional filter function allows to skip recording certain patches.\n *\n * @param subject\n * @param filter\n * @returns\n */\nexport function recordPatches(\n  subject: IAnyStateTreeNode,\n  filter?: (\n    patch: IJsonPatch,\n    inversePatch: IJsonPatch,\n    actionContext: IActionContext | undefined\n  ) => boolean\n): IPatchRecorder {\n  // check all arguments\n  assertIsStateTreeNode(subject, 1)\n\n  interface IPatches {\n    patches: IJsonPatch[]\n    reversedInversePatches: IJsonPatch[]\n    inversePatches: IJsonPatch[]\n  }\n\n  const data: Pick<IPatches, \"patches\" | \"inversePatches\"> = {\n    patches: [],\n    inversePatches: []\n  }\n\n  // we will generate the immutable copy of patches on demand for public consumption\n  const publicData: Partial<IPatches> = {}\n\n  let disposer: IDisposer | undefined\n\n  const recorder: IPatchRecorder = {\n    get recording() {\n      return !!disposer\n    },\n    get patches() {\n      if (!publicData.patches) {\n        publicData.patches = data.patches.slice()\n      }\n      return publicData.patches\n    },\n    get reversedInversePatches() {\n      if (!publicData.reversedInversePatches) {\n        publicData.reversedInversePatches = data.inversePatches\n          .slice()\n          .reverse()\n      }\n      return publicData.reversedInversePatches\n    },\n    get inversePatches() {\n      if (!publicData.inversePatches) {\n        publicData.inversePatches = data.inversePatches.slice()\n      }\n      return publicData.inversePatches\n    },\n    stop() {\n      if (disposer) {\n        disposer()\n        disposer = undefined\n      }\n    },\n    resume() {\n      if (disposer) {\n        return\n      }\n      disposer = onPatch(subject, (patch, inversePatch) => {\n        // skip patches that are asked to be filtered if there's a filter in place\n        if (filter && !filter(patch, inversePatch, getRunningActionContext())) {\n          return\n        }\n        data.patches.push(patch)\n        data.inversePatches.push(inversePatch)\n\n        // mark immutable public patches as dirty\n        publicData.patches = undefined\n        publicData.inversePatches = undefined\n        publicData.reversedInversePatches = undefined\n      })\n    },\n    replay(target?: IAnyStateTreeNode) {\n      applyPatch(target || subject, data.patches)\n    },\n    undo(target?: IAnyStateTreeNode) {\n      applyPatch(target || subject, data.inversePatches.slice().reverse())\n    }\n  }\n\n  recorder.resume()\n  return recorder\n}\n\n/**\n * The inverse of `unprotect`.\n *\n * @param target\n */\nexport function protect(target: IAnyStateTreeNode): void {\n  // check all arguments\n  assertIsStateTreeNode(target, 1)\n\n  const node = getStateTreeNode(target)\n  if (!node.isRoot) {\n    throw fail(\"`protect` can only be invoked on root nodes\")\n  }\n  node.isProtectionEnabled = true\n}\n\n/**\n * By default it is not allowed to directly modify a model. Models can only be modified through actions.\n * However, in some cases you don't care about the advantages (like replayability, traceability, etc) this yields.\n * For example because you are building a PoC or don't have any middleware attached to your tree.\n *\n * In that case you can disable this protection by calling `unprotect` on the root of your tree.\n *\n * Example:\n * ```ts\n * const Todo = types.model({\n *     done: false\n * }).actions(self => ({\n *     toggle() {\n *         self.done = !self.done\n *     }\n * }))\n *\n * const todo = Todo.create()\n * todo.done = true // throws!\n * todo.toggle() // OK\n * unprotect(todo)\n * todo.done = false // OK\n * ```\n */\nexport function unprotect(target: IAnyStateTreeNode): void {\n  // check all arguments\n  assertIsStateTreeNode(target, 1)\n\n  const node = getStateTreeNode(target)\n  if (!node.isRoot) {\n    throw fail(\"`unprotect` can only be invoked on root nodes\")\n  }\n  node.isProtectionEnabled = false\n}\n\n/**\n * Returns true if the object is in protected mode, @see protect\n */\nexport function isProtected(target: IAnyStateTreeNode): boolean {\n  return getStateTreeNode(target).isProtected\n}\n\n/**\n * Applies a snapshot to a given model instances. Patch and snapshot listeners will be invoked as usual.\n *\n * @param target\n * @param snapshot\n * @returns\n */\nexport function applySnapshot<C>(\n  target: IStateTreeNode<IType<C, any, any>>,\n  snapshot: C\n) {\n  // check all arguments\n  assertIsStateTreeNode(target, 1)\n\n  return getStateTreeNode(target).applySnapshot(snapshot)\n}\n\n/**\n * Calculates a snapshot from the given model instance. The snapshot will always reflect the latest state but use\n * structural sharing where possible. Doesn't require MobX transactions to be completed.\n *\n * @param target\n * @param applyPostProcess If true (the default) then postProcessSnapshot gets applied.\n * @returns\n */\nexport function getSnapshot<S>(\n  target: IStateTreeNode<IType<any, S, any>>,\n  applyPostProcess = true\n): S {\n  // check all arguments\n  assertIsStateTreeNode(target, 1)\n\n  const node = getStateTreeNode(target)\n  if (applyPostProcess) {\n    return node.snapshot\n  }\n\n  return freeze(node.type.getSnapshot(node, false))\n}\n\n/**\n * Given a model instance, returns `true` if the object has a parent, that is, is part of another object, map or array.\n *\n * @param target\n * @param depth How far should we look upward? 1 by default.\n * @returns\n */\nexport function hasParent(\n  target: IAnyStateTreeNode,\n  depth: number = 1\n): boolean {\n  // check all arguments\n  assertIsStateTreeNode(target, 1)\n  assertIsNumber(depth, 2, 0)\n\n  let parent: AnyObjectNode | null = getStateTreeNode(target).parent\n  while (parent) {\n    if (--depth === 0) {\n      return true\n    }\n    parent = parent.parent\n  }\n  return false\n}\n\n/**\n * Returns the immediate parent of this object, or throws.\n *\n * Note that the immediate parent can be either an object, map or array, and\n * doesn't necessarily refer to the parent model.\n *\n * Please note that in child nodes access to the root is only possible\n * once the `afterAttach` hook has fired.\n *\n * @param target\n * @param depth How far should we look upward? 1 by default.\n * @returns\n */\nexport function getParent<IT extends IAnyStateTreeNode | IAnyComplexType>(\n  target: IAnyStateTreeNode,\n  depth = 1\n): TypeOrStateTreeNodeToStateTreeNode<IT> {\n  // check all arguments\n  assertIsStateTreeNode(target, 1)\n  assertIsNumber(depth, 2, 0)\n\n  let d = depth\n  let parent: AnyObjectNode | null = getStateTreeNode(target).parent\n  while (parent) {\n    if (--d === 0) {\n      return parent.storedValue as any\n    }\n    parent = parent.parent\n  }\n  throw fail(\n    `Failed to find the parent of ${getStateTreeNode(target)} at depth ${depth}`\n  )\n}\n\n/**\n * Given a model instance, returns `true` if the object has a parent of given type, that is, is part of another object, map or array\n *\n * @param target\n * @param type\n * @returns\n */\nexport function hasParentOfType(\n  target: IAnyStateTreeNode,\n  type: IAnyComplexType\n): boolean {\n  // check all arguments\n  assertIsStateTreeNode(target, 1)\n  assertIsType(type, 2)\n\n  let parent: AnyObjectNode | null = getStateTreeNode(target).parent\n  while (parent) {\n    if (type.is(parent.storedValue)) {\n      return true\n    }\n    parent = parent.parent\n  }\n  return false\n}\n\n/**\n * Returns the target's parent of a given type, or throws.\n *\n * @param target\n * @param type\n * @returns\n */\nexport function getParentOfType<IT extends IAnyComplexType>(\n  target: IAnyStateTreeNode,\n  type: IT\n): IT[\"Type\"] {\n  // check all arguments\n  assertIsStateTreeNode(target, 1)\n  assertIsType(type, 2)\n\n  let parent: AnyObjectNode | null = getStateTreeNode(target).parent\n  while (parent) {\n    if (type.is(parent.storedValue)) {\n      return parent.storedValue\n    }\n    parent = parent.parent\n  }\n  throw fail(\n    `Failed to find the parent of ${getStateTreeNode(target)} of a given type`\n  )\n}\n\n/**\n * Given an object in a model tree, returns the root object of that tree.\n *\n * Please note that in child nodes access to the root is only possible\n * once the `afterAttach` hook has fired.\n *\n * @param target\n * @returns\n */\nexport function getRoot<IT extends IAnyComplexType | IAnyStateTreeNode>(\n  target: IAnyStateTreeNode\n): TypeOrStateTreeNodeToStateTreeNode<IT> {\n  // check all arguments\n  assertIsStateTreeNode(target, 1)\n\n  return getStateTreeNode(target).root.storedValue\n}\n\n/**\n * Returns the path of the given object in the model tree\n *\n * @param target\n * @returns\n */\nexport function getPath(target: IAnyStateTreeNode): string {\n  // check all arguments\n  assertIsStateTreeNode(target, 1)\n\n  return getStateTreeNode(target).path\n}\n\n/**\n * Returns the path of the given object as unescaped string array.\n *\n * @param target\n * @returns\n */\nexport function getPathParts(target: IAnyStateTreeNode): string[] {\n  // check all arguments\n  assertIsStateTreeNode(target, 1)\n\n  return splitJsonPath(getStateTreeNode(target).path)\n}\n\n/**\n * Returns true if the given object is the root of a model tree.\n *\n * @param target\n * @returns\n */\nexport function isRoot(target: IAnyStateTreeNode): boolean {\n  // check all arguments\n  assertIsStateTreeNode(target, 1)\n\n  return getStateTreeNode(target).isRoot\n}\n\n/**\n * Resolves a path relatively to a given object.\n * Returns undefined if no value can be found.\n *\n * @param target\n * @param path escaped json path\n * @returns\n */\nexport function resolvePath(target: IAnyStateTreeNode, path: string): any {\n  // check all arguments\n  assertIsStateTreeNode(target, 1)\n  assertIsString(path, 2)\n\n  const node = resolveNodeByPath(getStateTreeNode(target), path)\n  return node ? node.value : undefined\n}\n\n/**\n * Resolves a model instance given a root target, the type and the identifier you are searching for.\n * Returns undefined if no value can be found.\n *\n * @param type\n * @param target\n * @param identifier\n * @returns\n */\nexport function resolveIdentifier<IT extends IAnyModelType>(\n  type: IT,\n  target: IAnyStateTreeNode,\n  identifier: ReferenceIdentifier\n): IT[\"Type\"] | undefined {\n  // check all arguments\n  assertIsType(type, 1)\n  assertIsStateTreeNode(target, 2)\n  assertIsValidIdentifier(identifier, 3)\n\n  const node = getStateTreeNode(target).root.identifierCache!.resolve(\n    type,\n    normalizeIdentifier(identifier)\n  )\n  return node?.value\n}\n\n/**\n * Returns the identifier of the target node.\n * This is the *string normalized* identifier, which might not match the type of the identifier attribute\n *\n * @param target\n * @returns\n */\nexport function getIdentifier(target: IAnyStateTreeNode): string | null {\n  // check all arguments\n  assertIsStateTreeNode(target, 1)\n\n  return getStateTreeNode(target).identifier\n}\n\n/**\n * Tests if a reference is valid (pointing to an existing node and optionally if alive) and returns such reference if the check passes,\n * else it returns undefined.\n *\n * @param getter Function to access the reference.\n * @param checkIfAlive true to also make sure the referenced node is alive (default), false to skip this check.\n * @returns\n */\nexport function tryReference<N extends IAnyStateTreeNode>(\n  getter: () => N | null | undefined,\n  checkIfAlive = true\n): N | undefined {\n  try {\n    const node = getter()\n    if (node === undefined || node === null) {\n      return undefined\n    } else if (isStateTreeNode(node)) {\n      if (!checkIfAlive) {\n        return node\n      } else {\n        return isAlive(node) ? node : undefined\n      }\n    } else {\n      throw fail(\n        \"The reference to be checked is not one of node, null or undefined\"\n      )\n    }\n  } catch (e) {\n    if (e instanceof InvalidReferenceError) {\n      return undefined\n    }\n    throw e\n  }\n}\n\n/**\n * Tests if a reference is valid (pointing to an existing node and optionally if alive) and returns if the check passes or not.\n *\n * @param getter Function to access the reference.\n * @param checkIfAlive true to also make sure the referenced node is alive (default), false to skip this check.\n * @returns\n */\nexport function isValidReference<N extends IAnyStateTreeNode>(\n  getter: () => N | null | undefined,\n  checkIfAlive = true\n): boolean {\n  try {\n    const node = getter()\n    if (node === undefined || node === null) {\n      return false\n    } else if (isStateTreeNode(node)) {\n      return checkIfAlive ? isAlive(node) : true\n    } else {\n      throw fail(\n        \"The reference to be checked is not one of node, null or undefined\"\n      )\n    }\n  } catch (e) {\n    if (e instanceof InvalidReferenceError) {\n      return false\n    }\n    throw e\n  }\n}\n\n/**\n * Try to resolve a given path relative to a given node.\n *\n * @param target\n * @param path\n * @returns\n */\nexport function tryResolve(target: IAnyStateTreeNode, path: string): any {\n  // check all arguments\n  assertIsStateTreeNode(target, 1)\n  assertIsString(path, 2)\n\n  const node = resolveNodeByPath(getStateTreeNode(target), path, false)\n  if (node === undefined) {\n    return undefined\n  }\n  try {\n    return node.value\n  } catch (_e) {\n    // For what ever reason not resolvable (e.g. totally not existing path, or value that cannot be fetched)\n    // see test / issue: 'try resolve doesn't work #686'\n    return undefined\n  }\n}\n\n/**\n * Given two state tree nodes that are part of the same tree,\n * returns the shortest jsonpath needed to navigate from the one to the other\n *\n * @param base\n * @param target\n * @returns\n */\nexport function getRelativePath(\n  base: IAnyStateTreeNode,\n  target: IAnyStateTreeNode\n): string {\n  // check all arguments\n  assertIsStateTreeNode(base, 1)\n  assertIsStateTreeNode(target, 2)\n\n  return getRelativePathBetweenNodes(\n    getStateTreeNode(base),\n    getStateTreeNode(target)\n  )\n}\n\n/**\n * Returns a deep copy of the given state tree node as new tree.\n * Shorthand for `snapshot(x) = getType(x).create(getSnapshot(x))`\n *\n * _Tip: clone will create a literal copy, including the same identifiers. To modify identifiers etc. during cloning, don't use clone but take a snapshot of the tree, modify it, and create new instance_\n *\n * @param source\n * @param keepEnvironment indicates whether the clone should inherit the same environment (`true`, the default), or not have an environment (`false`). If an object is passed in as second argument, that will act as the environment for the cloned tree.\n * @returns\n */\nexport function clone<T extends IAnyStateTreeNode>(\n  source: T,\n  keepEnvironment: boolean | any = true\n): T {\n  // check all arguments\n  assertIsStateTreeNode(source, 1)\n\n  const node = getStateTreeNode(source)\n  return node.type.create(\n    node.snapshot,\n    keepEnvironment === true\n      ? node.root.environment\n      : keepEnvironment === false\n        ? undefined\n        : keepEnvironment\n  ) // it's an object or something else\n}\n\n/**\n * Removes a model element from the state tree, and let it live on as a new state tree\n */\nexport function detach<T extends IAnyStateTreeNode>(target: T): T {\n  // check all arguments\n  assertIsStateTreeNode(target, 1)\n\n  getStateTreeNode(target).detach()\n  return target\n}\n\n/**\n * Removes a model element from the state tree, and mark it as end-of-life; the element should not be used anymore\n */\nexport function destroy(target: IAnyStateTreeNode): void {\n  // check all arguments\n  assertIsStateTreeNode(target, 1)\n\n  const node = getStateTreeNode(target)\n  if (node.isRoot) {\n    node.die()\n  } else {\n    node.parent!.removeChild(node.subpath)\n  }\n}\n\n/**\n * Returns true if the given state tree node is not killed yet.\n * This means that the node is still a part of a tree, and that `destroy`\n * has not been called. If a node is not alive anymore, the only thing one can do with it\n * is requesting it's last path and snapshot\n *\n * @param target\n * @returns\n */\nexport function isAlive(target: IAnyStateTreeNode): boolean {\n  // check all arguments\n  assertIsStateTreeNode(target, 1)\n\n  return getStateTreeNode(target).observableIsAlive\n}\n\n/**\n * Use this utility to register a function that should be called whenever the\n * targeted state tree node is destroyed. This is a useful alternative to managing\n * cleanup methods yourself using the `beforeDestroy` hook.\n *\n * This methods returns the same disposer that was passed as argument.\n *\n * Example:\n * ```ts\n * const Todo = types.model({\n *   title: types.string\n * }).actions(self => ({\n *   afterCreate() {\n *     const autoSaveDisposer = reaction(\n *       () => getSnapshot(self),\n *       snapshot => sendSnapshotToServerSomehow(snapshot)\n *     )\n *     // stop sending updates to server if this\n *     // instance is destroyed\n *     addDisposer(self, autoSaveDisposer)\n *   }\n * }))\n * ```\n *\n * @param target\n * @param disposer\n * @returns The same disposer that was passed as argument\n */\nexport function addDisposer(\n  target: IAnyStateTreeNode,\n  disposer: IDisposer\n): IDisposer {\n  // check all arguments\n  assertIsStateTreeNode(target, 1)\n  assertIsFunction(disposer, 2)\n\n  const node = getStateTreeNode(target)\n  node.addDisposer(disposer)\n  return disposer\n}\n\n/**\n * Returns the environment of the current state tree. For more info on environments,\n * see [Dependency injection](https://github.com/mobxjs/mobx-state-tree#dependency-injection)\n *\n * Please note that in child nodes access to the root is only possible\n * once the `afterAttach` hook has fired\n *\n * Returns an empty environment if the tree wasn't initialized with an environment\n *\n * @param target\n * @returns\n */\nexport function getEnv<T = any>(target: IAnyStateTreeNode): T {\n  // check all arguments\n  assertIsStateTreeNode(target, 1)\n\n  const node = getStateTreeNode(target)\n  const env = node.root.environment\n  if (!env) {\n    return EMPTY_OBJECT as T\n  }\n  return env\n}\n\n/**\n * Performs a depth first walk through a tree.\n */\nexport function walk(\n  target: IAnyStateTreeNode,\n  processor: (item: IAnyStateTreeNode) => void\n): void {\n  // check all arguments\n  assertIsStateTreeNode(target, 1)\n  assertIsFunction(processor, 2)\n\n  const node = getStateTreeNode(target)\n  // tslint:disable-next-line:no_unused-variable\n  node.getChildren().forEach(child => {\n    if (isStateTreeNode(child.storedValue)) {\n      walk(child.storedValue, processor)\n    }\n  })\n  processor(node.storedValue)\n}\n\nexport interface IModelReflectionPropertiesData {\n  name: string\n  properties: { [K: string]: IAnyType }\n}\n\n/**\n * Returns a reflection of the model type properties and name for either a model type or model node.\n *\n * @param typeOrNode\n * @returns\n */\nexport function getPropertyMembers(\n  typeOrNode: IAnyModelType | IAnyStateTreeNode\n): IModelReflectionPropertiesData {\n  let type: IAnyModelType\n\n  if (isStateTreeNode(typeOrNode)) {\n    type = getType(typeOrNode) as IAnyModelType\n  } else {\n    type = typeOrNode as IAnyModelType\n  }\n\n  assertArg(type, t => isModelType(t), \"model type or model instance\", 1)\n\n  return {\n    name: type.name,\n    properties: { ...type.properties }\n  }\n}\n\nexport interface IModelReflectionData extends IModelReflectionPropertiesData {\n  actions: string[]\n  views: string[]\n  volatile: string[]\n  flowActions: string[]\n}\n\n/**\n * Returns a reflection of the model node, including name, properties, views, volatile state,\n * and actions. `flowActions` is also provided as a separate array of names for any action that\n * came from a flow generator as well.\n *\n * In the case where a model has two actions: `doSomething` and `doSomethingWithFlow`, where\n * `doSomethingWithFlow` is a flow generator, the `actions` array will contain both actions,\n * i.e. [\"doSomething\", \"doSomethingWithFlow\"], and the `flowActions` array will contain only\n * the flow action, i.e. [\"doSomethingWithFlow\"].\n *\n * @param target\n * @returns\n */\nexport function getMembers(target: IAnyStateTreeNode): IModelReflectionData {\n  const type = getStateTreeNode(target).type as unknown as IAnyModelType\n\n  const reflected: IModelReflectionData = {\n    ...getPropertyMembers(type),\n    actions: [],\n    volatile: [],\n    views: [],\n    flowActions: []\n  }\n\n  const props = Object.getOwnPropertyNames(target)\n  props.forEach(key => {\n    if (key in reflected.properties) {\n      return\n    }\n    const descriptor = Object.getOwnPropertyDescriptor(target, key)!\n    if (descriptor.get) {\n      if (isComputedProp(target, key)) {\n        reflected.views.push(key)\n      } else {\n        reflected.volatile.push(key)\n      }\n      return\n    }\n    if (descriptor.value._isFlowAction === true) {\n      reflected.flowActions.push(key)\n    }\n    if (descriptor.value._isMSTAction === true) {\n      reflected.actions.push(key)\n    } else if (isObservableProp(target, key)) {\n      reflected.volatile.push(key)\n    } else {\n      reflected.views.push(key)\n    }\n  })\n  return reflected\n}\n\nexport function cast<\n  O extends string | number | boolean | null | undefined = never\n>(snapshotOrInstance: O): O\nexport function cast<O = never>(\n  snapshotOrInstance:\n    | TypeOfValue<O>[\"CreationType\"]\n    | TypeOfValue<O>[\"SnapshotType\"]\n    | TypeOfValue<O>[\"Type\"]\n): O\n/**\n * Casts a node snapshot or instance type to an instance type so it can be assigned to a type instance.\n * Note that this is just a cast for the type system, this is, it won't actually convert a snapshot to an instance,\n * but just fool typescript into thinking so.\n * Either way, casting when outside an assignation operation won't compile.\n *\n * Example:\n * ```ts\n * const ModelA = types.model({\n *   n: types.number\n * }).actions(self => ({\n *   setN(aNumber: number) {\n *     self.n = aNumber\n *   }\n * }))\n *\n * const ModelB = types.model({\n *   innerModel: ModelA\n * }).actions(self => ({\n *   someAction() {\n *     // this will allow the compiler to assign a snapshot to the property\n *     self.innerModel = cast({ a: 5 })\n *   }\n * }))\n * ```\n *\n * @param snapshotOrInstance Snapshot or instance\n * @returns The same object cast as an instance\n */\nexport function cast(snapshotOrInstance: any): any {\n  return snapshotOrInstance as any\n}\n\n/**\n * Casts a node instance type to a snapshot type so it can be assigned to a type snapshot (e.g. to be used inside a create call).\n * Note that this is just a cast for the type system, this is, it won't actually convert an instance to a snapshot,\n * but just fool typescript into thinking so.\n *\n * Example:\n * ```ts\n * const ModelA = types.model({\n *   n: types.number\n * }).actions(self => ({\n *   setN(aNumber: number) {\n *     self.n = aNumber\n *   }\n * }))\n *\n * const ModelB = types.model({\n *   innerModel: ModelA\n * })\n *\n * const a = ModelA.create({ n: 5 });\n * // this will allow the compiler to use a model as if it were a snapshot\n * const b = ModelB.create({ innerModel: castToSnapshot(a)})\n * ```\n *\n * @param snapshotOrInstance Snapshot or instance\n * @returns The same object cast as an input (creation) snapshot\n */\nexport function castToSnapshot<I>(\n  snapshotOrInstance: I\n): Extract<I, IAnyStateTreeNode> extends never\n  ? I\n  : TypeOfValue<I>[\"CreationType\"] {\n  return snapshotOrInstance as any\n}\n\n/**\n * Casts a node instance type to a reference snapshot type so it can be assigned to a reference snapshot (e.g. to be used inside a create call).\n * Note that this is just a cast for the type system, this is, it won't actually convert an instance to a reference snapshot,\n * but just fool typescript into thinking so.\n *\n * Example:\n * ```ts\n * const ModelA = types.model({\n *   id: types.identifier,\n *   n: types.number\n * }).actions(self => ({\n *   setN(aNumber: number) {\n *     self.n = aNumber\n *   }\n * }))\n *\n * const ModelB = types.model({\n *   refA: types.reference(ModelA)\n * })\n *\n * const a = ModelA.create({ id: 'someId', n: 5 });\n * // this will allow the compiler to use a model as if it were a reference snapshot\n * const b = ModelB.create({ refA: castToReferenceSnapshot(a)})\n * ```\n *\n * @param instance Instance\n * @returns The same object cast as a reference snapshot (string or number)\n */\nexport function castToReferenceSnapshot<I>(\n  instance: I\n): Extract<I, IAnyStateTreeNode> extends never ? I : ReferenceIdentifier {\n  return instance as any\n}\n\n/**\n * Returns the unique node id (not to be confused with the instance identifier) for a\n * given instance.\n * This id is a number that is unique for each instance.\n *\n * @export\n * @param target\n * @returns\n */\nexport function getNodeId(target: IAnyStateTreeNode): number {\n  assertIsStateTreeNode(target, 1)\n\n  return getStateTreeNode(target).nodeId\n}\n"]}

package/esm/core/node/BaseNode.d.ts

@@ -1,62 +0,0 @@
-import { type AnyObjectNode, Hook, type IAnyType, type IDisposer, NodeLifeCycle } from "../../internal.ts";
-type HookSubscribers = {
-    [Hook.afterAttach]: (node: AnyNode, hook: Hook) => void;
-    [Hook.afterCreate]: (node: AnyNode, hook: Hook) => void;
-    [Hook.afterCreationFinalization]: (node: AnyNode, hook: Hook) => void;
-    [Hook.beforeDestroy]: (node: AnyNode, hook: Hook) => void;
-    [Hook.beforeDetach]: (node: AnyNode, hook: Hook) => void;
-};
-/**
- * @internal
- * @hidden
- */
-export declare abstract class BaseNode<C, S, T> {
-    readonly type: IAnyType;
-    environment: any;
-    private _escapedSubpath?;
-    private _subpath;
-    get subpath(): string;
-    private _subpathUponDeath?;
-    get subpathUponDeath(): string | undefined;
-    private _pathUponDeath?;
-    protected get pathUponDeath(): string | undefined;
-    storedValue: any;
-    get value(): T;
-    private aliveAtom?;
-    private _state;
-    get state(): NodeLifeCycle;
-    set state(val: NodeLifeCycle);
-    private _hookSubscribers?;
-    protected abstract fireHook(name: Hook): void;
-    protected fireInternalHook(name: Hook): void;
-    registerHook<H extends Hook>(hook: H, hookHandler: HookSubscribers[H]): IDisposer;
-    private _parent;
-    get parent(): AnyObjectNode | null;
-    constructor(type: IAnyType, parent: AnyObjectNode | null, subpath: string, environment: any);
-    getReconciliationType(): IAnyType;
-    private pathAtom?;
-    protected baseSetParent(parent: AnyObjectNode | null, subpath: string): void;
-    get path(): string;
-    protected getEscapedPath(reportObserved: boolean): string;
-    get isRoot(): boolean;
-    abstract get root(): AnyObjectNode;
-    abstract setParent(newParent: AnyObjectNode | null, subpath: string | null): void;
-    abstract get snapshot(): S;
-    abstract getSnapshot(): S;
-    get isAlive(): boolean;
-    get isDetaching(): boolean;
-    get observableIsAlive(): boolean;
-    abstract die(): void;
-    abstract finalizeCreation(): void;
-    protected baseFinalizeCreation(whenFinalized?: () => void): void;
-    abstract finalizeDeath(): void;
-    protected baseFinalizeDeath(): void;
-    abstract aboutToDie(): void;
-    protected baseAboutToDie(): void;
-}
-/**
- * @internal
- * @hidden
- */
-export type AnyNode = BaseNode<any, any, any>;
-export {};

package/esm/core/node/BaseNode.js

@@ -1,148 +0,0 @@
-import { createAtom } from "mobx";
-import { EventHandlers, Hook, NodeLifeCycle, devMode, escapeJsonPath, fail } from "../../internal.js";
-/**
- * @internal
- * @hidden
- */
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-export class BaseNode {
-    type;
-    environment;
-    _escapedSubpath;
-    _subpath;
-    get subpath() {
-        return this._subpath;
-    }
-    _subpathUponDeath;
-    get subpathUponDeath() {
-        return this._subpathUponDeath;
-    }
-    _pathUponDeath;
-    get pathUponDeath() {
-        return this._pathUponDeath;
-    }
-    storedValue; // usually the same type as the value, but not always (such as with references)
-    get value() {
-        return this.type.getValue(this);
-    }
-    aliveAtom;
-    _state = NodeLifeCycle.INITIALIZING;
-    get state() {
-        return this._state;
-    }
-    set state(val) {
-        const wasAlive = this.isAlive;
-        this._state = val;
-        const isAlive = this.isAlive;
-        if (this.aliveAtom && wasAlive !== isAlive) {
-            this.aliveAtom.reportChanged();
-        }
-    }
-    _hookSubscribers;
-    fireInternalHook(name) {
-        if (this._hookSubscribers) {
-            this._hookSubscribers.emit(name, this, name);
-        }
-    }
-    registerHook(hook, hookHandler) {
-        if (!this._hookSubscribers) {
-            this._hookSubscribers = new EventHandlers();
-        }
-        return this._hookSubscribers.register(hook, hookHandler);
-    }
-    _parent;
-    get parent() {
-        return this._parent;
-    }
-    constructor(type, parent, subpath, environment) {
-        this.type = type;
-        this.environment = environment;
-        this.environment = environment;
-        this.baseSetParent(parent, subpath);
-    }
-    getReconciliationType() {
-        return this.type;
-    }
-    pathAtom;
-    baseSetParent(parent, subpath) {
-        this._parent = parent;
-        this._subpath = subpath;
-        this._escapedSubpath = undefined; // regenerate when needed
-        if (this.pathAtom) {
-            this.pathAtom.reportChanged();
-        }
-    }
-    /*
-     * Returns (escaped) path representation as string
-     */
-    get path() {
-        return this.getEscapedPath(true);
-    }
-    getEscapedPath(reportObserved) {
-        if (reportObserved) {
-            if (!this.pathAtom) {
-                this.pathAtom = createAtom(`path`);
-            }
-            this.pathAtom.reportObserved();
-        }
-        if (!this.parent) {
-            return "";
-        }
-        // regenerate escaped subpath if needed
-        if (this._escapedSubpath === undefined) {
-            this._escapedSubpath = !this._subpath ? "" : escapeJsonPath(this._subpath);
-        }
-        return (this.parent.getEscapedPath(reportObserved) + "/" + this._escapedSubpath);
-    }
-    get isRoot() {
-        return this.parent === null;
-    }
-    get isAlive() {
-        return this.state !== NodeLifeCycle.DEAD;
-    }
-    get isDetaching() {
-        return this.state === NodeLifeCycle.DETACHING;
-    }
-    get observableIsAlive() {
-        if (!this.aliveAtom) {
-            this.aliveAtom = createAtom(`alive`);
-        }
-        this.aliveAtom.reportObserved();
-        return this.isAlive;
-    }
-    baseFinalizeCreation(whenFinalized) {
-        if (devMode()) {
-            if (!this.isAlive) {
-                // istanbul ignore next
-                throw fail("assertion failed: cannot finalize the creation of a node that is already dead");
-            }
-        }
-        // goal: afterCreate hooks runs depth-first. After attach runs parent first, so on afterAttach the parent has completed already
-        if (this.state === NodeLifeCycle.CREATED) {
-            if (this.parent) {
-                if (this.parent.state !== NodeLifeCycle.FINALIZED) {
-                    // parent not ready yet, postpone
-                    return;
-                }
-                this.fireHook(Hook.afterAttach);
-            }
-            this.state = NodeLifeCycle.FINALIZED;
-            if (whenFinalized) {
-                whenFinalized();
-            }
-        }
-    }
-    baseFinalizeDeath() {
-        if (this._hookSubscribers) {
-            this._hookSubscribers.clearAll();
-        }
-        this._subpathUponDeath = this._subpath;
-        this._pathUponDeath = this.getEscapedPath(false);
-        this.baseSetParent(null, "");
-        this.state = NodeLifeCycle.DEAD;
-    }
-    baseAboutToDie() {
-        this.fireHook(Hook.beforeDestroy);
-    }
-}
-//# sourceMappingURL=BaseNode.js.map

package/esm/core/node/BaseNode.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"BaseNode.js","sourceRoot":"","sources":["../../../src/core/node/BaseNode.ts"],"names":[],"mappings":"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","sourcesContent":["import { type IAtom, createAtom } from \"mobx\"\n\nimport {\n  type AnyObjectNode,\n  EventHandlers,\n  Hook,\n  type IAnyType,\n  type IDisposer,\n  NodeLifeCycle,\n  devMode,\n  escapeJsonPath,\n  fail\n} from \"../../internal.ts\"\n\ntype HookSubscribers = {\n  [Hook.afterAttach]: (node: AnyNode, hook: Hook) => void\n  [Hook.afterCreate]: (node: AnyNode, hook: Hook) => void\n  [Hook.afterCreationFinalization]: (node: AnyNode, hook: Hook) => void\n  [Hook.beforeDestroy]: (node: AnyNode, hook: Hook) => void\n  [Hook.beforeDetach]: (node: AnyNode, hook: Hook) => void\n}\n\n/**\n * @internal\n * @hidden\n */\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nexport abstract class BaseNode<C, S, T> {\n  private _escapedSubpath?: string\n\n  private _subpath!: string\n  get subpath() {\n    return this._subpath\n  }\n\n  private _subpathUponDeath?: string\n  get subpathUponDeath() {\n    return this._subpathUponDeath\n  }\n\n  private _pathUponDeath?: string\n  protected get pathUponDeath() {\n    return this._pathUponDeath\n  }\n\n  storedValue!: any // usually the same type as the value, but not always (such as with references)\n  get value(): T {\n    return (this.type as any).getValue(this)\n  }\n\n  private aliveAtom?: IAtom\n  private _state = NodeLifeCycle.INITIALIZING\n  get state() {\n    return this._state\n  }\n  set state(val: NodeLifeCycle) {\n    const wasAlive = this.isAlive\n    this._state = val\n    const isAlive = this.isAlive\n\n    if (this.aliveAtom && wasAlive !== isAlive) {\n      this.aliveAtom.reportChanged()\n    }\n  }\n\n  private _hookSubscribers?: EventHandlers<HookSubscribers>\n\n  protected abstract fireHook(name: Hook): void\n\n  protected fireInternalHook(name: Hook) {\n    if (this._hookSubscribers) {\n      this._hookSubscribers.emit(name, this, name)\n    }\n  }\n\n  registerHook<H extends Hook>(\n    hook: H,\n    hookHandler: HookSubscribers[H]\n  ): IDisposer {\n    if (!this._hookSubscribers) {\n      this._hookSubscribers = new EventHandlers()\n    }\n    return this._hookSubscribers.register(hook, hookHandler)\n  }\n\n  private _parent!: AnyObjectNode | null\n  get parent() {\n    return this._parent\n  }\n\n  constructor(\n    readonly type: IAnyType,\n    parent: AnyObjectNode | null,\n    subpath: string,\n    public environment: any\n  ) {\n    this.environment = environment\n    this.baseSetParent(parent, subpath)\n  }\n\n  getReconciliationType() {\n    return this.type\n  }\n\n  private pathAtom?: IAtom\n  protected baseSetParent(parent: AnyObjectNode | null, subpath: string) {\n    this._parent = parent\n    this._subpath = subpath\n    this._escapedSubpath = undefined // regenerate when needed\n    if (this.pathAtom) {\n      this.pathAtom.reportChanged()\n    }\n  }\n\n  /*\n   * Returns (escaped) path representation as string\n   */\n  get path(): string {\n    return this.getEscapedPath(true)\n  }\n\n  protected getEscapedPath(reportObserved: boolean): string {\n    if (reportObserved) {\n      if (!this.pathAtom) {\n        this.pathAtom = createAtom(`path`)\n      }\n      this.pathAtom.reportObserved()\n    }\n    if (!this.parent) {\n      return \"\"\n    }\n    // regenerate escaped subpath if needed\n    if (this._escapedSubpath === undefined) {\n      this._escapedSubpath = !this._subpath ? \"\" : escapeJsonPath(this._subpath)\n    }\n    return (\n      this.parent.getEscapedPath(reportObserved) + \"/\" + this._escapedSubpath\n    )\n  }\n\n  get isRoot(): boolean {\n    return this.parent === null\n  }\n\n  abstract get root(): AnyObjectNode\n\n  abstract setParent(\n    newParent: AnyObjectNode | null,\n    subpath: string | null\n  ): void\n\n  abstract get snapshot(): S\n  abstract getSnapshot(): S\n\n  get isAlive() {\n    return this.state !== NodeLifeCycle.DEAD\n  }\n\n  get isDetaching() {\n    return this.state === NodeLifeCycle.DETACHING\n  }\n\n  get observableIsAlive() {\n    if (!this.aliveAtom) {\n      this.aliveAtom = createAtom(`alive`)\n    }\n    this.aliveAtom.reportObserved()\n    return this.isAlive\n  }\n\n  abstract die(): void\n\n  abstract finalizeCreation(): void\n\n  protected baseFinalizeCreation(whenFinalized?: () => void) {\n    if (devMode()) {\n      if (!this.isAlive) {\n        // istanbul ignore next\n        throw fail(\n          \"assertion failed: cannot finalize the creation of a node that is already dead\"\n        )\n      }\n    }\n\n    // goal: afterCreate hooks runs depth-first. After attach runs parent first, so on afterAttach the parent has completed already\n    if (this.state === NodeLifeCycle.CREATED) {\n      if (this.parent) {\n        if (this.parent.state !== NodeLifeCycle.FINALIZED) {\n          // parent not ready yet, postpone\n          return\n        }\n        this.fireHook(Hook.afterAttach)\n      }\n\n      this.state = NodeLifeCycle.FINALIZED\n\n      if (whenFinalized) {\n        whenFinalized()\n      }\n    }\n  }\n\n  abstract finalizeDeath(): void\n\n  protected baseFinalizeDeath() {\n    if (this._hookSubscribers) {\n      this._hookSubscribers.clearAll()\n    }\n\n    this._subpathUponDeath = this._subpath\n    this._pathUponDeath = this.getEscapedPath(false)\n    this.baseSetParent(null, \"\")\n    this.state = NodeLifeCycle.DEAD\n  }\n\n  abstract aboutToDie(): void\n\n  protected baseAboutToDie() {\n    this.fireHook(Hook.beforeDestroy)\n  }\n}\n\n/**\n * @internal\n * @hidden\n */\nexport type AnyNode = BaseNode<any, any, any>\n"]}

package/esm/core/node/Hook.d.ts

@@ -1,17 +0,0 @@
-/**
- * @hidden
- */
-export declare enum Hook {
-    afterCreate = "afterCreate",
-    afterAttach = "afterAttach",
-    afterCreationFinalization = "afterCreationFinalization",
-    beforeDetach = "beforeDetach",
-    beforeDestroy = "beforeDestroy"
-}
-export interface IHooks {
-    [Hook.afterCreate]?: () => void;
-    [Hook.afterAttach]?: () => void;
-    [Hook.beforeDetach]?: () => void;
-    [Hook.beforeDestroy]?: () => void;
-}
-export type IHooksGetter<T> = (self: T) => IHooks;

package/esm/core/node/Hook.js

@@ -1,12 +0,0 @@
-/**
- * @hidden
- */
-export var Hook;
-(function (Hook) {
-    Hook["afterCreate"] = "afterCreate";
-    Hook["afterAttach"] = "afterAttach";
-    Hook["afterCreationFinalization"] = "afterCreationFinalization";
-    Hook["beforeDetach"] = "beforeDetach";
-    Hook["beforeDestroy"] = "beforeDestroy";
-})(Hook || (Hook = {}));
-//# sourceMappingURL=Hook.js.map

package/esm/core/node/Hook.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"Hook.js","sourceRoot":"","sources":["../../../src/core/node/Hook.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,CAAN,IAAY,IAMX;AAND,WAAY,IAAI;IACd,mCAA2B,CAAA;IAC3B,mCAA2B,CAAA;IAC3B,+DAAuD,CAAA;IACvD,qCAA6B,CAAA;IAC7B,uCAA+B,CAAA;AACjC,CAAC,EANW,IAAI,KAAJ,IAAI,QAMf","sourcesContent":["/**\n * @hidden\n */\nexport enum Hook {\n  afterCreate = \"afterCreate\",\n  afterAttach = \"afterAttach\",\n  afterCreationFinalization = \"afterCreationFinalization\",\n  beforeDetach = \"beforeDetach\",\n  beforeDestroy = \"beforeDestroy\"\n}\n\nexport interface IHooks {\n  [Hook.afterCreate]?: () => void\n  [Hook.afterAttach]?: () => void\n  [Hook.beforeDetach]?: () => void\n  [Hook.beforeDestroy]?: () => void\n}\n\nexport type IHooksGetter<T> = (self: T) => IHooks\n"]}

package/esm/core/node/create-node.d.ts

@@ -1,16 +0,0 @@
-import { type AnyNode, type AnyObjectNode, ComplexType, ObjectNode, ScalarNode, SimpleType } from "../../internal.ts";
-/**
- * @internal
- * @hidden
- */
-export declare function createObjectNode<C, S, T>(type: ComplexType<C, S, T>, parent: AnyObjectNode | null, subpath: string, environment: any, initialValue: C | T): ObjectNode<C, S, T>;
-/**
- * @internal
- * @hidden
- */
-export declare function createScalarNode<C, S, T>(type: SimpleType<C, S, T>, parent: AnyObjectNode | null, subpath: string, environment: any, initialValue: C): ScalarNode<C, S, T>;
-/**
- * @internal
- * @hidden
- */
-export declare function isNode(value: any): value is AnyNode;

package/esm/core/node/create-node.js

@@ -1,36 +0,0 @@
-import { ObjectNode, ScalarNode, fail, getStateTreeNodeSafe } from "../../internal.js";
-/**
- * @internal
- * @hidden
- */
-export function createObjectNode(type, parent, subpath, environment, initialValue) {
-    const existingNode = getStateTreeNodeSafe(initialValue);
-    if (existingNode) {
-        if (existingNode.parent) {
-            // istanbul ignore next
-            throw fail(`Cannot add an object to a state tree if it is already part of the same or another state tree. Tried to assign an object to '${parent ? parent.path : ""}/${subpath}', but it lives already at '${existingNode.path}'`);
-        }
-        if (parent) {
-            existingNode.setParent(parent, subpath);
-        }
-        // else it already has no parent since it is a pre-requisite
-        return existingNode;
-    }
-    // not a node, a snapshot
-    return new ObjectNode(type, parent, subpath, environment, initialValue);
-}
-/**
- * @internal
- * @hidden
- */
-export function createScalarNode(type, parent, subpath, environment, initialValue) {
-    return new ScalarNode(type, parent, subpath, environment, initialValue);
-}
-/**
- * @internal
- * @hidden
- */
-export function isNode(value) {
-    return value instanceof ScalarNode || value instanceof ObjectNode;
-}
-//# sourceMappingURL=create-node.js.map

package/esm/core/node/create-node.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"create-node.js","sourceRoot":"","sources":["../../../src/core/node/create-node.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,UAAU,EACV,UAAU,EAEV,IAAI,EACJ,oBAAoB,EACrB,MAAM,mBAAmB,CAAA;AAE1B;;;GAGG;AACH,MAAM,UAAU,gBAAgB,CAC9B,IAA0B,EAC1B,MAA4B,EAC5B,OAAe,EACf,WAAgB,EAChB,YAAmB;IAEnB,MAAM,YAAY,GAAG,oBAAoB,CAAC,YAAY,CAAC,CAAA;IACvD,IAAI,YAAY,EAAE,CAAC;QACjB,IAAI,YAAY,CAAC,MAAM,EAAE,CAAC;YACxB,uBAAuB;YACvB,MAAM,IAAI,CACR,+HACE,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EACzB,IAAI,OAAO,+BAA+B,YAAY,CAAC,IAAI,GAAG,CAC/D,CAAA;QACH,CAAC;QAED,IAAI,MAAM,EAAE,CAAC;YACX,YAAY,CAAC,SAAS,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;QACzC,CAAC;QACD,4DAA4D;QAE5D,OAAO,YAAY,CAAA;IACrB,CAAC;IAED,yBAAyB;IACzB,OAAO,IAAI,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,WAAW,EAAE,YAAiB,CAAC,CAAA;AAC9E,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,gBAAgB,CAC9B,IAAyB,EACzB,MAA4B,EAC5B,OAAe,EACf,WAAgB,EAChB,YAAe;IAEf,OAAO,IAAI,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,WAAW,EAAE,YAAY,CAAC,CAAA;AACzE,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,MAAM,CAAC,KAAU;IAC/B,OAAO,KAAK,YAAY,UAAU,IAAI,KAAK,YAAY,UAAU,CAAA;AACnE,CAAC","sourcesContent":["import {\n  type AnyNode,\n  type AnyObjectNode,\n  ComplexType,\n  ObjectNode,\n  ScalarNode,\n  SimpleType,\n  fail,\n  getStateTreeNodeSafe\n} from \"../../internal.ts\"\n\n/**\n * @internal\n * @hidden\n */\nexport function createObjectNode<C, S, T>(\n  type: ComplexType<C, S, T>,\n  parent: AnyObjectNode | null,\n  subpath: string,\n  environment: any,\n  initialValue: C | T\n): ObjectNode<C, S, T> {\n  const existingNode = getStateTreeNodeSafe(initialValue)\n  if (existingNode) {\n    if (existingNode.parent) {\n      // istanbul ignore next\n      throw fail(\n        `Cannot add an object to a state tree if it is already part of the same or another state tree. Tried to assign an object to '${\n          parent ? parent.path : \"\"\n        }/${subpath}', but it lives already at '${existingNode.path}'`\n      )\n    }\n\n    if (parent) {\n      existingNode.setParent(parent, subpath)\n    }\n    // else it already has no parent since it is a pre-requisite\n\n    return existingNode\n  }\n\n  // not a node, a snapshot\n  return new ObjectNode(type, parent, subpath, environment, initialValue as C)\n}\n\n/**\n * @internal\n * @hidden\n */\nexport function createScalarNode<C, S, T>(\n  type: SimpleType<C, S, T>,\n  parent: AnyObjectNode | null,\n  subpath: string,\n  environment: any,\n  initialValue: C\n): ScalarNode<C, S, T> {\n  return new ScalarNode(type, parent, subpath, environment, initialValue)\n}\n\n/**\n * @internal\n * @hidden\n */\nexport function isNode(value: any): value is AnyNode {\n  return value instanceof ScalarNode || value instanceof ObjectNode\n}\n"]}

package/esm/core/node/identifier-cache.d.ts

@@ -1,19 +0,0 @@
-import { type AnyObjectNode, type IAnyComplexType, ObjectNode } from "../../internal.ts";
-/**
- * @internal
- * @hidden
- */
-export declare class IdentifierCache {
-    private cacheId;
-    private cache;
-    private lastCacheModificationPerId;
-    constructor();
-    private updateLastCacheModificationPerId;
-    getLastCacheModificationPerId(identifier: string): string;
-    addNodeToCache(node: AnyObjectNode, lastCacheUpdate?: boolean): void;
-    mergeCache(node: AnyObjectNode): void;
-    notifyDied(node: AnyObjectNode): void;
-    splitCache(splitNode: AnyObjectNode): IdentifierCache;
-    has(type: IAnyComplexType, identifier: string): boolean;
-    resolve<IT extends IAnyComplexType>(type: IT, identifier: string): ObjectNode<IT["CreationType"], IT["SnapshotType"], IT["TypeWithoutSTN"]> | null;
-}

package/esm/core/node/identifier-cache.js

@@ -1,111 +0,0 @@
-import { entries, observable, values } from "mobx";
-import { fail, mobxShallow } from "../../internal.js";
-let identifierCacheId = 0;
-/**
- * @internal
- * @hidden
- */
-export class IdentifierCache {
-    cacheId = identifierCacheId++;
-    // n.b. in cache all identifiers are normalized to strings
-    cache = observable.map();
-    // last time the cache (array) for a given time changed
-    // n.b. it is not really the time, but just an integer that gets increased after each modification to the array
-    lastCacheModificationPerId = observable.map();
-    constructor() { }
-    updateLastCacheModificationPerId(identifier) {
-        const lcm = this.lastCacheModificationPerId.get(identifier);
-        // we start at 1 since 0 means no update since cache creation
-        this.lastCacheModificationPerId.set(identifier, lcm === undefined ? 1 : lcm + 1);
-    }
-    getLastCacheModificationPerId(identifier) {
-        const modificationId = this.lastCacheModificationPerId.get(identifier) || 0;
-        return `${this.cacheId}-${modificationId}`;
-    }
-    addNodeToCache(node, lastCacheUpdate = true) {
-        if (node.identifierAttribute) {
-            const identifier = node.identifier;
-            if (!this.cache.has(identifier)) {
-                this.cache.set(identifier, observable.array([], mobxShallow));
-            }
-            const set = this.cache.get(identifier);
-            if (set.indexOf(node) !== -1) {
-                throw fail(`Already registered`);
-            }
-            set.push(node);
-            if (lastCacheUpdate) {
-                this.updateLastCacheModificationPerId(identifier);
-            }
-        }
-    }
-    mergeCache(node) {
-        values(node.identifierCache.cache).forEach(nodes => nodes.forEach(child => {
-            this.addNodeToCache(child);
-        }));
-    }
-    notifyDied(node) {
-        if (node.identifierAttribute) {
-            const id = node.identifier;
-            const set = this.cache.get(id);
-            if (set) {
-                set.remove(node);
-                // remove empty sets from cache
-                if (!set.length) {
-                    this.cache.delete(id);
-                }
-                this.updateLastCacheModificationPerId(node.identifier);
-            }
-        }
-    }
-    splitCache(splitNode) {
-        const newCache = new IdentifierCache();
-        // The slash is added here so we only match children of the splitNode. In version 5.1.8 and
-        // earlier there was no trailing slash, so non children that started with the same path string
-        // were being matched incorrectly.
-        const basePath = splitNode.path + "/";
-        entries(this.cache).forEach(([id, nodes]) => {
-            let modified = false;
-            for (let i = nodes.length - 1; i >= 0; i--) {
-                const node = nodes[i];
-                if (node === splitNode || node.path.indexOf(basePath) === 0) {
-                    newCache.addNodeToCache(node, false); // no need to update lastUpdated since it is a whole new cache
-                    nodes.splice(i, 1);
-                    // remove empty sets from cache
-                    if (!nodes.length) {
-                        this.cache.delete(id);
-                    }
-                    modified = true;
-                }
-            }
-            if (modified) {
-                this.updateLastCacheModificationPerId(id);
-            }
-        });
-        return newCache;
-    }
-    has(type, identifier) {
-        const set = this.cache.get(identifier);
-        if (!set) {
-            return false;
-        }
-        return set.some(candidate => type.isAssignableFrom(candidate.type));
-    }
-    resolve(type, identifier) {
-        const set = this.cache.get(identifier);
-        if (!set) {
-            return null;
-        }
-        const matches = set.filter(candidate => type.isAssignableFrom(candidate.type));
-        switch (matches.length) {
-            case 0:
-                return null;
-            case 1:
-                return matches[0];
-            default:
-                throw fail(`Cannot resolve a reference to type '${type.name}' with id: '${identifier}' unambigously, there are multiple candidates: ${matches
-                    .map(n => n.path)
-                    .join(", ")}`);
-        }
-    }
-}
-//# sourceMappingURL=identifier-cache.js.map

package/esm/core/node/identifier-cache.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"identifier-cache.js","sourceRoot":"","sources":["../../../src/core/node/identifier-cache.ts"],"names":[],"mappings":"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","sourcesContent":["import { type IObservableArray, entries, observable, values } from \"mobx\"\n\nimport {\n  type AnyObjectNode,\n  type IAnyComplexType,\n  ObjectNode,\n  fail,\n  mobxShallow\n} from \"../../internal.ts\"\n\nlet identifierCacheId = 0\n\n/**\n * @internal\n * @hidden\n */\nexport class IdentifierCache {\n  private cacheId = identifierCacheId++\n\n  // n.b. in cache all identifiers are normalized to strings\n  private cache = observable.map<string, IObservableArray<AnyObjectNode>>()\n\n  // last time the cache (array) for a given time changed\n  // n.b. it is not really the time, but just an integer that gets increased after each modification to the array\n  private lastCacheModificationPerId = observable.map<string, number>()\n\n  constructor() {}\n\n  private updateLastCacheModificationPerId(identifier: string) {\n    const lcm = this.lastCacheModificationPerId.get(identifier)\n    // we start at 1 since 0 means no update since cache creation\n    this.lastCacheModificationPerId.set(\n      identifier,\n      lcm === undefined ? 1 : lcm + 1\n    )\n  }\n\n  getLastCacheModificationPerId(identifier: string): string {\n    const modificationId = this.lastCacheModificationPerId.get(identifier) || 0\n    return `${this.cacheId}-${modificationId}`\n  }\n\n  addNodeToCache(node: AnyObjectNode, lastCacheUpdate = true): void {\n    if (node.identifierAttribute) {\n      const identifier = node.identifier!\n      if (!this.cache.has(identifier)) {\n        this.cache.set(\n          identifier,\n          observable.array<AnyObjectNode>([], mobxShallow)\n        )\n      }\n      const set = this.cache.get(identifier)!\n      if (set.indexOf(node) !== -1) {\n        throw fail(`Already registered`)\n      }\n      set.push(node)\n      if (lastCacheUpdate) {\n        this.updateLastCacheModificationPerId(identifier)\n      }\n    }\n  }\n\n  mergeCache(node: AnyObjectNode) {\n    values(node.identifierCache!.cache).forEach(nodes =>\n      nodes.forEach(child => {\n        this.addNodeToCache(child)\n      })\n    )\n  }\n\n  notifyDied(node: AnyObjectNode) {\n    if (node.identifierAttribute) {\n      const id = node.identifier!\n      const set = this.cache.get(id)\n      if (set) {\n        set.remove(node)\n        // remove empty sets from cache\n        if (!set.length) {\n          this.cache.delete(id)\n        }\n        this.updateLastCacheModificationPerId(node.identifier!)\n      }\n    }\n  }\n\n  splitCache(splitNode: AnyObjectNode): IdentifierCache {\n    const newCache = new IdentifierCache()\n    // The slash is added here so we only match children of the splitNode. In version 5.1.8 and\n    // earlier there was no trailing slash, so non children that started with the same path string\n    // were being matched incorrectly.\n    const basePath = splitNode.path + \"/\"\n    entries(this.cache).forEach(([id, nodes]) => {\n      let modified = false\n      for (let i = nodes.length - 1; i >= 0; i--) {\n        const node = nodes[i]\n        if (node === splitNode || node.path.indexOf(basePath) === 0) {\n          newCache.addNodeToCache(node, false) // no need to update lastUpdated since it is a whole new cache\n          nodes.splice(i, 1)\n          // remove empty sets from cache\n          if (!nodes.length) {\n            this.cache.delete(id)\n          }\n          modified = true\n        }\n      }\n      if (modified) {\n        this.updateLastCacheModificationPerId(id)\n      }\n    })\n    return newCache\n  }\n\n  has(type: IAnyComplexType, identifier: string): boolean {\n    const set = this.cache.get(identifier)\n    if (!set) {\n      return false\n    }\n    return set.some(candidate => type.isAssignableFrom(candidate.type))\n  }\n\n  resolve<IT extends IAnyComplexType>(\n    type: IT,\n    identifier: string\n  ): ObjectNode<\n    IT[\"CreationType\"],\n    IT[\"SnapshotType\"],\n    IT[\"TypeWithoutSTN\"]\n  > | null {\n    const set = this.cache.get(identifier)\n    if (!set) {\n      return null\n    }\n    const matches = set.filter(candidate =>\n      type.isAssignableFrom(candidate.type)\n    )\n    switch (matches.length) {\n      case 0:\n        return null\n      case 1:\n        return matches[0]\n      default:\n        throw fail(\n          `Cannot resolve a reference to type '${\n            type.name\n          }' with id: '${identifier}' unambigously, there are multiple candidates: ${matches\n            .map(n => n.path)\n            .join(\", \")}`\n        )\n    }\n  }\n}\n"]}

package/esm/core/node/livelinessChecking.d.ts

@@ -1,37 +0,0 @@
-/**
- * Defines what MST should do when running into reads / writes to objects that have died.
- * - `"warn"`: Print a warning (default).
- * - `"error"`: Throw an exception.
- * - "`ignore`": Do nothing.
- */
-export type LivelinessMode = "warn" | "error" | "ignore";
-/**
- * Defines what MST should do when running into reads / writes to objects that have died.
- * By default it will print a warning.
- * Use the `"error"` option to easy debugging to see where the error was thrown and when the offending read / write took place
- *
- * @param mode `"warn"`, `"error"` or `"ignore"`
- */
-export declare function setLivelinessChecking(mode: LivelinessMode): void;
-/**
- * Returns the current liveliness checking mode.
- *
- * @returns `"warn"`, `"error"` or `"ignore"`
- */
-export declare function getLivelinessChecking(): LivelinessMode;
-/**
- * @deprecated use LivelinessMode instead
- * @hidden
- */
-export type LivelynessMode = LivelinessMode;
-/**
- * @deprecated use setLivelinessChecking instead
- * @hidden
- *
- * Defines what MST should do when running into reads / writes to objects that have died.
- * By default it will print a warning.
- * Use the `"error"` option to easy debugging to see where the error was thrown and when the offending read / write took place
- *
- * @param mode `"warn"`, `"error"` or `"ignore"`
- */
-export declare function setLivelynessChecking(mode: LivelinessMode): void;