@portabletext/editor 7.10.16 → 7.10.17

package/lib/get-parent-51Kzgaf9.js

@@ -0,0 +1,237 @@
+import { isTextBlock } from "@portabletext/schema";
+/**
+* @public
+*/
+function isKeyedSegment(segment) {
+	return typeof segment == "object" && !!segment && "_key" in segment;
+}
+/**
+* Serialize a keyed path to a string using Sanity's bracket notation.
+*
+* - `[{_key: 'k0'}]` -> `[_key=="k0"]`
+* - `[{_key: 'k0'}, 'children', {_key: 's0'}]` -> `[_key=="k0"].children[_key=="s0"]`
+* - `[{_key: 't0'}, 'rows', {_key: 'r0'}, 'cells', {_key: 'c0'}, 'content', {_key: 'b0'}, 'children', {_key: 's0'}]` -> `[_key=="t0"].rows[_key=="r0"].cells[_key=="c0"].content[_key=="b0"].children[_key=="s0"]`
+*/
+function serializePath(path) {
+	return path.reduce((result, segment, index) => isKeyedSegment(segment) ? `${result}[_key=="${segment._key}"]` : `${result}${index === 0 ? "" : "."}${segment}`, "");
+}
+function isTypedObject(object) {
+	return isRecord(object) && typeof object._type == "string";
+}
+function isRecord(value) {
+	return !!value && (typeof value == "object" || typeof value == "function");
+}
+/**
+* Resolve a container node's editable child array.
+*
+* Returns `{children, container}` for a node registered as a container:
+* `children` is the node's editable child array, and `container` is the
+* node's own container registration. Read `container.field.name` for the
+* path segment that reaches `children`, and thread `container` back in as
+* `parent` when descending into them.
+*
+* Returns `undefined` for anything that is not a container: text blocks,
+* spans, leaves, and unregistered objects. It is node-based and resolves
+* in one step with no path re-walk, so recursive descent over containers
+* is linear in nesting depth. The caller seeds the document root from
+* `context.value` itself.
+*
+* @beta
+*/
+function getContainerChildren(containers, node, parent) {
+	let resolved = resolveNodeContainer(containers, parent, node);
+	if (!resolved) return;
+	let fieldValue = node[resolved.field.name];
+	if (Array.isArray(fieldValue)) return {
+		children: fieldValue,
+		container: resolved
+	};
+}
+/**
+* Pick the positional override from `parent.of` if present; fall back
+* to the top-level entry. Returns only `RegisteredContainer` entries
+* since leaves do not have editable children.
+*/
+function resolveNodeContainer(containers, parent, node) {
+	if (parent?.of) {
+		for (let entry of parent.of) if (entry.type === node._type) return "field" in entry ? entry : void 0;
+	}
+	return containers.get(node._type);
+}
+/**
+* Get the children of a node at a given path.
+*
+* @beta
+*/
+function getChildren(snapshot, path) {
+	let currentChildren = snapshot.context.value, currentFieldName = "value", currentPath = [], isRoot = !0, currentParent;
+	for (let segment of path) {
+		if (typeof segment == "string") continue;
+		let node;
+		if (isKeyedSegment(segment)) {
+			let candidatePath = isRoot ? [{ _key: segment._key }] : [
+				...currentPath,
+				currentFieldName,
+				{ _key: segment._key }
+			], index = snapshot.blockIndexMap.get(serializePath(candidatePath));
+			node = index !== void 0 && currentChildren[index]?._key === segment._key ? currentChildren[index] : currentChildren.find((child) => child._key === segment._key);
+		} else typeof segment == "number" && (node = currentChildren.at(segment));
+		if (!node) return [];
+		currentPath = isRoot ? [{ _key: node._key }] : [
+			...currentPath,
+			currentFieldName,
+			{ _key: node._key }
+		], isRoot = !1;
+		let next = getNodeChildren(snapshot.context, node, currentParent);
+		if (!next) return [];
+		currentChildren = next.children, currentFieldName = next.fieldName, currentParent = next.parent;
+	}
+	return currentChildren.map((child) => ({
+		node: child,
+		path: isRoot ? [{ _key: child._key }] : [
+			...currentPath,
+			currentFieldName,
+			{ _key: child._key }
+		]
+	}));
+}
+/**
+* Resolve a node's editable child array.
+*
+* When `parent` is provided and its `of` declares a positional entry
+* matching `node._type`, that positional entry's `field` is used.
+* Otherwise the top-level `containers.get(node._type)` provides the
+* fallback.
+*
+* The returned `parent` is the resolved container entry for `node`
+* itself (used by the caller to thread further descent).
+*
+* Internal descent kernel shared by the positional traversal utilities
+* (`getChildren`, `getNode`, `getNodes`, `getAncestors`); it folds the
+* text-block, container, and root-document cases. Public consumers that
+* only need to descend containers use {@link getContainerChildren}.
+*/
+function getNodeChildren(context, node, parent) {
+	if (isTextBlock(context, node)) return {
+		children: node.children,
+		fieldName: "children",
+		parent: void 0
+	};
+	if (isTypedObject(node)) {
+		let result = getContainerChildren(context.containers, node, parent);
+		if (result) return {
+			children: result.children,
+			fieldName: result.container.field.name,
+			parent: result.container
+		};
+	}
+	if ("value" in node && Array.isArray(node.value) && !("_key" in node) && !("_type" in node)) return {
+		children: node.value,
+		fieldName: "value",
+		parent: void 0
+	};
+}
+/**
+* Get the node at a given path.
+*
+* The path can be either keyed (KeyedSegment + field name strings) or
+* indexed (numbers). Keyed segments are resolved by matching `_key`,
+* field name strings name a structural descent into the previous
+* node's children, and numbers are resolved by index.
+*
+* The returned `path` always identifies the returned node: it's fully
+* keyed (numeric indices are converted to `KeyedSegment`s) and any
+* trailing segments in the input that point outside the value tree —
+* e.g. an object node's primitive field, or an annotation reached via
+* `'markDefs'` on a text block — are stripped so that
+* `getNode(snapshot, entry.path).node === entry.node`.
+*
+* The walk stops when a string segment names a field that isn't the
+* current node's structural child array. Annotations live in
+* `markDefs` on a text block, alongside `children` rather than inside
+* it, so `getNode` resolves an annotation path to the enclosing text
+* block. Use `getAnnotation` to resolve the annotation itself.
+*
+* @beta
+*/
+function getNode(snapshot, path) {
+	if (path.length === 0) return;
+	let { context, blockIndexMap } = snapshot, currentChildren = context.value, currentFieldName, node, currentParent, resolvedPath = [];
+	for (let i = 0; i < path.length; i++) {
+		let segment = path[i];
+		if (typeof segment == "string") {
+			if (currentFieldName !== void 0 && segment === currentFieldName) {
+				resolvedPath.push(segment);
+				continue;
+			}
+			for (let j = i + 1; j < path.length; j++) {
+				let s = path[j];
+				if (isKeyedSegment(s) || typeof s == "number") return;
+			}
+			break;
+		}
+		if (isKeyedSegment(segment)) {
+			resolvedPath.push(segment);
+			let index = blockIndexMap.get(serializePath(resolvedPath));
+			index !== void 0 && currentChildren[index]?._key === segment._key ? node = currentChildren[index] : (node = currentChildren.find((child) => child._key === segment._key), node && node._key !== void 0 && (resolvedPath[resolvedPath.length - 1] = { _key: node._key }));
+		} else if (typeof segment == "number") node = currentChildren.at(segment), node && resolvedPath.push({ _key: node._key });
+		else return;
+		if (!node) return;
+		let hasMoreSegments = !1;
+		for (let j = i + 1; j < path.length; j++) {
+			let s = path[j];
+			if (isKeyedSegment(s) || typeof s == "number") {
+				hasMoreSegments = !0;
+				break;
+			}
+		}
+		if (hasMoreSegments) {
+			let next = getNodeChildren(context, node, currentParent);
+			if (!next) return;
+			currentChildren = next.children, currentFieldName = next.fieldName, currentParent = next.parent;
+		} else currentFieldName = void 0;
+	}
+	if (node) {
+		for (; resolvedPath.length > 0 && typeof resolvedPath[resolvedPath.length - 1] == "string";) resolvedPath.pop();
+		return {
+			node,
+			path: resolvedPath
+		};
+	}
+}
+/**
+* Get the parent path of a path.
+*
+* Drops the last node segment (keyed or numeric) and the preceding field
+* name string.
+*
+* [{_key:'b1'}, 'children', {_key:'s1'}] → [{_key:'b1'}]
+* [{_key:'b1'}, 'children', 0]           → [{_key:'b1'}]
+* [{_key:'b1'}]                           → []
+*/
+function parentPath(path) {
+	if (path.length === 0) throw Error(`Cannot get the parent path of the root path [${path}].`);
+	let lastNodeIndex = -1;
+	for (let i = path.length - 1; i >= 0; i--) if (isKeyedSegment(path[i]) || typeof path[i] == "number") {
+		lastNodeIndex = i;
+		break;
+	}
+	if (lastNodeIndex === -1) return [];
+	let result = path.slice(0, lastNodeIndex);
+	return result.length > 0 && typeof result[result.length - 1] == "string" ? result.slice(0, -1) : result;
+}
+function getParent(snapshot, path, options) {
+	if (path.length === 0) return;
+	let parent = parentPath(path);
+	if (parent.length === 0) return;
+	let entry = getNode(snapshot, parent);
+	if (!entry) return;
+	let result = {
+		node: entry.node,
+		path: entry.path
+	};
+	if (!(options?.match && !options.match(result.node, result.path))) return result;
+}
+export { getNodeChildren as a, isTypedObject as c, getChildren as i, serializePath as l, parentPath as n, getContainerChildren as o, getNode as r, isRecord as s, getParent as t, isKeyedSegment as u };
+
+//# sourceMappingURL=get-parent-51Kzgaf9.js.map

package/lib/get-parent-51Kzgaf9.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-parent-51Kzgaf9.js","names":["KeyedSegment","isKeyedSegment","segment","Path","isKeyedSegment","serializePath","path","reduce","result","segment","index","_key","separator","TypedObject","isTypedObject","object","isRecord","value","Record","Node","Containers","RegisteredContainer","getContainerChildren","containers","node","parent","children","Array","container","resolved","resolveNodeContainer","undefined","fieldValue","Record","field","name","isArray","of","entry","type","_type","get","isTextBlock","EditorSchema","Node","Path","serializePath","Containers","RegisteredContainer","isTypedObject","isKeyedSegment","getContainerChildren","TraversalSnapshot","getChildren","snapshot","path","Array","node","currentChildren","context","value","currentFieldName","currentPath","isRoot","currentParent","segment","candidatePath","_key","index","blockIndexMap","get","undefined","find","child","at","next","getNodeChildren","children","fieldName","parent","map","schema","containers","result","container","field","name","isArray","Node","Path","serializePath","RegisteredContainer","isKeyedSegment","getNodeChildren","TraversalSnapshot","getNode","snapshot","path","node","length","undefined","context","blockIndexMap","currentChildren","Array","value","currentFieldName","currentParent","resolvedPath","i","segment","push","j","s","index","get","_key","find","child","at","hasMoreSegments","next","children","fieldName","parent","pop","isKeyedSegment","Path","parentPath","path","length","Error","lastNodeIndex","i","result","slice","PortableTextBlock","Path","parentPath","getNode","TraversalSnapshot","getParent","snapshot","path","options","match","node","TMatch","length","undefined","parent","entry","result"],"sources":["../src/utils/util.is-keyed-segment.ts","../src/paths/serialize-path.ts","../src/utils/asserters.ts","../src/traversal/get-container-children.ts","../src/traversal/get-children.ts","../src/traversal/get-node.ts","../src/engine/path/parent-path.ts","../src/traversal/get-parent.ts"],"sourcesContent":["import type {KeyedSegment} from '../types/paths'\n\n/**\n * @public\n */\nexport function isKeyedSegment(segment: unknown): segment is KeyedSegment {\n  return typeof segment === 'object' && segment !== null && '_key' in segment\n}\n","import type {Path} from '../types/paths'\nimport {isKeyedSegment} from '../utils/util.is-keyed-segment'\n\n/**\n * Serialize a keyed path to a string using Sanity's bracket notation.\n *\n * - `[{_key: 'k0'}]` -> `[_key==\"k0\"]`\n * - `[{_key: 'k0'}, 'children', {_key: 's0'}]` -> `[_key==\"k0\"].children[_key==\"s0\"]`\n * - `[{_key: 't0'}, 'rows', {_key: 'r0'}, 'cells', {_key: 'c0'}, 'content', {_key: 'b0'}, 'children', {_key: 's0'}]` -> `[_key==\"t0\"].rows[_key==\"r0\"].cells[_key==\"c0\"].content[_key==\"b0\"].children[_key==\"s0\"]`\n */\nexport function serializePath(path: Path): string {\n  return path.reduce<string>((result, segment, index) => {\n    if (isKeyedSegment(segment)) {\n      return `${result}[_key==\"${segment._key}\"]`\n    }\n\n    const separator = index === 0 ? '' : '.'\n    return `${result}${separator}${segment}`\n  }, '')\n}\n","import type {TypedObject} from '@portabletext/schema'\n\nexport function isTypedObject(object: unknown): object is TypedObject {\n  return isRecord(object) && typeof object['_type'] === 'string'\n}\n\nexport function isRecord(value: unknown): value is Record<string, unknown> {\n  return !!value && (typeof value === 'object' || typeof value === 'function')\n}\n","import type {Node} from '../engine/interfaces/node'\nimport type {\n  Containers,\n  RegisteredContainer,\n} from '../schema/resolve-containers'\n\n/**\n * Resolve a container node's editable child array.\n *\n * Returns `{children, container}` for a node registered as a container:\n * `children` is the node's editable child array, and `container` is the\n * node's own container registration. Read `container.field.name` for the\n * path segment that reaches `children`, and thread `container` back in as\n * `parent` when descending into them.\n *\n * Returns `undefined` for anything that is not a container: text blocks,\n * spans, leaves, and unregistered objects. It is node-based and resolves\n * in one step with no path re-walk, so recursive descent over containers\n * is linear in nesting depth. The caller seeds the document root from\n * `context.value` itself.\n *\n * @beta\n */\nexport function getContainerChildren(\n  containers: Containers,\n  node: Node,\n  parent?: RegisteredContainer,\n):\n  | {\n      children: Array<Node>\n      container: RegisteredContainer\n    }\n  | undefined {\n  const resolved = resolveNodeContainer(containers, parent, node)\n\n  if (!resolved) {\n    return undefined\n  }\n\n  const fieldValue = (node as Record<string, unknown>)[resolved.field.name]\n\n  if (!Array.isArray(fieldValue)) {\n    return undefined\n  }\n\n  return {\n    children: fieldValue as Array<Node>,\n    container: resolved,\n  }\n}\n\n/**\n * Pick the positional override from `parent.of` if present; fall back\n * to the top-level entry. Returns only `RegisteredContainer` entries\n * since leaves do not have editable children.\n */\nfunction resolveNodeContainer(\n  containers: Containers,\n  parent: RegisteredContainer | undefined,\n  node: Node,\n): RegisteredContainer | undefined {\n  if (parent?.of) {\n    for (const entry of parent.of) {\n      if (entry.type === node._type) {\n        // Only return container entries; leaves have no editable children.\n        if ('field' in entry) {\n          return entry\n        }\n        return undefined\n      }\n    }\n  }\n  return containers.get(node._type)\n}\n","import {isTextBlock} from '@portabletext/schema'\nimport type {EditorSchema} from '../editor/editor-schema'\nimport type {Node} from '../engine/interfaces/node'\nimport type {Path} from '../engine/interfaces/path'\nimport {serializePath} from '../paths/serialize-path'\nimport type {\n  Containers,\n  RegisteredContainer,\n} from '../schema/resolve-containers'\nimport {isTypedObject} from '../utils/asserters'\nimport {isKeyedSegment} from '../utils/util.is-keyed-segment'\nimport {getContainerChildren} from './get-container-children'\nimport type {TraversalSnapshot} from './traversal-snapshot'\n\n/**\n * Get the children of a node at a given path.\n *\n * @beta\n */\nexport function getChildren(\n  snapshot: TraversalSnapshot,\n  path: Path,\n): Array<{node: Node; path: Path}> {\n  let currentChildren: Array<Node> = snapshot.context.value\n  let currentFieldName = 'value'\n  let currentPath: Path = []\n  let isRoot = true\n  let currentParent: RegisteredContainer | undefined\n\n  for (const segment of path) {\n    if (typeof segment === 'string') {\n      continue\n    }\n\n    let node: Node | undefined\n    if (isKeyedSegment(segment)) {\n      // Resolve via `blockIndexMap` (O(1)) and fall back to a linear scan on a\n      // miss or when the snapshot's map disagrees with the value, mirroring\n      // `getNode`. The candidate path is this segment's full keyed path.\n      const candidatePath: Path = isRoot\n        ? [{_key: segment._key}]\n        : [...currentPath, currentFieldName, {_key: segment._key}]\n      const index = snapshot.blockIndexMap.get(serializePath(candidatePath))\n      node =\n        index !== undefined && currentChildren[index]?._key === segment._key\n          ? currentChildren[index]\n          : currentChildren.find((child) => child._key === segment._key)\n    } else if (typeof segment === 'number') {\n      node = currentChildren.at(segment)\n    }\n\n    if (!node) {\n      return []\n    }\n\n    currentPath = isRoot\n      ? [{_key: node._key}]\n      : [...currentPath, currentFieldName, {_key: node._key}]\n    isRoot = false\n\n    const next = getNodeChildren(snapshot.context, node, currentParent)\n\n    if (!next) {\n      return []\n    }\n\n    currentChildren = next.children\n    currentFieldName = next.fieldName\n    currentParent = next.parent\n  }\n\n  return currentChildren.map((child) => ({\n    node: child,\n    path: isRoot\n      ? [{_key: child._key}]\n      : [...currentPath, currentFieldName, {_key: child._key}],\n  }))\n}\n\n/**\n * Resolve a node's editable child array.\n *\n * When `parent` is provided and its `of` declares a positional entry\n * matching `node._type`, that positional entry's `field` is used.\n * Otherwise the top-level `containers.get(node._type)` provides the\n * fallback.\n *\n * The returned `parent` is the resolved container entry for `node`\n * itself (used by the caller to thread further descent).\n *\n * Internal descent kernel shared by the positional traversal utilities\n * (`getChildren`, `getNode`, `getNodes`, `getAncestors`); it folds the\n * text-block, container, and root-document cases. Public consumers that\n * only need to descend containers use {@link getContainerChildren}.\n */\nexport function getNodeChildren(\n  context: {\n    schema: EditorSchema\n    containers: Containers\n  },\n  node: Node | {value: Array<Node>},\n  parent?: RegisteredContainer,\n):\n  | {\n      children: Array<Node>\n      fieldName: string\n      parent: RegisteredContainer | undefined\n    }\n  | undefined {\n  // Text blocks store children in .children\n  if (isTextBlock(context, node)) {\n    return {\n      children: node.children,\n      fieldName: 'children',\n      parent: undefined,\n    }\n  }\n\n  if (isTypedObject(node)) {\n    const result = getContainerChildren(context.containers, node, parent)\n\n    if (result) {\n      return {\n        children: result.children,\n        fieldName: result.container.field.name,\n        parent: result.container,\n      }\n    }\n  }\n\n  // Root context: has .value array but no _key or _type\n  if (\n    'value' in node &&\n    Array.isArray(node['value']) &&\n    !('_key' in node) &&\n    !('_type' in node)\n  ) {\n    return {\n      children: node['value'] as Array<Node>,\n      fieldName: 'value',\n      parent: undefined,\n    }\n  }\n\n  return undefined\n}\n","import type {Node} from '../engine/interfaces/node'\nimport type {Path} from '../engine/interfaces/path'\nimport {serializePath} from '../paths/serialize-path'\nimport type {RegisteredContainer} from '../schema/resolve-containers'\nimport {isKeyedSegment} from '../utils/util.is-keyed-segment'\nimport {getNodeChildren} from './get-children'\nimport type {TraversalSnapshot} from './traversal-snapshot'\n\n/**\n * Get the node at a given path.\n *\n * The path can be either keyed (KeyedSegment + field name strings) or\n * indexed (numbers). Keyed segments are resolved by matching `_key`,\n * field name strings name a structural descent into the previous\n * node's children, and numbers are resolved by index.\n *\n * The returned `path` always identifies the returned node: it's fully\n * keyed (numeric indices are converted to `KeyedSegment`s) and any\n * trailing segments in the input that point outside the value tree —\n * e.g. an object node's primitive field, or an annotation reached via\n * `'markDefs'` on a text block — are stripped so that\n * `getNode(snapshot, entry.path).node === entry.node`.\n *\n * The walk stops when a string segment names a field that isn't the\n * current node's structural child array. Annotations live in\n * `markDefs` on a text block, alongside `children` rather than inside\n * it, so `getNode` resolves an annotation path to the enclosing text\n * block. Use `getAnnotation` to resolve the annotation itself.\n *\n * @beta\n */\nexport function getNode(\n  snapshot: TraversalSnapshot,\n  path: Path,\n): {node: Node; path: Path} | undefined {\n  if (path.length === 0) {\n    return undefined\n  }\n\n  const {context, blockIndexMap} = snapshot\n  let currentChildren: Array<Node> = context.value\n  let currentFieldName: string | undefined\n  let node: Node | undefined\n  let currentParent: RegisteredContainer | undefined\n  const resolvedPath: Path = []\n\n  for (let i = 0; i < path.length; i++) {\n    const segment = path[i]\n\n    if (typeof segment === 'string') {\n      // A string segment names a structural descent. If it matches the\n      // field name produced by the previous node's `getNodeChildren`,\n      // it's part of the value-tree descent — push it and continue.\n      // Otherwise the string names a sidecar field (markDefs on a text\n      // block, a primitive field on an object). If the input keeps\n      // digging past it with more keyed/numeric segments, the caller\n      // wanted a node inside the sidecar and `getNode` can't reach it\n      // (use `getAnnotation` for annotations); return undefined.\n      // Otherwise the rest is just trailing field names — let the loop\n      // exit and the post-loop strip remove them.\n      if (currentFieldName !== undefined && segment === currentFieldName) {\n        resolvedPath.push(segment)\n        continue\n      }\n      for (let j = i + 1; j < path.length; j++) {\n        const s = path[j]\n        if (isKeyedSegment(s) || typeof s === 'number') {\n          return undefined\n        }\n      }\n      break\n    }\n\n    if (isKeyedSegment(segment)) {\n      resolvedPath.push(segment)\n      const index = blockIndexMap.get(serializePath(resolvedPath))\n      if (\n        index !== undefined &&\n        currentChildren[index]?._key === segment._key\n      ) {\n        node = currentChildren[index]\n      } else {\n        // The map can miss (unkeyed transient nodes, e.g. `{_type:'table'}`\n        // inserted by a remote patch before normalize mints a key) or\n        // disagree with the traversed value (snapshots that pair the live\n        // map with a pre-apply value, e.g. `textPatch`). Fall back to a\n        // linear scan in both cases.\n        node = currentChildren.find((child) => child._key === segment._key)\n        if (node && node._key !== undefined) {\n          resolvedPath[resolvedPath.length - 1] = {_key: node._key}\n        }\n      }\n    } else if (typeof segment === 'number') {\n      node = currentChildren.at(segment)\n      if (node) {\n        resolvedPath.push({_key: node._key})\n      }\n    } else {\n      return undefined\n    }\n\n    if (!node) {\n      return undefined\n    }\n\n    let hasMoreSegments = false\n    for (let j = i + 1; j < path.length; j++) {\n      const s = path[j]\n      if (isKeyedSegment(s) || typeof s === 'number') {\n        hasMoreSegments = true\n        break\n      }\n    }\n\n    if (hasMoreSegments) {\n      const next = getNodeChildren(context, node, currentParent)\n\n      if (!next) {\n        return undefined\n      }\n\n      currentChildren = next.children\n      currentFieldName = next.fieldName\n      currentParent = next.parent\n    } else {\n      currentFieldName = undefined\n    }\n  }\n\n  if (!node) {\n    return undefined\n  }\n\n  // Strip trailing field-name segments. The walker may have pushed\n  // matching field names during structural descent; if the deepest\n  // reached keyed segment was the last keyed segment in the input,\n  // any further field names that followed are part of the input but\n  // don't identify the returned node.\n  while (\n    resolvedPath.length > 0 &&\n    typeof resolvedPath[resolvedPath.length - 1] === 'string'\n  ) {\n    resolvedPath.pop()\n  }\n\n  return {node, path: resolvedPath}\n}\n","import {isKeyedSegment} from '../../utils/util.is-keyed-segment'\nimport type {Path} from '../interfaces/path'\n\n/**\n * Get the parent path of a path.\n *\n * Drops the last node segment (keyed or numeric) and the preceding field\n * name string.\n *\n * [{_key:'b1'}, 'children', {_key:'s1'}] → [{_key:'b1'}]\n * [{_key:'b1'}, 'children', 0]           → [{_key:'b1'}]\n * [{_key:'b1'}]                           → []\n */\nexport function parentPath(path: Path): Path {\n  if (path.length === 0) {\n    throw new Error(`Cannot get the parent path of the root path [${path}].`)\n  }\n\n  let lastNodeIndex = -1\n  for (let i = path.length - 1; i >= 0; i--) {\n    if (isKeyedSegment(path[i]) || typeof path[i] === 'number') {\n      lastNodeIndex = i\n      break\n    }\n  }\n\n  if (lastNodeIndex === -1) {\n    return []\n  }\n\n  const result = path.slice(0, lastNodeIndex)\n\n  if (result.length > 0 && typeof result[result.length - 1] === 'string') {\n    return result.slice(0, -1)\n  }\n\n  return result\n}\n","import type {PortableTextBlock} from '@portabletext/schema'\nimport type {Path} from '../engine/interfaces/path'\nimport {parentPath} from '../engine/path/parent-path'\nimport {getNode} from './get-node'\nimport type {TraversalSnapshot} from './traversal-snapshot'\n\n/**\n * Get the parent of a node at a given path.\n *\n * A parent has children, so it is always a `PortableTextBlock` (text block\n * or object node).\n *\n * When `match` is provided and the parent does not satisfy it, returns\n * `undefined`.\n *\n * @beta\n */\nexport function getParent<TMatch extends PortableTextBlock>(\n  snapshot: TraversalSnapshot,\n  path: Path,\n  options: {\n    match: (node: PortableTextBlock, path: Path) => node is TMatch\n  },\n): {node: TMatch; path: Path} | undefined\n/**\n * @beta\n */\nexport function getParent(\n  snapshot: TraversalSnapshot,\n  path: Path,\n  options?: {\n    match?: (node: PortableTextBlock, path: Path) => boolean\n  },\n): {node: PortableTextBlock; path: Path} | undefined\nexport function getParent(\n  snapshot: TraversalSnapshot,\n  path: Path,\n  options?: {\n    match?: (node: PortableTextBlock, path: Path) => boolean\n  },\n): {node: PortableTextBlock; path: Path} | undefined {\n  if (path.length === 0) {\n    return undefined\n  }\n\n  const parent = parentPath(path)\n\n  if (parent.length === 0) {\n    return undefined\n  }\n\n  const entry = getNode(snapshot, parent)\n\n  if (!entry) {\n    return undefined\n  }\n\n  const result = {node: entry.node as PortableTextBlock, path: entry.path}\n\n  if (options?.match && !options.match(result.node, result.path)) {\n    return undefined\n  }\n\n  return result\n}\n"],"mappings":"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"}