@portabletext/editor 6.6.3 → 7.0.0

package/lib/_chunks-es/get-path-sub-schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-path-sub-schema.js","sources":["../../src/slate/node/is-span-node.ts","../../src/slate/node/is-text-block-node.ts","../../src/slate/path/parent-path.ts","../../src/node-traversal/get-parent.ts","../../src/node-traversal/is-block.ts","../../src/node-traversal/has-node.ts","../../src/schema/resolve-container-at.ts","../../src/node-traversal/get-enclosing-block.ts","../../src/slate/path/is-ancestor-path.ts","../../src/node-traversal/get-nodes.ts","../../src/node-traversal/get-sibling.ts","../../src/node-traversal/is-inline.ts","../../src/schema/descend-to-parent.ts","../../src/schema/get-enclosing-container.ts","../../src/traversal/get-path-sub-schema.ts"],"sourcesContent":["import type {EditorSchema} from '../../editor/editor-schema'\nimport {isTypedObject} from '../../utils/asserters'\n\nexport type SpanNode = {\n  _type: string\n  _key: string\n  text?: string\n  marks?: Array<string>\n}\n\n/**\n * Checks if a node is a span based on `_type` alone, without requiring `text`\n * to be present. This is needed to identify spans before normalization has had\n * a chance to add the missing `text` property.\n */\nexport function isSpanNode(\n  context: {schema: EditorSchema},\n  node: unknown,\n): node is SpanNode {\n  return isTypedObject(node) && node._type === context.schema.span.name\n}\n","import type {PortableTextObject, PortableTextSpan} from '@portabletext/schema'\nimport type {EditorSchema} from '../../editor/editor-schema'\nimport {isTypedObject} from '../../utils/asserters'\n\ntype TextBlockNode = {\n  _type: string\n  _key: string\n  children?: Array<PortableTextSpan | PortableTextObject>\n  markDefs?: Array<PortableTextObject>\n  style?: string\n  listItem?: string\n  level?: number\n}\n\n/**\n * Checks if a node is a text block based on `_type` alone, without requiring\n * `children` to be present. This is needed to identify text blocks before\n * normalization has had a chance to add the missing `children` property.\n */\nexport function isTextBlockNode(\n  context: {schema: EditorSchema},\n  node: unknown,\n): node is TextBlockNode {\n  return isTypedObject(node) && node._type === context.schema.block.name\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 {Node} from '../slate/interfaces/node'\nimport type {Path} from '../slate/interfaces/path'\nimport {parentPath} from '../slate/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 * @beta\n */\nexport function getParent(\n  snapshot: TraversalSnapshot,\n  path: Path,\n): {node: Node; 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  return getNode(snapshot, parent)\n}\n","import type {PortableTextBlock} from '@portabletext/schema'\nimport type {Path} from '../slate/interfaces/path'\nimport {isSpanNode} from '../slate/node/is-span-node'\nimport {isTextBlockNode} from '../slate/node/is-text-block-node'\nimport {getNode} from './get-node'\nimport {getParent} from './get-parent'\nimport type {TraversalSnapshot} from './traversal-snapshot'\n\n/**\n * Determine if a node at the given path is a block.\n *\n * A node is a block if its parent is not a text block. Top-level nodes\n * (direct children of the editor) are always blocks. Children of text blocks\n * (spans and inline objects) are not blocks. Children of containers are\n * blocks within that container.\n *\n * @beta\n */\nexport function isBlock(snapshot: TraversalSnapshot, path: Path): boolean {\n  const parent = getParent(snapshot, path)\n\n  if (!parent) {\n    return true\n  }\n\n  return !isTextBlockNode({schema: snapshot.context.schema}, parent.node)\n}\n\n/**\n * Get the node at the given path if it is a block.\n *\n * Returns the node narrowed to PortableTextBlock, or undefined if the node\n * doesn't exist or is not a block.\n *\n * @beta\n */\nexport function getBlock(\n  snapshot: TraversalSnapshot,\n  path: Path,\n): {node: PortableTextBlock; path: Path} | undefined {\n  const entry = getNode(snapshot, path)\n\n  if (!entry) {\n    return undefined\n  }\n\n  if (!isBlock(snapshot, path)) {\n    return undefined\n  }\n\n  // Narrow the type: a block is never a span (spans always have a text block\n  // parent, so isBlock returns false for them).\n  if (isSpanNode({schema: snapshot.context.schema}, entry.node)) {\n    return undefined\n  }\n\n  // Node minus PortableTextSpan = PortableTextTextBlock | PortableTextObject = PortableTextBlock\n  return {node: entry.node, path: entry.path}\n}\n","import type {Path} from '../slate/interfaces/path'\nimport {getNode} from './get-node'\nimport type {TraversalSnapshot} from './traversal-snapshot'\n\n/**\n * Check if a node exists at a given path.\n *\n * @beta\n */\nexport function hasNode(snapshot: TraversalSnapshot, path: Path): boolean {\n  return getNode(snapshot, path) !== undefined\n}\n","import type {Node} from '../slate/interfaces/node'\nimport type {Path} from '../slate/interfaces/path'\nimport {isKeyedSegment} from '../utils/util.is-keyed-segment'\nimport type {\n  Containers,\n  RegisteredContainer,\n  RegisteredPositional,\n} from './container-types'\n\n/**\n * Walk the editor value following `path` and return the\n * {@link RegisteredContainer} or {@link RegisteredPositional} that applies\n * at `path`'s target position.\n *\n * Resolution rules at each step:\n *\n * 1. **Positional override.** If the current parent declares the\n *    child's `_type` in its `of`, the positional entry wins.\n *    Used to resolve same-`_type` registered under different\n *    parents with different `field` values.\n *\n * 2. **Global fallback.** If the parent has no positional override,\n *    fall back to the top-level entry for `_type` in\n *    `containers`.\n *\n * 3. **Chain validity.** If any ancestor along the path has no\n *    resolved container entry (unregistered or not reachable as a\n *    container at its position), return `undefined`.\n *\n * Returns `undefined` when the target's `_type` is not registered\n * at this position. Returns a {@link RegisteredPositional} when the target\n * resolves to a leaf in a positional `of` (terminal node with no\n * editable children).\n *\n * @alpha\n */\nexport function resolveContainerAt(\n  containers: Containers,\n  value: ReadonlyArray<Node>,\n  path: Path,\n): RegisteredContainer | RegisteredPositional | undefined {\n  const keyedIndices: Array<number> = []\n  for (let index = 0; index < path.length; index++) {\n    if (isKeyedSegment(path[index])) {\n      keyedIndices.push(index)\n    }\n  }\n  if (keyedIndices.length === 0) {\n    return undefined\n  }\n\n  let currentChildren: ReadonlyArray<Node> = value\n  let parent: RegisteredContainer | undefined\n  let resolved: RegisteredContainer | RegisteredPositional | undefined\n  const targetKeyedIndex = keyedIndices[keyedIndices.length - 1]!\n\n  let segmentIndex = 0\n  while (segmentIndex <= targetKeyedIndex) {\n    const segment = path[segmentIndex]!\n    if (typeof segment === 'string') {\n      segmentIndex++\n      continue\n    }\n\n    let node: Node | undefined\n    if (isKeyedSegment(segment)) {\n      node = currentChildren.find((child) => child._key === segment._key)\n    } else if (typeof segment === 'number') {\n      node = currentChildren.at(segment)\n    } else {\n      return undefined\n    }\n    if (!node) {\n      return undefined\n    }\n\n    resolved = resolveNodeEntry(containers, parent, node)\n    if (!resolved) {\n      return undefined\n    }\n\n    if (segmentIndex < targetKeyedIndex) {\n      // Walk one more level. The resolved entry must be a container\n      // (have children) for descent to continue.\n      if (!('field' in resolved)) {\n        return undefined\n      }\n      const fieldValue = (node as Record<string, unknown>)[resolved.field.name]\n      if (!Array.isArray(fieldValue)) {\n        return undefined\n      }\n      parent = resolved\n      currentChildren = fieldValue as Array<Node>\n    }\n    segmentIndex++\n  }\n\n  return resolved\n}\n\nfunction resolveNodeEntry(\n  containers: Containers,\n  parent: RegisteredContainer | undefined,\n  node: Node,\n): RegisteredContainer | RegisteredPositional | undefined {\n  if (parent?.of) {\n    for (const entry of parent.of) {\n      if (entry.type === node._type) {\n        return entry\n      }\n    }\n  }\n  return containers.get(node._type)\n}\n","import type {PortableTextBlock} from '@portabletext/schema'\nimport type {Path} from '../slate/interfaces/path'\nimport {getAncestors} from './get-ancestors'\nimport {getBlock, isBlock} from './is-block'\nimport type {TraversalSnapshot} from './traversal-snapshot'\n\n/**\n * Walk up from a path to find the nearest enclosing block.\n *\n * Returns the node at the path if it is a block, otherwise the first ancestor\n * that is a block. Works at any depth — inside a container this returns the\n * container-internal block, not the outer container.\n *\n * @beta\n */\nexport function getEnclosingBlock(\n  snapshot: TraversalSnapshot,\n  path: Path,\n): {node: PortableTextBlock; path: Path} | undefined {\n  const direct = getBlock(snapshot, path)\n\n  if (direct) {\n    return direct\n  }\n\n  for (const ancestor of getAncestors(snapshot, path)) {\n    if (isBlock(snapshot, ancestor.path)) {\n      const block = getBlock(snapshot, ancestor.path)\n\n      if (block) {\n        return block\n      }\n    }\n  }\n\n  return undefined\n}\n","import {isKeyedSegment} from '../../utils/util.is-keyed-segment'\nimport type {Path} from '../interfaces/path'\n\nexport function isAncestorPath(path: Path, another: Path): boolean {\n  if (path.length >= another.length) {\n    return false\n  }\n\n  for (let i = 0; i < path.length; i++) {\n    const segment = path[i]\n    const otherSegment = another[i]\n\n    if (isKeyedSegment(segment) && isKeyedSegment(otherSegment)) {\n      if (segment._key !== otherSegment._key) {\n        return false\n      }\n    } else if (segment !== otherSegment) {\n      return false\n    }\n  }\n\n  return true\n}\n","import type {EditorSchema} from '../editor/editor-schema'\nimport type {\n  Containers,\n  RegisteredContainer,\n} from '../schema/resolve-containers'\nimport type {Node} from '../slate/interfaces/node'\nimport type {Path} from '../slate/interfaces/path'\nimport {isAncestorPath} from '../slate/path/is-ancestor-path'\nimport {isKeyedSegment} from '../utils/util.is-keyed-segment'\nimport {getChildren, getNodeChildren} from './get-children'\nimport type {TraversalSnapshot} from './traversal-snapshot'\n\n/**\n * Get the descendant nodes of the node at a given path.\n *\n * When `from` and `to` are provided, performs a range-bounded DFS traversal,\n * yielding only nodes between `from` and `to` (inclusive). Both paths are\n * always in document order: `from` is the earlier path, `to` is the later\n * path. The `reverse` flag controls iteration direction within that range.\n *\n * When `match` is provided, only yields nodes where the predicate returns true.\n * The traversal still visits all nodes in range - `match` is a filter, not a\n * traversal control.\n *\n * When `at` is provided, traverses descendants of the node at that path\n * instead of the root.\n */\nexport function* getNodes(\n  snapshot: TraversalSnapshot,\n  options: {\n    at?: Path\n    from?: Path\n    to?: Path\n    match?: (node: Node, path: Path) => boolean\n    reverse?: boolean\n  } = {},\n): Generator<{node: Node; path: Path}, void, undefined> {\n  const {at = [], from, to, match, reverse = false} = options\n\n  if (from === undefined && to === undefined) {\n    yield* getNodesSimple(snapshot, at, {match, reverse})\n    return\n  }\n\n  yield* getNodesInRange(snapshot, at, {from, to, match, reverse})\n}\n\n/**\n * Get descendant nodes of a standalone node (not in the editor tree).\n * Used for cases like getDirtyPaths where the node hasn't been inserted yet.\n */\nexport function* getNodeDescendants(\n  context: {\n    schema: EditorSchema\n    containers: Containers\n  },\n  node: Node | {value: Array<Node>},\n): Generator<{node: Node; path: Path}, void, undefined> {\n  // The editor root wrapper ({value: [...]}) is not a real node, so its field\n  // name is not part of paths. For standalone nodes (a real {_key, _type, ...}\n  // passed in by callers like getDirtyPaths), the field name IS part of the\n  // path.\n  const isRoot = !('_key' in node) && !('_type' in node)\n  yield* walkStandalone(context, node, [], isRoot)\n}\n\nfunction* walkStandalone(\n  context: {\n    schema: EditorSchema\n    containers: Containers\n  },\n  node: Node | {value: Array<Node>},\n  path: Path,\n  isRoot: boolean,\n  parent?: RegisteredContainer,\n): Generator<{node: Node; path: Path}, void, undefined> {\n  const next = getNodeChildren(context, node, parent)\n  if (!next) {\n    return\n  }\n\n  for (const child of next.children) {\n    const childPath: Path = isRoot\n      ? [{_key: child._key}]\n      : [...path, next.fieldName, {_key: child._key}]\n    yield {node: child, path: childPath}\n    yield* walkStandalone(context, child, childPath, false, next.parent)\n  }\n}\n\n/**\n * Simple recursive DFS - the original behavior.\n * Yields all descendants of the node at `path`.\n */\nfunction* getNodesSimple(\n  snapshot: TraversalSnapshot,\n  path: Path,\n  options: {\n    match?: (node: Node, path: Path) => boolean\n    reverse?: boolean\n  },\n): Generator<{node: Node; path: Path}, void, undefined> {\n  const {match, reverse = false} = options\n\n  const children = getChildren(snapshot, path)\n\n  const entries = reverse ? [...children].reverse() : children\n\n  for (const entry of entries) {\n    if (!match || match(entry.node, entry.path)) {\n      yield entry\n    }\n\n    yield* getNodesSimple(snapshot, entry.path, options)\n  }\n}\n\n/**\n * Compare two keyed paths in document order. Returns -1, 0, or 1.\n *\n * Descends both paths from the root in a single pass, advancing\n * `currentNode` and `currentChildren` together so each level costs\n * one keyed-segment scan instead of an O(depth) walk from root.\n *\n * Uses `blockIndexMap` for O(1) lookup at the root level. Deeper\n * levels fall back to a linear scan of the current sibling array.\n */\nfunction comparePathsInTree(\n  snapshot: TraversalSnapshot,\n  pathA: Path,\n  pathB: Path,\n): -1 | 0 | 1 {\n  const keysA = pathA.filter(isKeyedSegment)\n  const keysB = pathB.filter(isKeyedSegment)\n\n  const {context} = snapshot\n  let currentChildren: Array<Node> = context.value\n  let currentParent: RegisteredContainer | undefined\n  let isRootLevel = true\n\n  const minDepth = Math.min(keysA.length, keysB.length)\n\n  for (let depth = 0; depth < minDepth; depth++) {\n    const keyA = keysA[depth]!\n    const keyB = keysB[depth]!\n\n    if (keyA._key === keyB._key) {\n      // Same node at this depth: descend into its children for the next\n      // iteration. The root level can short-circuit via blockIndexMap;\n      // deeper levels scan the current sibling array.\n      let matchedNode: Node | undefined\n      if (isRootLevel && snapshot.blockIndexMap.has(keyA._key)) {\n        const index = snapshot.blockIndexMap.get(keyA._key)\n        if (index !== undefined) {\n          matchedNode = currentChildren[index]\n        }\n      } else {\n        matchedNode = currentChildren.find((c) => c._key === keyA._key)\n      }\n      if (!matchedNode) {\n        return 0\n      }\n      const next = getNodeChildren(context, matchedNode, currentParent)\n      if (!next) {\n        return 0\n      }\n      currentChildren = next.children\n      currentParent = next.parent\n\n      isRootLevel = false\n      continue\n    }\n\n    if (isRootLevel) {\n      const indexA = snapshot.blockIndexMap.get(keyA._key) ?? -1\n      const indexB = snapshot.blockIndexMap.get(keyB._key) ?? -1\n      if (indexA !== -1 && indexB !== -1) {\n        if (indexA < indexB) {\n          return -1\n        }\n        if (indexA > indexB) {\n          return 1\n        }\n        return 0\n      }\n    }\n\n    let indexA = -1\n    let indexB = -1\n    for (let i = 0; i < currentChildren.length; i++) {\n      const sibling = currentChildren[i]!\n      if (sibling._key === keyA._key) {\n        indexA = i\n      }\n      if (sibling._key === keyB._key) {\n        indexB = i\n      }\n      if (indexA !== -1 && indexB !== -1) {\n        break\n      }\n    }\n\n    if (indexA < indexB) {\n      return -1\n    }\n    if (indexA > indexB) {\n      return 1\n    }\n\n    return 0\n  }\n\n  // One path is a prefix of the other (ancestor relationship)\n  // In DFS order, shorter path (ancestor) comes first\n  if (keysA.length < keysB.length) {\n    return -1\n  }\n  if (keysA.length > keysB.length) {\n    return 1\n  }\n\n  return 0\n}\n\n/**\n * Range-bounded recursive DFS traversal.\n *\n * `from` and `to` are always in document order (from is earlier, to is\n * later), regardless of traversal direction.\n */\nfunction* getNodesInRange(\n  snapshot: TraversalSnapshot,\n  path: Path,\n  options: {\n    from?: Path\n    to?: Path\n    match?: (node: Node, path: Path) => boolean\n    reverse?: boolean\n  },\n): Generator<{node: Node; path: Path}, void, undefined> {\n  const {from, to, match, reverse = false} = options\n\n  const children = getChildren(snapshot, path)\n  const entries = reverse ? [...children].reverse() : children\n\n  for (const entry of entries) {\n    if (canStopTraversal(snapshot, entry.path, from, to, reverse)) {\n      return\n    }\n\n    if (!couldContainInRangeNodes(snapshot, entry.path, from, to)) {\n      continue\n    }\n\n    if (isInRange(snapshot, entry.path, from, to)) {\n      if (!match || match(entry.node, entry.path)) {\n        yield entry\n      }\n    }\n\n    yield* getNodesInRange(snapshot, entry.path, options)\n  }\n}\n\n/**\n * Check if a node is within the [from, to] range in document order.\n * Both bounds are inclusive. Ancestor nodes of from or to are also\n * considered in range since they contain the range boundary.\n */\nfunction isInRange(\n  snapshot: TraversalSnapshot,\n  nodePath: Path,\n  from: Path | undefined,\n  to: Path | undefined,\n): boolean {\n  if (\n    from !== undefined &&\n    comparePathsInTree(snapshot, nodePath, from) === -1\n  ) {\n    if (!isAncestorPath(nodePath, from)) {\n      return false\n    }\n  }\n\n  if (to !== undefined && comparePathsInTree(snapshot, nodePath, to) === 1) {\n    if (!isAncestorPath(nodePath, to)) {\n      return false\n    }\n  }\n\n  return true\n}\n\n/**\n * Check if a subtree rooted at `nodePath` could contain any nodes in the\n * [from, to] range.\n */\nfunction couldContainInRangeNodes(\n  snapshot: TraversalSnapshot,\n  nodePath: Path,\n  from: Path | undefined,\n  to: Path | undefined,\n): boolean {\n  if (isInRange(snapshot, nodePath, from, to)) {\n    return true\n  }\n\n  if (from !== undefined && isAncestorPath(nodePath, from)) {\n    return true\n  }\n\n  if (to !== undefined && isAncestorPath(nodePath, to)) {\n    return true\n  }\n\n  return false\n}\n\n/**\n * Check if all remaining nodes in iteration order will be outside the range.\n */\nfunction canStopTraversal(\n  snapshot: TraversalSnapshot,\n  nodePath: Path,\n  from: Path | undefined,\n  to: Path | undefined,\n  reverse: boolean,\n): boolean {\n  if (reverse) {\n    if (from === undefined) {\n      return false\n    }\n\n    return (\n      comparePathsInTree(snapshot, nodePath, from) === -1 &&\n      !isAncestorPath(nodePath, from)\n    )\n  }\n\n  if (to === undefined) {\n    return false\n  }\n\n  return comparePathsInTree(snapshot, nodePath, to) === 1\n}\n","import type {Node} from '../slate/interfaces/node'\nimport type {Path} from '../slate/interfaces/path'\nimport {parentPath} from '../slate/path/parent-path'\nimport {isKeyedSegment} from '../utils/util.is-keyed-segment'\nimport {getChildren} from './get-children'\nimport type {TraversalSnapshot} from './traversal-snapshot'\n\n/**\n * Get the next or previous sibling of the node at a given path.\n *\n * @beta\n */\nexport function getSibling(\n  snapshot: TraversalSnapshot,\n  path: Path,\n  direction: 'next' | 'previous',\n): {node: Node; path: Path} | undefined {\n  if (path.length === 0) {\n    return undefined\n  }\n\n  const lastSegment = path.at(-1)\n\n  if (!isKeyedSegment(lastSegment)) {\n    return undefined\n  }\n\n  const parent = parentPath(path)\n  const children = getChildren(snapshot, parent)\n\n  const currentIndex = children.findIndex(\n    (child) => child.node._key === lastSegment._key,\n  )\n\n  if (currentIndex === -1) {\n    return undefined\n  }\n\n  const siblingIndex =\n    direction === 'next' ? currentIndex + 1 : currentIndex - 1\n\n  if (siblingIndex < 0 || siblingIndex >= children.length) {\n    return undefined\n  }\n\n  return children[siblingIndex]\n}\n","import type {Path} from '../slate/interfaces/path'\nimport {isBlock} from './is-block'\nimport type {TraversalSnapshot} from './traversal-snapshot'\n\n/**\n * Determine if a node at the given path is inline.\n *\n * A node is inline if its parent is a text block. This is the inverse of\n * `isBlock`. Top-level nodes are never inline.\n *\n * @beta\n */\nexport function isInline(snapshot: TraversalSnapshot, path: Path): boolean {\n  return !isBlock(snapshot, path)\n}\n","import {getAncestors} from '../node-traversal/get-ancestors'\nimport type {TraversalSnapshot} from '../node-traversal/traversal-snapshot'\nimport type {Path} from '../slate/interfaces/path'\nimport {isObjectNode} from '../slate/node/is-object-node'\nimport type {RegisteredContainer} from './container-types'\nimport {resolveContainerAt} from './resolve-container-at'\n\n/**\n * Descent primitive: return the immediate parent\n * {@link RegisteredContainer} of the node at `path` (and that parent's\n * path), or `undefined` when the target's immediate parent is the\n * editor root, when no object-node ancestor is a registered container,\n * or when descent hits an ancestor whose `_type` is not registered.\n *\n * Walks ancestors and resolves each object-node ancestor positionally\n * via {@link resolveContainerAt}. Text-block and span ancestors are\n * skipped - \"container\" here means the enclosing object container,\n * not the text-block holding spans.\n */\nexport function descendToParent(\n  snapshot: TraversalSnapshot,\n  path: Path,\n): {parent: RegisteredContainer; parentPath: Path} | undefined {\n  const ancestors = getAncestors(snapshot, path)\n  for (const ancestor of ancestors) {\n    if (!isObjectNode({schema: snapshot.context.schema}, ancestor.node)) {\n      continue\n    }\n    const resolved = resolveContainerAt(\n      snapshot.context.containers,\n      snapshot.context.value,\n      ancestor.path,\n    )\n    if (!resolved || !('field' in resolved)) {\n      return undefined\n    }\n    return {parent: resolved, parentPath: ancestor.path}\n  }\n  return undefined\n}\n","import type {OfDefinition} from '@portabletext/schema'\nimport type {TraversalSnapshot} from '../node-traversal/traversal-snapshot'\nimport type {Path} from '../slate/interfaces/path'\nimport {descendToParent} from './descend-to-parent'\n\n/**\n * Return the immediate registered-container ancestor of `path` along\n * with its `of` array (the schema definitions accepted at this position).\n *\n * Position-aware: nested-only registrations (e.g. `cell` registered\n * only inside `table.row.of`) are recognized via the same descent\n * primitive used by all parent-aware traversal.\n *\n * Returns `undefined` when `path` has no registered-container ancestor\n * (i.e. is at the document root) or when descent hits a leaf-resolved\n * ancestor.\n */\nexport function getEnclosingContainer(\n  snapshot: TraversalSnapshot,\n  path: Path,\n):\n  | {\n      of: ReadonlyArray<OfDefinition>\n      path: Path\n    }\n  | undefined {\n  const descent = descendToParent(snapshot, path)\n  if (!descent) {\n    return undefined\n  }\n  return {\n    of: descent.parent.field.of,\n    path: descent.parentPath,\n  }\n}\n","import {getSubSchema, type Schema} from '@portabletext/schema'\nimport type {TraversalSnapshot} from '../node-traversal/traversal-snapshot'\nimport {getEnclosingContainer} from '../schema/get-enclosing-container'\nimport type {Path} from '../slate/interfaces/path'\n\n/**\n * Return the `Schema` view that applies at a given path.\n *\n * For paths at the root of the document, or for paths where no ancestor is\n * a registered container, returns the top-level schema. For paths inside a\n * container, walks ancestors to find the nearest container and returns the\n * sub-schema derived from its `of` declaration.\n *\n * @beta\n */\nexport function getPathSubSchema(\n  snapshot: TraversalSnapshot,\n  path: Path,\n): Schema {\n  const enclosing = getEnclosingContainer(snapshot, path)\n\n  if (!enclosing) {\n    return snapshot.context.schema\n  }\n\n  return getSubSchema(snapshot.context.schema, enclosing.of)\n}\n"],"names":["isSpanNode","context","node","isTypedObject","_type","schema","span","name","isTextBlockNode","block","parentPath","path","length","Error","lastNodeIndex","i","isKeyedSegment","result","slice","getParent","snapshot","parent","getNode","isBlock","getBlock","entry","hasNode","undefined","resolveContainerAt","containers","value","keyedIndices","index","push","currentChildren","resolved","targetKeyedIndex","segmentIndex","segment","find","child","_key","at","resolveNodeEntry","fieldValue","field","Array","isArray","of","type","get","getEnclosingBlock","direct","ancestor","getAncestors","isAncestorPath","another","otherSegment","getNodes","options","from","to","match","reverse","getNodesSimple","getNodesInRange","children","getChildren","entries","comparePathsInTree","pathA","pathB","keysA","filter","keysB","currentParent","isRootLevel","minDepth","Math","min","depth","keyA","keyB","matchedNode","blockIndexMap","has","c","next","getNodeChildren","indexA","indexB","sibling","canStopTraversal","couldContainInRangeNodes","isInRange","nodePath","getSibling","direction","lastSegment","currentIndex","findIndex","siblingIndex","isInline","descendToParent","ancestors","isObjectNode","getEnclosingContainer","descent","getPathSubSchema","enclosing","getSubSchema"],"mappings":"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"}