@portabletext/editor 7.10.15 → 7.10.17

package/lib/behavior.types.behavior-B_77VtQR.js

@@ -0,0 +1,159 @@
+/**
+* Directly executes an event, bypassing all Behavior matching.
+*
+* Use `execute` when you want to perform an action without triggering any
+* Behaviors. The event is executed immediately as a direct operation.
+*
+* @example
+* ```ts
+* defineBehavior({
+*   on: 'insert.text',
+*   guard: ({event}) => event.text === 'a',
+*   actions: [() => [execute({type: 'insert.text', text: 'b'})]],
+* })
+* ```
+*
+* @beta
+*/
+function execute(event) {
+	return {
+		type: "execute",
+		event
+	};
+}
+/**
+* Forwards an event to the next Behavior(s) in the current chain.
+*
+* Use `forward` to pass an event to succeeding Behaviors without starting a
+* fresh lookup. This is useful for intercepting events, performing side
+* effects, and then letting the default handling continue.
+*
+* **Key rule:** When forwarding to a different event type, only Behaviors that
+* were already in the remaining chain AND match the new type will run. This
+* means cross-type `forward` is mostly useful for falling through to default
+* Behaviors, not for triggering user-defined Behaviors of a different type.
+*
+* To trigger all Behaviors for a different event type, use {@link raise}
+* instead.
+*
+* @example
+* ```ts
+* // Intercept and forward same event type
+* defineBehavior({
+*   on: 'insert.text',
+*   actions: [({event}) => [effect(logEvent), forward(event)]],
+* })
+*
+* // Forward to default handling of different event type
+* defineBehavior({
+*   on: 'clipboard.paste',
+*   actions: [
+*     ({event}) => {
+*       const text = event.originEvent.dataTransfer?.getData('text/plain')
+*       return text ? [forward({type: 'insert.text', text})] : []
+*     },
+*   ],
+* })
+* ```
+*
+* @beta
+*/
+function forward(event) {
+	return {
+		type: "forward",
+		event
+	};
+}
+/**
+* Raises an event, triggering a fresh lookup of all Behaviors.
+*
+* Use `raise` when you want to trigger an event "from scratch", including all
+* Behaviors that match the event type. This is the appropriate action when you
+* want to trigger Behaviors for a different event type.
+*
+* If no Behavior matches the raised event, synthetic events will fall through
+* to their default operation.
+*
+* @example
+* ```ts
+* // Raise a custom event that triggers other Behaviors
+* defineBehavior({
+*   on: 'insert.text',
+*   guard: ({event}) => event.text === 'a',
+*   actions: [() => [raise({type: 'custom.specialInsert'})]],
+* })
+*
+* // Raise a different event type (fresh lookup includes all Behaviors)
+* defineBehavior({
+*   on: 'clipboard.paste',
+*   actions: [
+*     ({event}) => {
+*       const text = event.originEvent.dataTransfer?.getData('text/plain')
+*       return text ? [raise({type: 'insert.text', text})] : []
+*     },
+*   ],
+* })
+* ```
+*
+* @beta
+*/
+function raise(event) {
+	return {
+		type: "raise",
+		event
+	};
+}
+/**
+* Performs a side effect.
+*
+* Use `effect` for logging, analytics, async operations, or other side effects.
+*
+* **Note:** Using `effect` alone (without `forward`) will stop event
+* propagation. To perform a side effect while allowing the default Behavior
+* to continue, combine `effect` with `forward`.
+*
+* The effect callback receives a `send` function that can be used to send
+* events back to the editor asynchronously.
+*
+* @example
+* ```ts
+* // Log events while preserving default Behavior
+* defineBehavior({
+*   on: 'insert.text',
+*   actions: [({event}) => [effect(() => console.log(event)), forward(event)]],
+* })
+*
+* // Effect alone stops propagation (native event is cancelled)
+* defineBehavior({
+*   on: 'keyboard.keydown',
+*   actions: [() => [effect(() => console.log('key pressed'))]],
+* })
+*
+* // Async effect that sends an event later
+* defineBehavior({
+*   on: 'custom.save',
+*   actions: [
+*     () => [
+*       effect(async ({send}) => {
+*         await saveDocument()
+*         send({type: 'custom.saved'})
+*       }),
+*     ],
+*   ],
+* })
+* ```
+*
+* @beta
+*/
+function effect(effect) {
+	return {
+		type: "effect",
+		effect
+	};
+}
+function defineBehavior(behavior) {
+	return behavior;
+}
+export { raise as a, forward as i, effect as n, execute as r, defineBehavior as t };
+
+//# sourceMappingURL=behavior.types.behavior-B_77VtQR.js.map

package/lib/behavior.types.behavior-B_77VtQR.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"behavior.types.behavior-B_77VtQR.js","names":["EditorDom","EditorSnapshot","PickFromUnion","CustomBehaviorEvent","ExternalBehaviorEvent","NativeBehaviorEvent","SyntheticBehaviorEvent","BehaviorAction","type","event","effect","payload","send","execute","forward","raise","BehaviorActionSet","snapshot","TBehaviorEvent","dom","guardResponse","TGuardResponse","Array","BehaviorActionSet","BehaviorEvent","BehaviorEventTypeNamespace","CustomBehaviorEvent","ResolveBehaviorEvent","BehaviorGuard","Behavior","TBehaviorEventType","on","guard","TBehaviorEvent","TGuardResponse","actions","Array","defineBehavior","Record","behavior","TPayload"],"sources":["../src/behaviors/behavior.types.action.ts","../src/behaviors/behavior.types.behavior.ts"],"sourcesContent":["import type {EditorDom} from '../editor/editor-dom'\nimport type {EditorSnapshot} from '../editor/editor-snapshot'\nimport type {PickFromUnion} from '../type-utils'\nimport type {\n  CustomBehaviorEvent,\n  ExternalBehaviorEvent,\n  NativeBehaviorEvent,\n  SyntheticBehaviorEvent,\n} from './behavior.types.event'\n\n/**\n * @beta\n */\nexport type BehaviorAction =\n  | {\n      type: 'execute'\n      event: SyntheticBehaviorEvent\n    }\n  | {\n      type: 'forward'\n      event: NativeBehaviorEvent | SyntheticBehaviorEvent | CustomBehaviorEvent\n    }\n  | {\n      type: 'raise'\n      event: SyntheticBehaviorEvent | CustomBehaviorEvent\n    }\n  | {\n      type: 'effect'\n      effect: (payload: {\n        /**\n         * Send a Behavior Event back into the Editor.\n         *\n         * @example\n         * ```ts\n         * defineBehavior({\n         *   on: '...',\n         *   actions: [\n         *     () => [\n         *       effect(({send}) => {\n         *         doSomethingAsync()\n         *           .then(() => {\n         *             send({\n         *               type: '...',\n         *             })\n         *           })\n         *       })\n         *     ],\n         *   ],\n         * })\n         * ```\n         */\n        send: (event: ExternalBehaviorEvent) => void\n      }) => void\n    }\n\n/**\n * Directly executes an event, bypassing all Behavior matching.\n *\n * Use `execute` when you want to perform an action without triggering any\n * Behaviors. The event is executed immediately as a direct operation.\n *\n * @example\n * ```ts\n * defineBehavior({\n *   on: 'insert.text',\n *   guard: ({event}) => event.text === 'a',\n *   actions: [() => [execute({type: 'insert.text', text: 'b'})]],\n * })\n * ```\n *\n * @beta\n */\nexport function execute(\n  event: SyntheticBehaviorEvent,\n): PickFromUnion<BehaviorAction, 'type', 'execute'> {\n  return {type: 'execute', event}\n}\n\n/**\n * Forwards an event to the next Behavior(s) in the current chain.\n *\n * Use `forward` to pass an event to succeeding Behaviors without starting a\n * fresh lookup. This is useful for intercepting events, performing side\n * effects, and then letting the default handling continue.\n *\n * **Key rule:** When forwarding to a different event type, only Behaviors that\n * were already in the remaining chain AND match the new type will run. This\n * means cross-type `forward` is mostly useful for falling through to default\n * Behaviors, not for triggering user-defined Behaviors of a different type.\n *\n * To trigger all Behaviors for a different event type, use {@link raise}\n * instead.\n *\n * @example\n * ```ts\n * // Intercept and forward same event type\n * defineBehavior({\n *   on: 'insert.text',\n *   actions: [({event}) => [effect(logEvent), forward(event)]],\n * })\n *\n * // Forward to default handling of different event type\n * defineBehavior({\n *   on: 'clipboard.paste',\n *   actions: [\n *     ({event}) => {\n *       const text = event.originEvent.dataTransfer?.getData('text/plain')\n *       return text ? [forward({type: 'insert.text', text})] : []\n *     },\n *   ],\n * })\n * ```\n *\n * @beta\n */\nexport function forward(\n  event: NativeBehaviorEvent | SyntheticBehaviorEvent | CustomBehaviorEvent,\n): PickFromUnion<BehaviorAction, 'type', 'forward'> {\n  return {type: 'forward', event}\n}\n\n/**\n * Raises an event, triggering a fresh lookup of all Behaviors.\n *\n * Use `raise` when you want to trigger an event \"from scratch\", including all\n * Behaviors that match the event type. This is the appropriate action when you\n * want to trigger Behaviors for a different event type.\n *\n * If no Behavior matches the raised event, synthetic events will fall through\n * to their default operation.\n *\n * @example\n * ```ts\n * // Raise a custom event that triggers other Behaviors\n * defineBehavior({\n *   on: 'insert.text',\n *   guard: ({event}) => event.text === 'a',\n *   actions: [() => [raise({type: 'custom.specialInsert'})]],\n * })\n *\n * // Raise a different event type (fresh lookup includes all Behaviors)\n * defineBehavior({\n *   on: 'clipboard.paste',\n *   actions: [\n *     ({event}) => {\n *       const text = event.originEvent.dataTransfer?.getData('text/plain')\n *       return text ? [raise({type: 'insert.text', text})] : []\n *     },\n *   ],\n * })\n * ```\n *\n * @beta\n */\nexport function raise(\n  event: SyntheticBehaviorEvent | CustomBehaviorEvent,\n): PickFromUnion<BehaviorAction, 'type', 'raise'> {\n  return {type: 'raise', event}\n}\n\n/**\n * Performs a side effect.\n *\n * Use `effect` for logging, analytics, async operations, or other side effects.\n *\n * **Note:** Using `effect` alone (without `forward`) will stop event\n * propagation. To perform a side effect while allowing the default Behavior\n * to continue, combine `effect` with `forward`.\n *\n * The effect callback receives a `send` function that can be used to send\n * events back to the editor asynchronously.\n *\n * @example\n * ```ts\n * // Log events while preserving default Behavior\n * defineBehavior({\n *   on: 'insert.text',\n *   actions: [({event}) => [effect(() => console.log(event)), forward(event)]],\n * })\n *\n * // Effect alone stops propagation (native event is cancelled)\n * defineBehavior({\n *   on: 'keyboard.keydown',\n *   actions: [() => [effect(() => console.log('key pressed'))]],\n * })\n *\n * // Async effect that sends an event later\n * defineBehavior({\n *   on: 'custom.save',\n *   actions: [\n *     () => [\n *       effect(async ({send}) => {\n *         await saveDocument()\n *         send({type: 'custom.saved'})\n *       }),\n *     ],\n *   ],\n * })\n * ```\n *\n * @beta\n */\nexport function effect(\n  effect: PickFromUnion<BehaviorAction, 'type', 'effect'>['effect'],\n): PickFromUnion<BehaviorAction, 'type', 'effect'> {\n  return {type: 'effect', effect}\n}\n\n/**\n * @beta\n */\nexport type BehaviorActionSet<TBehaviorEvent, TGuardResponse> = (\n  payload: {\n    snapshot: EditorSnapshot\n    event: TBehaviorEvent\n    dom: EditorDom\n  },\n  guardResponse: TGuardResponse,\n) => Array<BehaviorAction>\n","import type {BehaviorActionSet} from './behavior.types.action'\nimport type {\n  BehaviorEvent,\n  BehaviorEventTypeNamespace,\n  CustomBehaviorEvent,\n  ResolveBehaviorEvent,\n} from './behavior.types.event'\nimport type {BehaviorGuard} from './behavior.types.guard'\n\n/**\n * @beta\n */\nexport type Behavior<\n  TBehaviorEventType extends\n    | '*'\n    | `${BehaviorEventTypeNamespace}.*`\n    | BehaviorEvent['type'] =\n    | '*'\n    | `${BehaviorEventTypeNamespace}.*`\n    | BehaviorEvent['type'],\n  TGuardResponse = true,\n  TBehaviorEvent extends ResolveBehaviorEvent<TBehaviorEventType> =\n    ResolveBehaviorEvent<TBehaviorEventType>,\n> = {\n  /**\n   * Editor Event that triggers this Behavior.\n   */\n  on: TBehaviorEventType\n  /**\n   * Predicate function that determines if the Behavior should be executed.\n   * Returning a non-nullable value from the guard will pass the value to the\n   * actions and execute them.\n   */\n  guard?: BehaviorGuard<TBehaviorEvent, TGuardResponse>\n  /**\n   * Array of Behavior Action sets.\n   * Each set represents a step in the history stack.\n   */\n  actions: Array<BehaviorActionSet<TBehaviorEvent, TGuardResponse>>\n}\n\n/**\n * @beta\n *\n * @example\n *\n * ```tsx\n * const noLowerCaseA = defineBehavior({\n *   on: 'insert.text',\n *   guard: ({event, snapshot}) => event.text === 'a',\n *   actions: [({event, snapshot}) => [{type: 'insert.text', text: 'A'}]],\n * })\n * ```\n *\n */\nexport function defineBehavior<\n  TPayload extends Record<string, unknown>,\n  TBehaviorEventType extends\n    | '*'\n    | `${BehaviorEventTypeNamespace}.*`\n    | BehaviorEvent['type'] = CustomBehaviorEvent['type'],\n  TGuardResponse = true,\n>(\n  behavior: Behavior<\n    TBehaviorEventType,\n    TGuardResponse,\n    ResolveBehaviorEvent<TBehaviorEventType, TPayload>\n  >,\n): Behavior\nexport function defineBehavior<\n  TPayload extends never = never,\n  TBehaviorEventType extends\n    | '*'\n    | `${BehaviorEventTypeNamespace}.*`\n    | BehaviorEvent['type'] = BehaviorEvent['type'],\n  TGuardResponse = true,\n  TBehaviorEvent extends ResolveBehaviorEvent<TBehaviorEventType, TPayload> =\n    ResolveBehaviorEvent<TBehaviorEventType, TPayload>,\n>(\n  behavior: Behavior<TBehaviorEventType, TGuardResponse, TBehaviorEvent>,\n): Behavior {\n  return behavior as unknown as Behavior\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAwEA,SAAgBa,QACdJ,OACkD;CAClD,OAAO;EAACD,MAAM;EAAWC;CAAK;AAChC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuCA,SAAgBK,QACdL,OACkD;CAClD,OAAO;EAACD,MAAM;EAAWC;CAAK;AAChC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCA,SAAgBM,MACdN,OACgD;CAChD,OAAO;EAACD,MAAM;EAASC;CAAK;AAC9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4CA,SAAgBC,OACdA,QACiD;CACjD,OAAO;EAACF,MAAM;EAAUE;CAAM;AAChC;ACzIA,SAAgB2B,eAUdE,UACU;CACV,OAAOA;AACT"}

package/lib/behaviors/index.d.ts

@@ -1,2 +1,2 @@
-import { a as forward, b as defineBehavior, c as BehaviorEvent, d as InsertPlacement, f as NativeBehaviorEvent, i as execute, l as CustomBehaviorEvent, n as BehaviorActionSet, o as raise, p as SyntheticBehaviorEvent, r as effect, t as BehaviorAction, x as BehaviorGuard, y as Behavior } from "../_chunks-dts/behavior.types.action.js";
+import { Q as BehaviorGuard, X as Behavior, Z as defineBehavior, a as forward, c as CustomBehaviorEvent, d as SyntheticBehaviorEvent, i as execute, l as InsertPlacement, n as BehaviorActionSet, o as raise, r as effect, s as BehaviorEvent, t as BehaviorAction, u as NativeBehaviorEvent } from "../behavior.types.action-CYtiRDck.js";
 export { type Behavior, type BehaviorAction, type BehaviorActionSet, type BehaviorEvent, type BehaviorGuard, type CustomBehaviorEvent, type InsertPlacement, type NativeBehaviorEvent, type SyntheticBehaviorEvent, defineBehavior, effect, execute, forward, raise };

package/lib/behaviors/index.js

@@ -1,35 +1,2 @@
-function execute(event) {
-  return {
-    type: "execute",
-    event
-  };
-}
-function forward(event) {
-  return {
-    type: "forward",
-    event
-  };
-}
-function raise(event) {
-  return {
-    type: "raise",
-    event
-  };
-}
-function effect(effect2) {
-  return {
-    type: "effect",
-    effect: effect2
-  };
-}
-function defineBehavior(behavior) {
-  return behavior;
-}
-export {
-  defineBehavior,
-  effect,
-  execute,
-  forward,
-  raise
-};
-//# sourceMappingURL=index.js.map
+import { a as raise, i as forward, n as effect, r as execute, t as defineBehavior } from "../behavior.types.behavior-B_77VtQR.js";
+export { defineBehavior, effect, execute, forward, raise };

package/lib/get-container-BeXYKpoi.js

@@ -0,0 +1,222 @@
+import { i as getChildren, r as getNode, u as isKeyedSegment } from "./get-parent-51Kzgaf9.js";
+import { C as getAncestors, _ as comparePoints, b as isEditableContainer, g as isAfterPoint, m as rangeEdges, r as comparePoints$1, u as getNodes, v as comparePaths, y as isObject$1 } from "./get-path-sub-schema--2I4NJbG.js";
+import { getSubSchema, isSpan, isTextBlock } from "@portabletext/schema";
+function getAncestor(snapshot, path, options) {
+	let { match, mode = "lowest" } = options, ancestors = getAncestors(snapshot, path);
+	if (mode === "highest") {
+		for (let ancestor of [...ancestors].reverse()) if (match(ancestor.node, ancestor.path)) return ancestor;
+		return;
+	}
+	for (let ancestor of ancestors) if (match(ancestor.node, ancestor.path)) return ancestor;
+}
+/**
+* Check if a node is a leaf object: an object node that has no editable
+* children (not a container).
+* Returns true for block objects and inline objects that don't have
+* registered editable content (containers).
+*
+* @beta
+*/
+function isLeafObject(snapshot, node, path) {
+	return isObject$1(snapshot, node) && !isEditableContainer(snapshot, node, path);
+}
+/**
+* Get the deepest leaf node starting from a path, walking toward either the
+* start or end edge. A leaf is any node that has no children according to the
+* traversal context.
+*
+* @beta
+*/
+function getLeaf(snapshot, path, options) {
+	let { edge } = options, currentPath = path;
+	if (currentPath.length === 0) {
+		let children = getChildren(snapshot, []);
+		if (children.length === 0) return;
+		let firstOrLast = edge === "end" ? children.at(-1) : children.at(0);
+		if (getChildren(snapshot, firstOrLast.path).length === 0) return firstOrLast;
+		currentPath = firstOrLast.path;
+	} else {
+		let entry = getNode(snapshot, currentPath);
+		if (!entry) return;
+		if (getChildren(snapshot, currentPath).length === 0) return entry;
+	}
+	for (;;) {
+		let children = getChildren(snapshot, currentPath);
+		if (children.length === 0) return getNode(snapshot, currentPath) ?? void 0;
+		currentPath = (edge === "end" ? children.at(-1) : children.at(0)).path;
+	}
+}
+function isPath(value) {
+	return Array.isArray(value) && (value.length === 0 || typeof value[0] == "number" || typeof value[0] == "string" || isKeyedSegment(value[0]));
+}
+const isObject = (value) => typeof value == "object" && !!value;
+function isPoint(value) {
+	return isObject(value) && typeof value.offset == "number" && isPath(value.path);
+}
+function isRange(value) {
+	return isObject(value) && isPoint(value.anchor) && isPoint(value.focus);
+}
+/**
+* Get the concatenated text content of the node at a given path.
+*
+* @beta
+*/
+function getText(snapshot, path) {
+	let entry = getNode(snapshot, path);
+	if (!entry) return;
+	if (isSpan({ schema: snapshot.context.schema }, entry.node)) return entry.node.text;
+	let text = "";
+	for (let descendant of getNodes(snapshot, { at: path })) isSpan({ schema: snapshot.context.schema }, descendant.node) && (text += descendant.node.text);
+	return text;
+}
+/**
+* Get the span node at a given path.
+*
+* @beta
+*/
+function getSpan(snapshot, path) {
+	let entry = getNode(snapshot, path);
+	if (entry && isSpan({ schema: snapshot.context.schema }, entry.node)) return {
+		node: entry.node,
+		path: entry.path
+	};
+}
+/**
+* Returns true if `ancestor` is equal to `descendant`, or if `descendant`
+* lives anywhere inside `ancestor`'s subtree.
+*
+* @beta
+*/
+function pathContains(ancestor, descendant) {
+	if (ancestor.length > descendant.length) return !1;
+	for (let i = 0; i < ancestor.length; i++) {
+		let segment = ancestor[i], otherSegment = descendant[i];
+		if (isKeyedSegment(segment) && isKeyedSegment(otherSegment)) {
+			if (segment._key !== otherSegment._key) return !1;
+		} else if (segment !== otherSegment) return !1;
+	}
+	return !0;
+}
+function isBeforePoint(point, another, root) {
+	return comparePoints(point, another, root) === -1;
+}
+/**
+* Returns true if `range` and the supplied `target` intersect. The target
+* may be a `Path`, an `EditorSelectionPoint`, or another
+* `EditorSelection`.
+*
+* For a `Path` or `EditorSelectionPoint` target, "intersect" means the
+* target lies at or between `range`'s start and end edges (inclusive).
+*
+* For an `EditorSelection` target, "intersect" means either endpoint of
+* `target` lies inside `range`, or `range` strictly encloses `target`.
+*
+* Pass `snapshot.context.selection` as `range` to ask the question against
+* the editor's current selection.
+*
+* Returns `false` when either `range` or `target` is `null`.
+*
+* @beta
+*/
+function rangeIntersects(snapshot, range, target) {
+	if (!range || target === null) return !1;
+	let root = { value: snapshot.context.value };
+	if (isRange(target)) {
+		if (rangeIntersects(snapshot, range, target.anchor) || rangeIntersects(snapshot, range, target.focus)) return !0;
+		let [rs, re] = rangeEdges(range, root), [ts, te] = rangeEdges(target, root);
+		return isBeforePoint(rs, ts, root) && isAfterPoint(re, te, root);
+	}
+	let [start, end] = rangeEdges(range, root), isAfterStart = !1, isBeforeEnd = !1;
+	return isPoint(target) ? (isAfterStart = comparePoints$1(snapshot, target, start) >= 0, isBeforeEnd = comparePoints$1(snapshot, target, end) <= 0) : (isAfterStart = comparePaths(target, start.path, root) >= 0, isBeforeEnd = comparePaths(target, end.path, root) <= 0), isAfterStart && isBeforeEnd;
+}
+/**
+* Get the text block node at a given path.
+*
+* @beta
+*/
+function getTextBlock(snapshot, path) {
+	let entry = getNode(snapshot, path);
+	if (entry && isTextBlock({ schema: snapshot.context.schema }, entry.node)) return {
+		node: entry.node,
+		path: entry.path
+	};
+}
+/**
+* Get the first child of a node at a given path.
+*
+* @beta
+*/
+function getFirstChild(snapshot, path) {
+	return getChildren(snapshot, path).at(0);
+}
+/**
+* Get the last child of a node at a given path.
+*
+* @beta
+*/
+function getLastChild(snapshot, path) {
+	return getChildren(snapshot, path).at(-1);
+}
+/**
+* Return a `Schema` that contains every named member declared anywhere
+* in the editor's schema graph that is reachable from a position where text
+* is edited - the root schema merged with the sub-schema of every registered
+* container whose field accepts text blocks, deduped by name. Useful for
+* rendering a static toolbar whose buttons stay stable across selection
+* moves while still reflecting everything that could plausibly be edited or
+* inserted somewhere.
+*
+* Containers whose field does NOT accept text blocks (e.g. a `table`
+* container whose `rows` field only accepts `row` objects, or a `row`
+* container whose `cells` field only accepts `cell` objects) are
+* **structural**: their immediate `of` types are organizational, not
+* insertable user content. Those structural types are excluded from the
+* union. Their nested text-block-accepting descendants (e.g. a `cell`
+* that contains a `content` field of `{type: 'block'}`) are reached via
+* those descendants' own container registration.
+*
+* Pair with `getPathSubSchema` (or a path-based intersection across a
+* range) to determine which of the union's members are applicable at the
+* current selection.
+*
+* @beta
+*/
+function getUnionSchema(schema, containers) {
+	let decorators = mergeByName(schema.decorators, []), annotations = mergeByName(schema.annotations, []), lists = mergeByName(schema.lists, []), styles = mergeByName(schema.styles, []), inlineObjects = mergeByName(schema.inlineObjects, []), blockObjects = mergeByName(schema.blockObjects, []);
+	for (let container of containers.values()) {
+		if (!acceptsTextBlock(container.field.of, schema.block.name)) continue;
+		let sub = getSubSchema(schema, container.field.of);
+		mergeByName(sub.decorators, decorators), mergeByName(sub.annotations, annotations), mergeByName(sub.lists, lists), mergeByName(sub.styles, styles), mergeByName(sub.inlineObjects, inlineObjects), mergeByName(sub.blockObjects, blockObjects);
+	}
+	return {
+		...schema,
+		decorators,
+		annotations,
+		lists,
+		styles,
+		inlineObjects,
+		blockObjects
+	};
+}
+function acceptsTextBlock(of, blockName) {
+	return of.some((member) => member.type === "block" || member.type === blockName);
+}
+function mergeByName(source, target) {
+	for (let entry of source) target.some((existing) => existing.name === entry.name) || target.push(entry);
+	return target;
+}
+/**
+* Get the registered editable container at a given path.
+*
+* @beta
+*/
+function getContainer(snapshot, path) {
+	let entry = getNode(snapshot, path);
+	if (entry && isEditableContainer(snapshot, entry.node, entry.path)) return {
+		node: entry.node,
+		path: entry.path
+	};
+}
+export { getAncestor as _, getTextBlock as a, pathContains as c, isRange as d, isPoint as f, isLeafObject as g, getLeaf as h, getFirstChild as i, getSpan as l, isPath as m, getUnionSchema as n, rangeIntersects as o, isObject as p, getLastChild as r, isBeforePoint as s, getContainer as t, getText as u };
+
+//# sourceMappingURL=get-container-BeXYKpoi.js.map

package/lib/get-container-BeXYKpoi.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-container-BeXYKpoi.js","names":["PortableTextBlock","Path","getAncestors","TraversalSnapshot","getAncestor","snapshot","path","options","match","node","TMatch","mode","ancestors","ancestor","reverse","undefined","PortableTextObject","Path","isEditableContainer","isObject","TraversalSnapshot","isLeafObject","snapshot","node","path","Node","Path","getChildren","getNode","TraversalSnapshot","getLeaf","snapshot","path","options","edge","node","currentPath","length","children","undefined","firstOrLast","at","nodeChildren","entry","child","isKeyedSegment","Path","isPath","value","Array","isArray","length","Point","isPath","isObject","isPoint","value","offset","path","Range","isPoint","isObject","isRange","value","anchor","focus","isSpan","Path","getNode","getNodes","TraversalSnapshot","getText","snapshot","path","entry","undefined","schema","context","node","text","descendant","at","isSpan","PortableTextSpan","Path","getNode","TraversalSnapshot","getSpan","snapshot","path","node","entry","undefined","schema","context","Path","isKeyedSegment","pathContains","ancestor","descendant","length","i","segment","otherSegment","_key","Node","Point","comparePoints","isBeforePoint","point","another","root","value","Array","comparePaths","isAfterPoint","isBeforePoint","isPoint","isRange","rangeEdges","EditorSelection","EditorSelectionPoint","Path","comparePoints","TraversalSnapshot","rangeIntersects","snapshot","range","target","root","value","context","anchor","focus","rs","re","ts","te","start","end","isAfterStart","isBeforeEnd","path","isTextBlock","PortableTextTextBlock","Path","getNode","TraversalSnapshot","getTextBlock","snapshot","path","node","entry","undefined","schema","context","Node","Path","getChildren","TraversalSnapshot","getFirstChild","snapshot","path","node","at","Node","Path","getChildren","TraversalSnapshot","getLastChild","snapshot","path","node","children","at","getSubSchema","Schema","Containers","getUnionSchema","schema","containers","decorators","mergeByName","annotations","lists","styles","inlineObjects","blockObjects","container","values","acceptsTextBlock","field","of","block","name","sub","ReadonlyArray","type","blockName","some","member","source","T","target","Array","entry","existing","push","Node","Path","isEditableContainer","getNode","TraversalSnapshot","getContainer","snapshot","path","node","entry","undefined"],"sources":["../src/traversal/get-ancestor.ts","../src/traversal/is-leaf-object.ts","../src/traversal/get-leaf.ts","../src/engine/path/is-path.ts","../src/engine/utils/is-object.ts","../src/engine/point/is-point.ts","../src/engine/range/is-range.ts","../src/traversal/get-text.ts","../src/traversal/get-span.ts","../src/traversal/path-contains.ts","../src/engine/point/is-before-point.ts","../src/traversal/range-intersects.ts","../src/traversal/get-text-block.ts","../src/traversal/get-first-child.ts","../src/traversal/get-last-child.ts","../src/traversal/get-union-schema.ts","../src/traversal/get-container.ts"],"sourcesContent":["import type {PortableTextBlock} from '@portabletext/schema'\nimport type {Path} from '../engine/interfaces/path'\nimport {getAncestors} from './get-ancestors'\nimport type {TraversalSnapshot} from './traversal-snapshot'\n\n/**\n * Find an ancestor of the node at a given path that matches a predicate.\n * Does not check the node at the path itself, only its ancestors.\n *\n * `mode: 'lowest'` (default) returns the nearest matching ancestor.\n * `mode: 'highest'` returns the outermost matching ancestor.\n *\n * When `match` is a type predicate, the returned `node` narrows to that type.\n *\n * @beta\n */\nexport function getAncestor<TMatch extends PortableTextBlock>(\n  snapshot: TraversalSnapshot,\n  path: Path,\n  options: {\n    match: (node: PortableTextBlock, path: Path) => node is TMatch\n    mode?: 'lowest' | 'highest'\n  },\n): {node: TMatch; path: Path} | undefined\n/**\n * @beta\n */\nexport function getAncestor(\n  snapshot: TraversalSnapshot,\n  path: Path,\n  options: {\n    match: (node: PortableTextBlock, path: Path) => boolean\n    mode?: 'lowest' | 'highest'\n  },\n): {node: PortableTextBlock; path: Path} | undefined\nexport function getAncestor(\n  snapshot: TraversalSnapshot,\n  path: Path,\n  options: {\n    match: (node: PortableTextBlock, path: Path) => boolean\n    mode?: 'lowest' | 'highest'\n  },\n): {node: PortableTextBlock; path: Path} | undefined {\n  const {match, mode = 'lowest'} = options\n  const ancestors = getAncestors(snapshot, path)\n\n  if (mode === 'highest') {\n    for (const ancestor of [...ancestors].reverse()) {\n      if (match(ancestor.node, ancestor.path)) {\n        return ancestor\n      }\n    }\n    return undefined\n  }\n\n  for (const ancestor of ancestors) {\n    if (match(ancestor.node, ancestor.path)) {\n      return ancestor\n    }\n  }\n\n  return undefined\n}\n","import type {PortableTextObject} from '@portabletext/schema'\nimport type {Path} from '../engine/interfaces/path'\nimport {isEditableContainer} from '../schema/is-editable-container'\nimport {isObject} from './is-object'\nimport type {TraversalSnapshot} from './traversal-snapshot'\n\n/**\n * Check if a node is a leaf object: an object node that has no editable\n * children (not a container).\n * Returns true for block objects and inline objects that don't have\n * registered editable content (containers).\n *\n * @beta\n */\nexport function isLeafObject(\n  snapshot: TraversalSnapshot,\n  node: unknown,\n  path: Path,\n): node is PortableTextObject {\n  return isObject(snapshot, node) && !isEditableContainer(snapshot, node, path)\n}\n","import type {Node} from '../engine/interfaces/node'\nimport type {Path} from '../engine/interfaces/path'\nimport {getChildren} from './get-children'\nimport {getNode} from './get-node'\nimport type {TraversalSnapshot} from './traversal-snapshot'\n\n/**\n * Get the deepest leaf node starting from a path, walking toward either the\n * start or end edge. A leaf is any node that has no children according to the\n * traversal context.\n *\n * @beta\n */\nexport function getLeaf(\n  snapshot: TraversalSnapshot,\n  path: Path,\n  options: {edge: 'start' | 'end'},\n): {node: Node; path: Path} | undefined {\n  const {edge} = options\n\n  let currentPath = path\n\n  // If starting from root (empty path), descend into first/last child\n  if (currentPath.length === 0) {\n    const children = getChildren(snapshot, [])\n    if (children.length === 0) {\n      return undefined\n    }\n    const firstOrLast = edge === 'end' ? children.at(-1)! : children.at(0)!\n    const nodeChildren = getChildren(snapshot, firstOrLast.path)\n    if (nodeChildren.length === 0) {\n      return firstOrLast\n    }\n    currentPath = firstOrLast.path\n  } else {\n    // Check if the node at path is already a leaf\n    const entry = getNode(snapshot, currentPath)\n    if (!entry) {\n      return undefined\n    }\n    const children = getChildren(snapshot, currentPath)\n    if (children.length === 0) {\n      return entry\n    }\n  }\n\n  // Descend to deepest leaf\n  while (true) {\n    const children = getChildren(snapshot, currentPath)\n    if (children.length === 0) {\n      const entry = getNode(snapshot, currentPath)\n      return entry ?? undefined\n    }\n    const child = edge === 'end' ? children.at(-1)! : children.at(0)!\n    currentPath = child.path\n  }\n}\n","import {isKeyedSegment} from '../../utils/util.is-keyed-segment'\nimport type {Path} from '../interfaces/path'\n\nexport function isPath(value: any): value is Path {\n  return (\n    Array.isArray(value) &&\n    (value.length === 0 ||\n      typeof value[0] === 'number' ||\n      typeof value[0] === 'string' ||\n      isKeyedSegment(value[0]))\n  )\n}\n","export const isObject = (value: any) =>\n  typeof value === 'object' && value !== null\n","import type {Point} from '../interfaces/point'\nimport {isPath} from '../path/is-path'\nimport {isObject} from '../utils/is-object'\n\nexport function isPoint(value: any): value is Point {\n  return (\n    isObject(value) && typeof value.offset === 'number' && isPath(value.path)\n  )\n}\n","import type {Range} from '../interfaces/range'\nimport {isPoint} from '../point/is-point'\nimport {isObject} from '../utils/is-object'\n\nexport function isRange(value: any): value is Range {\n  return isObject(value) && isPoint(value.anchor) && isPoint(value.focus)\n}\n","import {isSpan} from '@portabletext/schema'\nimport type {Path} from '../engine/interfaces/path'\nimport {getNode} from './get-node'\nimport {getNodes} from './get-nodes'\nimport type {TraversalSnapshot} from './traversal-snapshot'\n\n/**\n * Get the concatenated text content of the node at a given path.\n *\n * @beta\n */\nexport function getText(\n  snapshot: TraversalSnapshot,\n  path: Path,\n): string | undefined {\n  const entry = getNode(snapshot, path)\n\n  if (!entry) {\n    return undefined\n  }\n\n  if (isSpan({schema: snapshot.context.schema}, entry.node)) {\n    return entry.node.text\n  }\n\n  let text = ''\n\n  for (const descendant of getNodes(snapshot, {at: path})) {\n    if (isSpan({schema: snapshot.context.schema}, descendant.node)) {\n      text += descendant.node.text\n    }\n  }\n\n  return text\n}\n","import {isSpan, type PortableTextSpan} from '@portabletext/schema'\nimport type {Path} from '../engine/interfaces/path'\nimport {getNode} from './get-node'\nimport type {TraversalSnapshot} from './traversal-snapshot'\n\n/**\n * Get the span node at a given path.\n *\n * @beta\n */\nexport function getSpan(\n  snapshot: TraversalSnapshot,\n  path: Path,\n): {node: PortableTextSpan; path: Path} | undefined {\n  const entry = getNode(snapshot, path)\n\n  if (!entry) {\n    return undefined\n  }\n\n  if (!isSpan({schema: snapshot.context.schema}, entry.node)) {\n    return undefined\n  }\n\n  return {node: entry.node, path: entry.path}\n}\n","import type {Path} from '../types/paths'\nimport {isKeyedSegment} from '../utils/util.is-keyed-segment'\n\n/**\n * Returns true if `ancestor` is equal to `descendant`, or if `descendant`\n * lives anywhere inside `ancestor`'s subtree.\n *\n * @beta\n */\nexport function pathContains(ancestor: Path, descendant: Path): boolean {\n  if (ancestor.length > descendant.length) {\n    return false\n  }\n\n  for (let i = 0; i < ancestor.length; i++) {\n    const segment = ancestor[i]\n    const otherSegment = descendant[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 {Node} from '../interfaces/node'\nimport type {Point} from '../interfaces/point'\nimport {comparePoints} from './compare-points'\n\nexport function isBeforePoint(\n  point: Point,\n  another: Point,\n  root: {value: Array<Node>},\n): boolean {\n  return comparePoints(point, another, root) === -1\n}\n","import {comparePaths} from '../engine/path/compare-paths'\nimport {isAfterPoint} from '../engine/point/is-after-point'\nimport {isBeforePoint} from '../engine/point/is-before-point'\nimport {isPoint} from '../engine/point/is-point'\nimport {isRange} from '../engine/range/is-range'\nimport {rangeEdges} from '../engine/range/range-edges'\nimport type {EditorSelection, EditorSelectionPoint} from '../types/editor'\nimport type {Path} from '../types/paths'\nimport {comparePoints} from './compare-points'\nimport type {TraversalSnapshot} from './traversal-snapshot'\n\n/**\n * Returns true if `range` and the supplied `target` intersect. The target\n * may be a `Path`, an `EditorSelectionPoint`, or another\n * `EditorSelection`.\n *\n * For a `Path` or `EditorSelectionPoint` target, \"intersect\" means the\n * target lies at or between `range`'s start and end edges (inclusive).\n *\n * For an `EditorSelection` target, \"intersect\" means either endpoint of\n * `target` lies inside `range`, or `range` strictly encloses `target`.\n *\n * Pass `snapshot.context.selection` as `range` to ask the question against\n * the editor's current selection.\n *\n * Returns `false` when either `range` or `target` is `null`.\n *\n * @beta\n */\nexport function rangeIntersects(\n  snapshot: TraversalSnapshot,\n  range: EditorSelection,\n  target: Path | EditorSelectionPoint | EditorSelection,\n): boolean {\n  if (!range || target === null) {\n    return false\n  }\n\n  const root = {value: snapshot.context.value}\n\n  if (isRange(target)) {\n    if (\n      rangeIntersects(snapshot, range, target.anchor) ||\n      rangeIntersects(snapshot, range, target.focus)\n    ) {\n      return true\n    }\n    const [rs, re] = rangeEdges(range, root)\n    const [ts, te] = rangeEdges(target, root)\n    return isBeforePoint(rs, ts, root) && isAfterPoint(re, te, root)\n  }\n\n  const [start, end] = rangeEdges(range, root)\n  let isAfterStart = false\n  let isBeforeEnd = false\n\n  if (isPoint(target)) {\n    isAfterStart = comparePoints(snapshot, target, start) >= 0\n    isBeforeEnd = comparePoints(snapshot, target, end) <= 0\n  } else {\n    isAfterStart = comparePaths(target, start.path, root) >= 0\n    isBeforeEnd = comparePaths(target, end.path, root) <= 0\n  }\n\n  return isAfterStart && isBeforeEnd\n}\n","import {isTextBlock, type PortableTextTextBlock} from '@portabletext/schema'\nimport type {Path} from '../engine/interfaces/path'\nimport {getNode} from './get-node'\nimport type {TraversalSnapshot} from './traversal-snapshot'\n\n/**\n * Get the text block node at a given path.\n *\n * @beta\n */\nexport function getTextBlock(\n  snapshot: TraversalSnapshot,\n  path: Path,\n): {node: PortableTextTextBlock; path: Path} | undefined {\n  const entry = getNode(snapshot, path)\n\n  if (!entry) {\n    return undefined\n  }\n\n  if (!isTextBlock({schema: snapshot.context.schema}, entry.node)) {\n    return undefined\n  }\n\n  return {node: entry.node, path: entry.path}\n}\n","import type {Node} from '../engine/interfaces/node'\nimport type {Path} from '../engine/interfaces/path'\nimport {getChildren} from './get-children'\nimport type {TraversalSnapshot} from './traversal-snapshot'\n\n/**\n * Get the first child of a node at a given path.\n *\n * @beta\n */\nexport function getFirstChild(\n  snapshot: TraversalSnapshot,\n  path: Path,\n): {node: Node; path: Path} | undefined {\n  return getChildren(snapshot, path).at(0)\n}\n","import type {Node} from '../engine/interfaces/node'\nimport type {Path} from '../engine/interfaces/path'\nimport {getChildren} from './get-children'\nimport type {TraversalSnapshot} from './traversal-snapshot'\n\n/**\n * Get the last child of a node at a given path.\n *\n * @beta\n */\nexport function getLastChild(\n  snapshot: TraversalSnapshot,\n  path: Path,\n): {node: Node; path: Path} | undefined {\n  const children = getChildren(snapshot, path)\n\n  return children.at(-1)\n}\n","import {getSubSchema, type Schema} from '@portabletext/schema'\nimport type {Containers} from '../schema/resolve-containers'\n\n/**\n * Return a `Schema` that contains every named member declared anywhere\n * in the editor's schema graph that is reachable from a position where text\n * is edited - the root schema merged with the sub-schema of every registered\n * container whose field accepts text blocks, deduped by name. Useful for\n * rendering a static toolbar whose buttons stay stable across selection\n * moves while still reflecting everything that could plausibly be edited or\n * inserted somewhere.\n *\n * Containers whose field does NOT accept text blocks (e.g. a `table`\n * container whose `rows` field only accepts `row` objects, or a `row`\n * container whose `cells` field only accepts `cell` objects) are\n * **structural**: their immediate `of` types are organizational, not\n * insertable user content. Those structural types are excluded from the\n * union. Their nested text-block-accepting descendants (e.g. a `cell`\n * that contains a `content` field of `{type: 'block'}`) are reached via\n * those descendants' own container registration.\n *\n * Pair with `getPathSubSchema` (or a path-based intersection across a\n * range) to determine which of the union's members are applicable at the\n * current selection.\n *\n * @beta\n */\nexport function getUnionSchema(schema: Schema, containers: Containers): Schema {\n  const decorators = mergeByName(schema.decorators, [])\n  const annotations = mergeByName(schema.annotations, [])\n  const lists = mergeByName(schema.lists, [])\n  const styles = mergeByName(schema.styles, [])\n  const inlineObjects = mergeByName(schema.inlineObjects, [])\n  const blockObjects = mergeByName(schema.blockObjects, [])\n\n  for (const container of containers.values()) {\n    if (!acceptsTextBlock(container.field.of, schema.block.name)) {\n      continue\n    }\n    const sub = getSubSchema(schema, container.field.of)\n    mergeByName(sub.decorators, decorators)\n    mergeByName(sub.annotations, annotations)\n    mergeByName(sub.lists, lists)\n    mergeByName(sub.styles, styles)\n    mergeByName(sub.inlineObjects, inlineObjects)\n    mergeByName(sub.blockObjects, blockObjects)\n  }\n\n  return {\n    ...schema,\n    decorators,\n    annotations,\n    lists,\n    styles,\n    inlineObjects,\n    blockObjects,\n  }\n}\n\nfunction acceptsTextBlock(\n  of: ReadonlyArray<{type: string}>,\n  blockName: string,\n): boolean {\n  return of.some(\n    (member) => member.type === 'block' || member.type === blockName,\n  )\n}\n\nfunction mergeByName<T extends {name: string}>(\n  source: ReadonlyArray<T>,\n  target: Array<T>,\n): Array<T> {\n  for (const entry of source) {\n    if (target.some((existing) => existing.name === entry.name)) {\n      continue\n    }\n    target.push(entry)\n  }\n  return target\n}\n","import type {Node} from '../engine/interfaces/node'\nimport type {Path} from '../engine/interfaces/path'\nimport {isEditableContainer} from '../schema/is-editable-container'\nimport {getNode} from './get-node'\nimport type {TraversalSnapshot} from './traversal-snapshot'\n\n/**\n * Get the registered editable container at a given path.\n *\n * @beta\n */\nexport function getContainer(\n  snapshot: TraversalSnapshot,\n  path: Path,\n): {node: Node; path: Path} | undefined {\n  const entry = getNode(snapshot, path)\n\n  if (!entry) {\n    return undefined\n  }\n\n  if (!isEditableContainer(snapshot, entry.node, entry.path)) {\n    return undefined\n  }\n\n  return {node: entry.node, path: entry.path}\n}\n"],"mappings":"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"}