@portabletext/editor 7.10.15 → 7.10.17

package/lib/util.slice-blocks-DQnr9X2s.js

@@ -0,0 +1,633 @@
+import { c as isTypedObject, r as getNode, s as isRecord, t as getParent, u as isKeyedSegment } from "./get-parent-51Kzgaf9.js";
+import { getSubSchema, isSpan, isTextBlock } from "@portabletext/schema";
+/**
+* Pure text-offset arithmetic over a node's children array, shared by
+* the snapshot-aware block-offset utils (`util.block-offset.ts`) and
+* the schema-free point transform (`engine/point/transform-point.ts`).
+* Span-ness is the caller's concern, expressed as an accessor that
+* returns the child's text when the child occupies text offsets and
+* `undefined` when it does not (inline objects, blocks).
+*/
+/**
+* The text offset of `(childKey, offsetInChild)` within `children`:
+* the total text of the children before that child, plus the offset
+* into it. `undefined` when the child is missing or carries no text.
+*/
+function textOffsetOfChild(children, getSpanText, childKey, offsetInChild) {
+	let precedingTextLength = 0;
+	for (let child of children) {
+		let text = getSpanText(child);
+		if (keyOf(child) === childKey) return text === void 0 ? void 0 : precedingTextLength + offsetInChild;
+		text !== void 0 && (precedingTextLength += text.length);
+	}
+}
+/**
+* The child and child-local offset at `textOffset` within `children`.
+* Forward-boundary convention: an offset landing exactly on a span
+* boundary stays at the end of the earlier span. `undefined` when the
+* offset lies beyond the children's total text.
+*/
+function childAtTextOffset(children, getSpanText, textOffset) {
+	let remainingOffset = textOffset;
+	for (let child of children) {
+		let text = getSpanText(child);
+		if (text !== void 0) {
+			if (remainingOffset <= text.length) {
+				let key = keyOf(child);
+				return key === void 0 ? void 0 : {
+					key,
+					offset: remainingOffset
+				};
+			}
+			remainingOffset -= text.length;
+		}
+	}
+}
+function keyOf(child) {
+	if (typeof child == "object" && child && "_key" in child) {
+		let key = child._key;
+		return typeof key == "string" ? key : void 0;
+	}
+}
+/**
+* @public
+*/
+function blockOffsetToSpanSelectionPoint({ snapshot, blockOffset, direction }) {
+	let blockEntry = getNode(snapshot, blockOffset.path);
+	if (!blockEntry || !isTextBlock(snapshot.context, blockEntry.node)) return;
+	let block = blockEntry.node, blockPath = blockEntry.path;
+	if (direction === "forward") {
+		let placed = childAtTextOffset(block.children, (child) => isSpan(snapshot.context, child) ? child.text : void 0, blockOffset.offset);
+		return placed ? {
+			path: [
+				...blockPath,
+				"children",
+				{ _key: placed.key }
+			],
+			offset: placed.offset
+		} : void 0;
+	}
+	let offsetLeft = blockOffset.offset, selectionPoint, skippedInlineObject = !1;
+	for (let child of block.children) {
+		if (!isSpan(snapshot.context, child)) {
+			skippedInlineObject = !0;
+			continue;
+		}
+		if (offsetLeft === 0 && selectionPoint && !skippedInlineObject) break;
+		if (offsetLeft > child.text.length) {
+			offsetLeft -= child.text.length;
+			continue;
+		}
+		if (offsetLeft <= child.text.length && (selectionPoint = {
+			path: [
+				...blockPath,
+				"children",
+				{ _key: child._key }
+			],
+			offset: offsetLeft
+		}, offsetLeft -= child.text.length, offsetLeft !== 0)) break;
+	}
+	return selectionPoint;
+}
+/**
+* @public
+*/
+function spanSelectionPointToBlockOffset({ snapshot, selectionPoint }) {
+	let spanSegment = selectionPoint.path.at(-1);
+	if (!isKeyedSegment(spanSegment)) return;
+	let textBlock = getParent(snapshot, selectionPoint.path, { match: (node) => isTextBlock({ schema: snapshot.context.schema }, node) });
+	if (!textBlock) return;
+	let offset = textOffsetOfChild(textBlock.node.children, (child) => isSpan(snapshot.context, child) ? child.text : void 0, spanSegment._key, selectionPoint.offset);
+	return offset === void 0 ? void 0 : {
+		path: textBlock.path,
+		offset
+	};
+}
+function isEqualPathSegments(segA, segB) {
+	return segA === segB ? !0 : segA === void 0 || segB === void 0 ? !1 : (typeof segA == "string" || typeof segA == "number") && (typeof segB == "string" || typeof segB == "number") ? segA === segB : isKeyedSegment(segA) && isKeyedSegment(segB) ? segA._key === segB._key : Array.isArray(segA) && Array.isArray(segB) ? segA[0] === segB[0] && segA[1] === segB[1] : !1;
+}
+/**
+* @public
+*/
+function isEqualPaths(a, b) {
+	if (a.length !== b.length) return !1;
+	for (let i = 0; i < a.length; i++) if (!isEqualPathSegments(a[i], b[i])) return !1;
+	return !0;
+}
+/**
+* @public
+*/
+function isEqualSelectionPoints(a, b) {
+	return a.offset === b.offset && isEqualPaths(a.path, b.path);
+}
+function getBlockKeyFromSelectionPoint(point) {
+	let blockPathSegment = point.path.at(0);
+	if (isKeyedSegment(blockPathSegment)) return blockPathSegment._key;
+}
+function getChildKeyFromSelectionPoint(point) {
+	let childPathSegment = point.path.at(2);
+	if (isKeyedSegment(childPathSegment)) return childPathSegment._key;
+}
+/**
+* @public
+*/
+function getBlockEndPoint({ context, block }) {
+	if (isTextBlock(context, block.node)) {
+		let lastChild = block.node.children[block.node.children.length - 1];
+		if (lastChild) return {
+			path: [
+				...block.path,
+				"children",
+				{ _key: lastChild._key }
+			],
+			offset: isSpan(context, lastChild) ? lastChild.text.length : 0
+		};
+	}
+	return {
+		path: block.path,
+		offset: 0
+	};
+}
+/**
+* @public
+*/
+function getBlockStartPoint({ context, block }) {
+	if (isTextBlock(context, block.node)) {
+		let firstChild = block.node.children[0];
+		return {
+			path: [
+				...block.path,
+				"children",
+				{ _key: firstChild?._key ?? "" }
+			],
+			offset: 0
+		};
+	}
+	return {
+		path: block.path,
+		offset: 0
+	};
+}
+/**
+* @public
+*/
+function isSelectionCollapsed(selection) {
+	return selection ? isEqualPaths(selection.anchor.path, selection.focus.path) && selection.anchor.offset === selection.focus.offset : !1;
+}
+/**
+* @public
+*/
+function getSelectionEndPoint(selection) {
+	return selection ? selection.backward ? selection.anchor : selection.focus : null;
+}
+/**
+* @public
+*/
+function getSelectionStartPoint(selection) {
+	return selection ? selection.backward ? selection.focus : selection.anchor : null;
+}
+/**
+* @public
+*/
+const defaultKeyGenerator = () => randomKey(12), getByteHexTable = (() => {
+	let table;
+	return () => {
+		if (table) return table;
+		table = [];
+		for (let i = 0; i < 256; ++i) table[i] = (i + 256).toString(16).slice(1);
+		return table;
+	};
+})();
+function whatwgRNG(length = 16) {
+	let rnds8 = new Uint8Array(length);
+	return crypto.getRandomValues(rnds8), rnds8;
+}
+function randomKey(length) {
+	let table = getByteHexTable();
+	return whatwgRNG(length).reduce((str, n) => str + table[n], "").slice(0, length);
+}
+function parseBlocks({ schema, keyGenerator, blocks, options }) {
+	return Array.isArray(blocks) ? blocks.flatMap((block) => {
+		let parsedBlock = parseBlockInternal({
+			schema,
+			keyGenerator,
+			block,
+			options
+		});
+		return parsedBlock ? [parsedBlock] : [];
+	}) : [];
+}
+function parseBlock({ schema, keyGenerator, block, options }) {
+	return parseBlockInternal({
+		schema,
+		keyGenerator,
+		block,
+		options
+	});
+}
+function parseSpan({ span, schema, keyGenerator, markDefKeyMap, options }) {
+	return parseSpanInternal({
+		span,
+		schema,
+		keyGenerator,
+		markDefKeyMap,
+		options
+	});
+}
+function parseInlineObject({ inlineObject, schema, keyGenerator, options }) {
+	return parseInlineObjectInternal({
+		inlineObject,
+		schema,
+		keyGenerator,
+		options
+	});
+}
+function parseMarkDefs({ schema, keyGenerator, markDefs, options }) {
+	return parseMarkDefsInternal({
+		schema,
+		keyGenerator,
+		markDefs,
+		options
+	});
+}
+function parseBlockInternal({ schema, keyGenerator, block, options }) {
+	return parseTextBlock({
+		block,
+		schema,
+		keyGenerator,
+		options
+	}) ?? parseBlockObject({
+		blockObject: block,
+		schema,
+		keyGenerator,
+		options
+	});
+}
+function parseBlockObject({ blockObject, schema, keyGenerator, options }) {
+	if (!isTypedObject(blockObject)) return;
+	let schemaType = schema.blockObjects.find(({ name }) => name === blockObject._type);
+	if (schemaType) return parseObject({
+		object: blockObject,
+		schema,
+		keyGenerator,
+		schemaType,
+		options
+	});
+}
+function isListBlock(context, block) {
+	return isTextBlock(context, block) && block.level !== void 0 && block.listItem !== void 0;
+}
+function parseTextBlock({ block, schema, keyGenerator, options }) {
+	if (!isTypedObject(block) || block._type !== schema.block.name) return;
+	let customFields = {};
+	for (let key of Object.keys(block)) key !== "_type" && key !== "_key" && key !== "children" && key !== "markDefs" && key !== "style" && key !== "listItem" && key !== "level" && (options.validateFields ? (schema.block.fields ?? []).some((f) => f.name === key) && (customFields[key] = block[key]) : customFields[key] = block[key]);
+	let _key = typeof block._key == "string" ? block._key : keyGenerator(), { markDefs, markDefKeyMap } = parseMarkDefsInternal({
+		schema,
+		keyGenerator,
+		markDefs: block.markDefs,
+		options
+	}), parsedChildren = (Array.isArray(block.children) ? block.children : []).map((child) => parseChildInternal({
+		child,
+		schema,
+		keyGenerator,
+		markDefKeyMap,
+		options
+	})).filter((child) => child !== void 0), marks = parsedChildren.flatMap((child) => child.marks ?? []), children = parsedChildren.length > 0 ? parsedChildren : [{
+		_key: keyGenerator(),
+		_type: schema.span.name,
+		text: "",
+		marks: []
+	}], normalizedChildren = options.normalize ? children.reduce((normalizedChildren, child, index) => {
+		if (isSpan({ schema }, child)) return [...normalizedChildren, child];
+		let previousChild = normalizedChildren.at(-1);
+		return !previousChild || !isSpan({ schema }, previousChild) ? [
+			...normalizedChildren,
+			{
+				_key: keyGenerator(),
+				_type: schema.span.name,
+				text: "",
+				marks: []
+			},
+			child,
+			...index === children.length - 1 ? [{
+				_key: keyGenerator(),
+				_type: schema.span.name,
+				text: "",
+				marks: []
+			}] : []
+		] : [...normalizedChildren, child];
+	}, []) : children, parsedBlock = {
+		_type: schema.block.name,
+		_key,
+		children: normalizedChildren,
+		...customFields
+	};
+	return typeof block.markDefs == "object" && block.markDefs !== null && (parsedBlock.markDefs = options.removeUnusedMarkDefs ? markDefs.filter((markDef) => marks.includes(markDef._key)) : markDefs), typeof block.style == "string" && schema.styles.find((style) => style.name === block.style) && (parsedBlock.style = block.style), typeof block.listItem == "string" && schema.lists.find((list) => list.name === block.listItem) && (parsedBlock.listItem = block.listItem), typeof block.level == "number" && (parsedBlock.level = block.level), parsedBlock;
+}
+function parseMarkDefsInternal({ schema, keyGenerator, markDefs, options }) {
+	let unparsedMarkDefs = Array.isArray(markDefs) ? markDefs : [], markDefKeyMap = /* @__PURE__ */ new Map();
+	return {
+		markDefs: unparsedMarkDefs.flatMap((markDef) => {
+			if (!isTypedObject(markDef)) return [];
+			let schemaType = schema.annotations.find(({ name }) => name === markDef._type);
+			if (!schemaType || typeof markDef._key != "string") return [];
+			let parsedAnnotation = parseObject({
+				object: markDef,
+				schema,
+				keyGenerator,
+				schemaType,
+				options
+			});
+			return parsedAnnotation ? (markDefKeyMap.set(markDef._key, parsedAnnotation._key), [parsedAnnotation]) : [];
+		}),
+		markDefKeyMap
+	};
+}
+function parseChildInternal({ child, schema, keyGenerator, markDefKeyMap, options }) {
+	return parseSpanInternal({
+		span: child,
+		schema,
+		keyGenerator,
+		markDefKeyMap,
+		options
+	}) ?? parseInlineObjectInternal({
+		inlineObject: child,
+		schema,
+		keyGenerator,
+		options
+	});
+}
+function parseSpanInternal({ span, schema, keyGenerator, markDefKeyMap, options }) {
+	if (!isRecord(span)) return;
+	let customFields = {};
+	for (let key of Object.keys(span)) key !== "_type" && key !== "_key" && key !== "text" && key !== "marks" && (customFields[key] = span[key]);
+	let marks = (Array.isArray(span.marks) ? span.marks : []).flatMap((mark) => {
+		if (typeof mark != "string") return [];
+		let markDefKey = markDefKeyMap.get(mark);
+		return markDefKey === void 0 ? schema.decorators.some((decorator) => decorator.name === mark) ? [mark] : [] : [markDefKey];
+	});
+	if (typeof span._type != "string" || span._type === schema.span.name) return typeof span._type == "string" ? {
+		_type: schema.span.name,
+		_key: typeof span._key == "string" ? span._key : keyGenerator(),
+		text: typeof span.text == "string" ? span.text : "",
+		marks,
+		...options.validateFields ? {} : customFields
+	} : typeof span.text == "string" ? {
+		_type: schema.span.name,
+		_key: typeof span._key == "string" ? span._key : keyGenerator(),
+		text: span.text,
+		marks,
+		...options.validateFields ? {} : customFields
+	} : void 0;
+}
+function parseInlineObjectInternal({ inlineObject, schema, keyGenerator, options }) {
+	if (!isTypedObject(inlineObject)) return;
+	let schemaType = schema.inlineObjects.find(({ name }) => name === inlineObject._type);
+	if (schemaType) return parseObject({
+		object: inlineObject,
+		schema,
+		keyGenerator,
+		schemaType,
+		options
+	});
+}
+function parseAnnotation({ annotation, schema, keyGenerator, options }) {
+	if (!isTypedObject(annotation)) return;
+	let schemaType = schema.annotations.find(({ name }) => name === annotation._type);
+	if (schemaType) return parseObject({
+		object: annotation,
+		schema,
+		keyGenerator,
+		schemaType,
+		options
+	});
+}
+/**
+* Resolve an `of` member against a runtime `_type`. Returns the schema-type
+* to use for parsing the item, or `undefined` if no member matches.
+*
+* Three forms (one branch each):
+* - Inline declaration `{type: 'object', name: 'X', fields: [...]}` -- name
+*   matches `_type`, fields are inline.
+* - Reference `{type: 'X'}` -- looks up in the ancestor chain first
+*   (inline-declared types are visible to descendants), then in the schema's
+*   root `blockObjects`. Mirrors `resolve-containers.ts`'s reference
+*   resolution.
+* - `{type: 'block'}` -- not a non-PTE object member, returns `undefined`.
+*/
+function resolveOfMember(of, typeName, schema, ancestorFields) {
+	for (let member of of) if (member.type !== "block") {
+		if (member.type === "object" && "name" in member && member.name) {
+			if (member.name === typeName && "fields" in member && member.fields) return {
+				name: member.name,
+				fields: member.fields
+			};
+			continue;
+		}
+		if (member.type === typeName) {
+			let ancestorMatch = ancestorFields.get(typeName);
+			if (ancestorMatch) return {
+				name: typeName,
+				fields: ancestorMatch
+			};
+			let rootMatch = schema.blockObjects.find((blockObject) => blockObject.name === typeName);
+			return rootMatch && "fields" in rootMatch && rootMatch.fields ? {
+				name: rootMatch.name,
+				fields: rootMatch.fields
+			} : void 0;
+		}
+	}
+}
+/**
+* Parse an object against a `{name, fields}` schema type. Validates top-level
+* fields and recurses into any array field whose `of` contains a block-like
+* member -- parsing the nested blocks against a child `Schema` built from
+* that `of`.
+*/
+function parseObject({ object, schema, keyGenerator, schemaType, ancestorFields, options }) {
+	let { _key, ...customFields } = object, fieldsByName = new Map(schemaType.fields.map((field) => [field.name, field])), nextAncestors = new Map(ancestorFields ?? []);
+	nextAncestors.set(schemaType.name, schemaType.fields);
+	let values = {};
+	for (let [key, value] of Object.entries(customFields)) {
+		if (key === "_type" || value === void 0) continue;
+		let field = fieldsByName.get(key);
+		if (!(options.validateFields && !field)) {
+			if (field && field.type === "array" && field.of && Array.isArray(value)) {
+				values[key] = parseContainerFieldValue({
+					schema,
+					keyGenerator,
+					of: field.of,
+					value,
+					ancestorFields: nextAncestors,
+					options
+				});
+				continue;
+			}
+			values[key] = value;
+		}
+	}
+	return {
+		_type: schemaType.name,
+		_key: typeof _key == "string" ? _key : keyGenerator(),
+		...values
+	};
+}
+/**
+* Parse the value of an array field whose `of` declares what's allowed at
+* that position. Each item is dispatched per its own type:
+*
+* - Text blocks (`_type === schema.block.name`) are parsed against a child
+*   sub-schema derived from the `{type: 'block'}` member of `of` (which
+*   carries the styles, decorators, annotations, lists, and inline objects
+*   allowed at this position).
+*
+* - Block objects (and structural objects sitting between containers and
+*   text blocks) are parsed via `resolveOfMember` against the `of` array,
+*   with `ancestorFields` carrying inline type declarations down to bare
+*   references like `{type: 'list'}`. This lets nested containers resolve
+*   to their inline shapes at any depth.
+*
+* Items that don't resolve are passed through unchanged.
+*/
+function parseContainerFieldValue({ schema, keyGenerator, of, value, ancestorFields, options }) {
+	let childBlockSubSchema = of.some((member) => member.type === "block") ? getSubSchema(schema, of) : void 0;
+	return value.flatMap((item) => {
+		if (!isTypedObject(item)) return [item];
+		if (childBlockSubSchema && item._type === childBlockSubSchema.block.name) {
+			let parsed = parseTextBlock({
+				block: item,
+				schema: childBlockSubSchema,
+				keyGenerator,
+				options: {
+					normalize: !1,
+					removeUnusedMarkDefs: !1,
+					validateFields: options.validateFields
+				}
+			});
+			return parsed ? [parsed] : [];
+		}
+		let schemaType = resolveOfMember(of, item._type, schema, ancestorFields);
+		return schemaType ? [parseObject({
+			object: item,
+			schema,
+			keyGenerator,
+			schemaType: {
+				name: schemaType.name,
+				fields: schemaType.fields
+			},
+			ancestorFields,
+			options
+		})] : [item];
+	});
+}
+/**
+* @public
+*/
+function sliceBlocks({ context, blocks }) {
+	let slice = [];
+	if (!context.selection) return slice;
+	let startBlock, middleBlocks = [], endBlock, startPoint = getSelectionStartPoint(context.selection), endPoint = getSelectionEndPoint(context.selection), startBlockKey = getBlockKeyFromSelectionPoint(startPoint), startChildKey = getChildKeyFromSelectionPoint(startPoint), endBlockKey = getBlockKeyFromSelectionPoint(endPoint), endChildKey = getChildKeyFromSelectionPoint(endPoint);
+	if (!startBlockKey || !endBlockKey) return slice;
+	for (let block of blocks) {
+		if (!isTextBlock(context, block) && block._key === startBlockKey && block._key === endBlockKey) {
+			startBlock = block;
+			break;
+		}
+		if (block._key === startBlockKey) {
+			if (!isTextBlock(context, block)) {
+				startBlock = block;
+				continue;
+			}
+			if (startChildKey) {
+				for (let child of block.children) {
+					if (child._key === startChildKey) {
+						if (isSpan(context, child)) {
+							let text = child._key === endChildKey ? child.text.slice(startPoint.offset, endPoint.offset) : child.text.slice(startPoint.offset);
+							startBlock = {
+								...block,
+								children: [{
+									...child,
+									text
+								}]
+							};
+						} else startBlock = {
+							...block,
+							children: [child]
+						};
+						if (block._key === endBlockKey && startChildKey === endChildKey) break;
+						continue;
+					}
+					if (startBlock && isTextBlock(context, startBlock) && (endChildKey && child._key === endChildKey && isSpan(context, child) ? startBlock.children.push({
+						...child,
+						text: child.text.slice(0, endPoint.offset)
+					}) : startBlock.children.push(child), block._key === endBlockKey && endChildKey && child._key === endChildKey)) break;
+				}
+				if (startBlockKey === endBlockKey) break;
+				continue;
+			}
+			if (startBlock = block, startBlockKey === endBlockKey) break;
+		}
+		if (block._key === endBlockKey) {
+			if (!isTextBlock(context, block)) {
+				endBlock = block;
+				break;
+			}
+			if (endChildKey) {
+				endBlock = {
+					...block,
+					children: []
+				};
+				for (let child of block.children) if (endBlock && isTextBlock(context, endBlock)) {
+					if (child._key === endChildKey && isSpan(context, child)) {
+						endBlock.children.push({
+							...child,
+							text: child.text.slice(0, endPoint.offset)
+						});
+						break;
+					}
+					if (endBlock.children.push(child), endChildKey && child._key === endChildKey) break;
+				}
+				break;
+			}
+			endBlock = block;
+			break;
+		}
+		startBlock && middleBlocks.push(parseBlock({
+			keyGenerator: context.keyGenerator ?? defaultKeyGenerator,
+			block,
+			options: {
+				normalize: !1,
+				removeUnusedMarkDefs: !0,
+				validateFields: !1
+			},
+			schema: context.schema
+		}) ?? block);
+	}
+	let parsedStartBlock = startBlock ? parseBlock({
+		keyGenerator: context.keyGenerator ?? defaultKeyGenerator,
+		block: startBlock,
+		options: {
+			normalize: !1,
+			removeUnusedMarkDefs: !0,
+			validateFields: !1
+		},
+		schema: context.schema
+	}) : void 0, parsedEndBlock = endBlock ? parseBlock({
+		keyGenerator: context.keyGenerator ?? defaultKeyGenerator,
+		block: endBlock,
+		options: {
+			normalize: !1,
+			removeUnusedMarkDefs: !0,
+			validateFields: !1
+		},
+		schema: context.schema
+	}) : void 0;
+	return [
+		...parsedStartBlock ? [parsedStartBlock] : [],
+		...middleBlocks,
+		...parsedEndBlock ? [parsedEndBlock] : []
+	];
+}
+export { isEqualPaths as _, parseBlocks as a, childAtTextOffset as b, parseSpan as c, getSelectionEndPoint as d, isSelectionCollapsed as f, isEqualSelectionPoints as g, getBlockKeyFromSelectionPoint as h, parseBlock as i, defaultKeyGenerator as l, getBlockEndPoint as m, isListBlock as n, parseInlineObject as o, getBlockStartPoint as p, parseAnnotation as r, parseMarkDefs as s, sliceBlocks as t, getSelectionStartPoint as u, blockOffsetToSpanSelectionPoint as v, textOffsetOfChild as x, spanSelectionPointToBlockOffset as y };
+
+//# sourceMappingURL=util.slice-blocks-DQnr9X2s.js.map