@portabletext/editor 7.10.16 → 7.10.18

package/lib/_chunks-es/util.slice-blocks.js

@@ -1,720 +0,0 @@
-import { isTextBlock, isSpan, getSubSchema } from "@portabletext/schema";
-import { getNode, isKeyedSegment, getParent, isTypedObject, isRecord } from "./get-parent.js";
-function textOffsetOfChild(children, getSpanText, childKey, offsetInChild) {
-  let precedingTextLength = 0;
-  for (const child of children) {
-    const text = getSpanText(child);
-    if (keyOf(child) === childKey)
-      return text === void 0 ? void 0 : precedingTextLength + offsetInChild;
-    text !== void 0 && (precedingTextLength += text.length);
-  }
-}
-function childAtTextOffset(children, getSpanText, textOffset) {
-  let remainingOffset = textOffset;
-  for (const child of children) {
-    const text = getSpanText(child);
-    if (text !== void 0) {
-      if (remainingOffset <= text.length) {
-        const key = keyOf(child);
-        return key === void 0 ? void 0 : {
-          key,
-          offset: remainingOffset
-        };
-      }
-      remainingOffset -= text.length;
-    }
-  }
-}
-function keyOf(child) {
-  if (child !== null && typeof child == "object" && "_key" in child) {
-    const key = child._key;
-    return typeof key == "string" ? key : void 0;
-  }
-}
-function blockOffsetToSpanSelectionPoint({
-  snapshot,
-  blockOffset,
-  direction
-}) {
-  const blockEntry = getNode(snapshot, blockOffset.path);
-  if (!blockEntry || !isTextBlock(snapshot.context, blockEntry.node))
-    return;
-  const block = blockEntry.node, blockPath = blockEntry.path;
-  if (direction === "forward") {
-    const 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 (const 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;
-}
-function spanSelectionPointToBlockOffset({
-  snapshot,
-  selectionPoint
-}) {
-  const spanSegment = selectionPoint.path.at(-1);
-  if (!isKeyedSegment(spanSegment))
-    return;
-  const textBlock = getParent(snapshot, selectionPoint.path, {
-    match: (node) => isTextBlock({
-      schema: snapshot.context.schema
-    }, node)
-  });
-  if (!textBlock)
-    return;
-  const 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;
-}
-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;
-}
-function isEqualSelectionPoints(a, b) {
-  return a.offset === b.offset && isEqualPaths(a.path, b.path);
-}
-function getBlockKeyFromSelectionPoint(point) {
-  const blockPathSegment = point.path.at(0);
-  if (isKeyedSegment(blockPathSegment))
-    return blockPathSegment._key;
-}
-function getChildKeyFromSelectionPoint(point) {
-  const childPathSegment = point.path.at(2);
-  if (isKeyedSegment(childPathSegment))
-    return childPathSegment._key;
-}
-function getBlockEndPoint({
-  context,
-  block
-}) {
-  if (isTextBlock(context, block.node)) {
-    const 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
-  };
-}
-function getBlockStartPoint({
-  context,
-  block
-}) {
-  if (isTextBlock(context, block.node)) {
-    const firstChild = block.node.children[0];
-    return {
-      path: [...block.path, "children", {
-        _key: firstChild?._key ?? ""
-      }],
-      offset: 0
-    };
-  }
-  return {
-    path: block.path,
-    offset: 0
-  };
-}
-function isSelectionCollapsed(selection) {
-  return selection ? isEqualPaths(selection.anchor.path, selection.focus.path) && selection.anchor.offset === selection.focus.offset : !1;
-}
-function getSelectionEndPoint(selection) {
-  return selection ? selection.backward ? selection.anchor : selection.focus : null;
-}
-function getSelectionStartPoint(selection) {
-  return selection ? selection.backward ? selection.focus : selection.anchor : null;
-}
-const defaultKeyGenerator = () => randomKey(12), getByteHexTable = /* @__PURE__ */ (() => {
-  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) {
-  const rnds8 = new Uint8Array(length);
-  return crypto.getRandomValues(rnds8), rnds8;
-}
-function randomKey(length) {
-  const 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) => {
-    const 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;
-  const 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;
-  const customFields = {};
-  for (const 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]);
-  const _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 ? (
-    // Ensure that inline objects re surrounded by spans
-    children.reduce((normalizedChildren2, child, index) => {
-      if (isSpan({
-        schema
-      }, child))
-        return [...normalizedChildren2, child];
-      const previousChild = normalizedChildren2.at(-1);
-      return !previousChild || !isSpan({
-        schema
-      }, previousChild) ? [...normalizedChildren2, {
-        _key: keyGenerator(),
-        _type: schema.span.name,
-        text: "",
-        marks: []
-      }, child, ...index === children.length - 1 ? [{
-        _key: keyGenerator(),
-        _type: schema.span.name,
-        text: "",
-        marks: []
-      }] : []] : [...normalizedChildren2, 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
-}) {
-  const unparsedMarkDefs = Array.isArray(markDefs) ? markDefs : [], markDefKeyMap = /* @__PURE__ */ new Map();
-  return {
-    markDefs: unparsedMarkDefs.flatMap((markDef) => {
-      if (!isTypedObject(markDef))
-        return [];
-      const schemaType = schema.annotations.find(({
-        name
-      }) => name === markDef._type);
-      if (!schemaType)
-        return [];
-      if (typeof markDef._key != "string")
-        return [];
-      const 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;
-  const customFields = {};
-  for (const key of Object.keys(span))
-    key !== "_type" && key !== "_key" && key !== "text" && key !== "marks" && (customFields[key] = span[key]);
-  const marks = (Array.isArray(span.marks) ? span.marks : []).flatMap((mark) => {
-    if (typeof mark != "string")
-      return [];
-    const markDefKey = markDefKeyMap.get(mark);
-    return markDefKey !== void 0 ? [markDefKey] : schema.decorators.some((decorator) => decorator.name === mark) ? [mark] : [];
-  });
-  if (!(typeof span._type == "string" && span._type !== schema.span.name))
-    return typeof span._type != "string" ? 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 : {
-      _type: schema.span.name,
-      _key: typeof span._key == "string" ? span._key : keyGenerator(),
-      text: typeof span.text == "string" ? span.text : "",
-      marks,
-      ...options.validateFields ? {} : customFields
-    };
-}
-function parseInlineObjectInternal({
-  inlineObject,
-  schema,
-  keyGenerator,
-  options
-}) {
-  if (!isTypedObject(inlineObject))
-    return;
-  const 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;
-  const schemaType = schema.annotations.find(({
-    name
-  }) => name === annotation._type);
-  if (schemaType)
-    return parseObject({
-      object: annotation,
-      schema,
-      keyGenerator,
-      schemaType,
-      options
-    });
-}
-function resolveOfMember(of, typeName, schema, ancestorFields) {
-  for (const 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) {
-        const ancestorMatch = ancestorFields.get(typeName);
-        if (ancestorMatch)
-          return {
-            name: typeName,
-            fields: ancestorMatch
-          };
-        const rootMatch = schema.blockObjects.find((blockObject) => blockObject.name === typeName);
-        return rootMatch && "fields" in rootMatch && rootMatch.fields ? {
-          name: rootMatch.name,
-          fields: rootMatch.fields
-        } : void 0;
-      }
-    }
-}
-function parseObject({
-  object,
-  schema,
-  keyGenerator,
-  schemaType,
-  ancestorFields,
-  options
-}) {
-  const {
-    _key,
-    ...customFields
-  } = object, fieldsByName = new Map(schemaType.fields.map((field) => [field.name, field])), nextAncestors = new Map(ancestorFields ?? []);
-  nextAncestors.set(schemaType.name, schemaType.fields);
-  const values = {};
-  for (const [key, value] of Object.entries(customFields)) {
-    if (key === "_type" || value === void 0)
-      continue;
-    const 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
-  };
-}
-function parseContainerFieldValue({
-  schema,
-  keyGenerator,
-  of,
-  value,
-  ancestorFields,
-  options
-}) {
-  const 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) {
-      const parsed = parseTextBlock({
-        block: item,
-        schema: childBlockSubSchema,
-        keyGenerator,
-        options: {
-          normalize: !1,
-          removeUnusedMarkDefs: !1,
-          validateFields: options.validateFields
-        }
-      });
-      return parsed ? [parsed] : [];
-    }
-    const schemaType = resolveOfMember(of, item._type, schema, ancestorFields);
-    return schemaType ? [parseObject({
-      object: item,
-      schema,
-      keyGenerator,
-      schemaType: {
-        name: schemaType.name,
-        fields: schemaType.fields
-      },
-      ancestorFields,
-      options
-    })] : [item];
-  });
-}
-function sliceBlocks({
-  context,
-  blocks
-}) {
-  const slice = [];
-  if (!context.selection)
-    return slice;
-  let startBlock;
-  const middleBlocks = [];
-  let endBlock;
-  const 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 (const 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 (const child of block.children) {
-          if (child._key === startChildKey) {
-            if (isSpan(context, child)) {
-              const 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 (const 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);
-  }
-  const 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 {
-  blockOffsetToSpanSelectionPoint,
-  childAtTextOffset,
-  defaultKeyGenerator,
-  getBlockEndPoint,
-  getBlockKeyFromSelectionPoint,
-  getBlockStartPoint,
-  getSelectionEndPoint,
-  getSelectionStartPoint,
-  isEqualPaths,
-  isEqualSelectionPoints,
-  isListBlock,
-  isSelectionCollapsed,
-  parseAnnotation,
-  parseBlock,
-  parseBlocks,
-  parseInlineObject,
-  parseMarkDefs,
-  parseSpan,
-  sliceBlocks,
-  spanSelectionPointToBlockOffset,
-  textOffsetOfChild
-};
-//# sourceMappingURL=util.slice-blocks.js.map