@superdoc-dev/mcp 0.8.0-next.6 → 0.8.0-next.8

package/dist/index.js

@@ -208942,7 +208942,7 @@ var init_remark_gfm_eZN6yzWQ_es = __esm(() => {
   init_remark_gfm_BhnWr3yf_es();
 });
 
-// ../../packages/superdoc/dist/chunks/src-AnmYYbEU.es.js
+// ../../packages/superdoc/dist/chunks/src-CYTyP_ze.es.js
 function deleteProps(obj, propOrProps) {
   const props = typeof propOrProps === "string" ? [propOrProps] : propOrProps;
   const removeNested = (target, pathParts, index2 = 0) => {
@@ -211411,13 +211411,8 @@ function splitBlockPatch(state, dispatch, editor) {
         atStart = $from.start(d) == $from.pos - ($from.depth - d);
         deflt = defaultBlockAt($from.node(d - 1).contentMatchAt($from.indexAfter(d - 1)));
         const sourceParagraphStyleId = node2.attrs?.paragraphProperties?.styleId;
-        paragraphAttrs = {
-          ...node2.attrs,
-          sdBlockId: null,
-          sdBlockRev: null,
-          paraId: null,
-          textId: null
-        };
+        const extensionAttrs = editor?.extensionService?.attributes ?? [];
+        paragraphAttrs = Attribute2.getSplittedAttributes(extensionAttrs, node2.type.name, node2.attrs);
         paragraphAttrs = clearInheritedLinkedStyleId(paragraphAttrs, editor, { emptyParagraph: atEnd });
         if (atEnd && $from.parent.type.name === "run") {
           if (!isLinkedParagraphStyleId(editor, sourceParagraphStyleId))
@@ -213136,12 +213131,10 @@ function createListBoundaryNavigationPlugin() {
     const paragraph2 = getParagraphContext$1(selection.$from);
     if (!paragraph2 || !isListParagraph(paragraph2.node))
       return false;
-    if (isRtlParagraph$1(paragraph2.node))
-      return false;
     const bounds = getParagraphTextBounds2(paragraph2.node, paragraph2.start);
     if (!bounds)
       return false;
-    const direction = event.key === "ArrowLeft" ? -1 : 1;
+    const direction = isRtlParagraph$1(paragraph2.node) ? event.key === "ArrowRight" ? -1 : 1 : event.key === "ArrowLeft" ? -1 : 1;
     const atLeftBoundary = direction < 0 && selection.from <= bounds.first;
     const atRightBoundary = direction > 0 && selection.from >= bounds.last;
     if (!atLeftBoundary && !atRightBoundary)
@@ -232429,10 +232422,7 @@ function tablesSplitAdapter(editor, input2, options) {
       const rEnd = tr.mapping.slice(mapFrom).map(rowPositions[i4] + tableNode.child(i4).nodeSize);
       tr.delete(rp, rEnd);
     }
-    const newTableAttrs = { ...tableNode.attrs };
-    delete newTableAttrs.sdBlockId;
-    delete newTableAttrs.paraId;
-    delete newTableAttrs.textId;
+    const newTableAttrs = Attribute2.getSplittedAttributes(editor.extensionService?.attributes ?? [], tableNode.type.name, tableNode.attrs);
     const newTable = schema.nodes.table.create(newTableAttrs, secondTableRows);
     const separatorParagraph = createSeparatorParagraph(schema);
     if (!separatorParagraph)
@@ -297501,7 +297491,7 @@ menclose::after {
     return;
   console.log(...args$1);
 }, HEADER_FOOTER_INIT_BUDGET_MS = 200, MAX_ZOOM_WARNING_THRESHOLD = 10, MAX_SELECTION_RECTS_PER_USER = 100, SEMANTIC_RESIZE_DEBOUNCE_MS = 120, MIN_SEMANTIC_CONTENT_WIDTH_PX = 1, GLOBAL_PERFORMANCE, PresentationEditor, ICONS, TEXTS, tableActionsOptions;
-var init_src_AnmYYbEU_es = __esm(() => {
+var init_src_CYTyP_ze_es = __esm(() => {
   init_rolldown_runtime_Bg48TavK_es();
   init_SuperConverter_k7GHkV_c_es();
   init_jszip_C49i9kUs_es();
@@ -300392,8 +300382,14 @@ ${err.toString()}`);
     },
     addAttributes() {
       return {
-        paraId: { rendered: false },
-        textId: { rendered: false },
+        paraId: {
+          rendered: false,
+          keepOnSplit: false
+        },
+        textId: {
+          rendered: false,
+          keepOnSplit: false
+        },
         rsidR: { rendered: false },
         rsidRDefault: { rendered: false },
         rsidP: { rendered: false },
@@ -335362,7 +335358,7 @@ var init_zipper_yaJVJ4z9_es = __esm(() => {
 
 // ../../packages/superdoc/dist/super-editor.es.js
 var init_super_editor_es = __esm(() => {
-  init_src_AnmYYbEU_es();
+  init_src_CYTyP_ze_es();
   init_SuperConverter_k7GHkV_c_es();
   init_jszip_C49i9kUs_es();
   init_xml_js_CqGKpaft_es();
@@ -393979,6 +393975,28 @@ function chainableEditorState2(transaction, state) {
     }
   };
 }
+
+// ../../packages/super-editor/src/editors/v1/core/helpers/getNodeType.js
+function getNodeType2(nameOrType, schema) {
+  if (typeof nameOrType === "string") {
+    if (!schema.nodes[nameOrType]) {
+      throw Error(`There is no node type named '${nameOrType}' in schema.`);
+    }
+    return schema.nodes[nameOrType];
+  }
+  return nameOrType;
+}
+
+// ../../packages/super-editor/src/editors/v1/core/helpers/getMarkType.js
+function getMarkType2(nameOrType, schema) {
+  if (typeof nameOrType === "string") {
+    if (!schema.marks[nameOrType]) {
+      throw Error(`There is no mark type named '${nameOrType}' in schema.`);
+    }
+    return schema.marks[nameOrType];
+  }
+  return nameOrType;
+}
 // ../../packages/super-editor/src/editors/v1/core/helpers/findParentNodeClosestToPos.js
 var findParentNodeClosestToPos2 = ($pos, predicate) => {
   for (let i4 = $pos.depth;i4 > 0; i4--) {
@@ -394037,6 +394055,16 @@ var init_isMarkActive = __esm(() => {
 var init_getMarksBetween = __esm(() => {
   init_getMarkRange();
 });
+
+// ../../packages/super-editor/src/editors/v1/core/helpers/getSchemaTypeNameByName.js
+function getSchemaTypeNameByName2(name, schema) {
+  if (schema.nodes[name])
+    return "node";
+  if (schema.marks[name])
+    return "mark";
+  return null;
+}
+
 // ../../packages/super-editor/src/editors/v1/core/helpers/isNodeActive.js
 var init_isNodeActive = __esm(() => {
   init_objectIncludes();
@@ -432714,6 +432742,19 @@ function normalizeRunProperties2(runProperties) {
 }
 
 // ../../packages/super-editor/src/editors/v1/core/helpers/getMarksFromSelection.js
+function getMarksFromSelection2(state, editor) {
+  return getSelectionFormattingState2(state, editor).resolvedMarks;
+}
+function getSelectionFormattingState2(state, editor) {
+  const { from: from4, to, empty: empty6 } = state.selection;
+  if (empty6) {
+    return getFormattingStateAtPos2(state, state.selection.$head.pos, editor, {
+      storedMarks: state.storedMarks ?? null,
+      includeCursorMarksWithStoredMarks: true
+    });
+  }
+  return getFormattingStateForRange2(state, from4, to, editor);
+}
 function getFormattingStateAtPos2(state, pos, editor, options = {}) {
   const {
     storedMarks = null,
@@ -432770,6 +432811,37 @@ function getFormattingStateAtPos2(state, pos, editor, options = {}) {
     styleRunProperties
   };
 }
+function getFormattingStateForRange2(state, from4, to, editor) {
+  const segments = [];
+  const seen = new Set;
+  state.doc.nodesBetween(from4, to, (node4, pos) => {
+    if (!node4.isText || node4.text?.length === 0)
+      return;
+    const segmentPos = pos + 1;
+    if (seen.has(segmentPos))
+      return;
+    seen.add(segmentPos);
+    segments.push(getFormattingStateAtPos2(state, segmentPos, editor));
+  });
+  if (segments.length === 0) {
+    return getFormattingStateAtPos2(state, from4, editor);
+  }
+  return aggregateFormattingSegments2(state, editor, segments);
+}
+function aggregateFormattingSegments2(state, editor, segments) {
+  const resolvedRunProperties = intersectRunProperties2(segments.map((segment) => segment.resolvedRunProperties));
+  const inlineRunProperties = intersectRunProperties2(segments.map((segment) => segment.inlineRunProperties));
+  const styleRunProperties = intersectRunProperties2(segments.map((segment) => segment.styleRunProperties));
+  const resolvedMarks = createMarksFromRunProperties2(state, resolvedRunProperties, editor);
+  const inlineMarks = createMarksFromRunProperties2(state, inlineRunProperties, editor);
+  return {
+    resolvedMarks: mergeResolvedMarksWithInlineFallback2(resolvedMarks, inlineMarks),
+    inlineMarks,
+    resolvedRunProperties,
+    inlineRunProperties,
+    styleRunProperties
+  };
+}
 function mergeResolvedMarksWithInlineFallback2(resolvedMarks, inlineMarks) {
   if (!resolvedMarks.length)
     return inlineMarks;
@@ -432779,6 +432851,20 @@ function mergeResolvedMarksWithInlineFallback2(resolvedMarks, inlineMarks) {
   const missingInlineMarks = inlineMarks.filter((mark2) => !resolvedMarkNames.has(mark2.type.name));
   return [...resolvedMarks, ...missingInlineMarks];
 }
+function intersectRunProperties2(runPropertiesList) {
+  const filtered = runPropertiesList.filter((props) => props && typeof props === "object");
+  if (filtered.length === 0)
+    return null;
+  const first2 = filtered[0];
+  const intersection3 = {};
+  Object.keys(first2).forEach((key2) => {
+    const serialized = JSON.stringify(first2[key2]);
+    if (filtered.every((props) => JSON.stringify(props[key2]) === serialized)) {
+      intersection3[key2] = first2[key2];
+    }
+  });
+  return Object.keys(intersection3).length ? intersection3 : null;
+}
 function getInheritedRunProperties2($pos, editor, inlineRunProperties) {
   if (!editor) {
     return {
@@ -449506,6 +449592,210 @@ function generateDocxHexId2() {
 }
 var DOCX_HEX_ID_LENGTH2 = 8;
 
+// ../../packages/super-editor/src/editors/v1/core/Attribute.ts
+class Attribute4 {
+  static getAttributesFromExtensions(extensions) {
+    const extensionAttributes = [];
+    const defaultAttribute = {
+      default: null,
+      rendered: true,
+      renderDOM: null,
+      parseDOM: null,
+      keepOnSplit: true
+    };
+    const globalAttributes = this.#getGlobalAttributes(extensions, defaultAttribute);
+    const nodeAndMarksAttributes = this.#getNodeAndMarksAttributes(extensions, defaultAttribute);
+    extensionAttributes.push(...globalAttributes, ...nodeAndMarksAttributes);
+    return extensionAttributes;
+  }
+  static #getGlobalAttributes(extensions, defaultAttribute) {
+    const extensionAttributes = [];
+    const collectAttribute = (globalAttr) => {
+      for (const type of globalAttr.types) {
+        const entries = Object.entries(globalAttr.attributes);
+        for (const [name, attribute] of entries) {
+          extensionAttributes.push({
+            type,
+            name,
+            attribute: {
+              ...defaultAttribute,
+              ...attribute
+            }
+          });
+        }
+      }
+    };
+    for (const extension3 of extensions) {
+      const context = {
+        name: extension3.name,
+        options: extension3.options,
+        storage: extension3.storage
+      };
+      const addGlobalAttributes = getExtensionConfigField2(extension3, "addGlobalAttributes", context);
+      if (!addGlobalAttributes)
+        continue;
+      const globalAttributes = addGlobalAttributes();
+      for (const globalAttr of globalAttributes) {
+        collectAttribute(globalAttr);
+      }
+    }
+    return extensionAttributes;
+  }
+  static #getNodeAndMarksAttributes(extensions, defaultAttribute) {
+    const extensionAttributes = [];
+    const nodeAndMarkExtensions = extensions.filter((e) => {
+      return e.type === "node" || e.type === "mark";
+    });
+    for (const extension3 of nodeAndMarkExtensions) {
+      const context = {
+        name: extension3.name,
+        options: extension3.options,
+        storage: extension3.storage
+      };
+      const addAttributes = getExtensionConfigField2(extension3, "addAttributes", context);
+      if (!addAttributes)
+        continue;
+      const attributes = addAttributes();
+      for (const [name, attribute] of Object.entries(attributes)) {
+        const merged = {
+          ...defaultAttribute,
+          ...attribute
+        };
+        if (typeof merged.default === "function") {
+          merged.default = merged.default();
+        }
+        extensionAttributes.push({
+          type: extension3.name,
+          name,
+          attribute: merged
+        });
+      }
+    }
+    return extensionAttributes;
+  }
+  static insertExtensionAttrsToParseRule(parseRule, extensionAttrs) {
+    if ("style" in parseRule) {
+      return parseRule;
+    }
+    return {
+      ...parseRule,
+      getAttrs: (node4) => {
+        const oldAttrs = parseRule.getAttrs ? parseRule.getAttrs(node4) : parseRule.attrs;
+        if (oldAttrs === false)
+          return false;
+        const parseFromString = (value) => {
+          if (typeof value !== "string")
+            return value;
+          if (value.match(/^[+-]?(\d*\.)?\d+$/))
+            return Number(value);
+          if (value === "true")
+            return true;
+          if (value === "false")
+            return false;
+          return value;
+        };
+        let newAttrs = {};
+        for (const item of extensionAttrs) {
+          const value = item.attribute.parseDOM ? item.attribute.parseDOM(node4) : parseFromString(node4.getAttribute(item.name));
+          if (value === null || value === undefined)
+            continue;
+          newAttrs = {
+            ...newAttrs,
+            [item.name]: value
+          };
+        }
+        return { ...oldAttrs, ...newAttrs };
+      }
+    };
+  }
+  static getAttributesToRender(nodeOrMark, extensionAttrs) {
+    const attributes = extensionAttrs.filter((item) => item.attribute.rendered).map((item) => {
+      if (!item.attribute.renderDOM) {
+        return { [item.name]: nodeOrMark.attrs[item.name] };
+      }
+      return item.attribute.renderDOM(nodeOrMark.attrs) || {};
+    });
+    let mergedAttrs = {};
+    for (const attribute of attributes) {
+      mergedAttrs = this.mergeAttributes(mergedAttrs, attribute);
+    }
+    return mergedAttrs;
+  }
+  static mergeAttributes(...objects) {
+    const items = objects.filter((item) => !!item);
+    let attrs = {};
+    for (const item of items) {
+      const mergedAttributes = { ...attrs };
+      for (const [key2, value] of Object.entries(item)) {
+        const exists = mergedAttributes[key2];
+        if (!exists) {
+          mergedAttributes[key2] = value;
+          continue;
+        }
+        if (key2 === "class") {
+          const valueStr = typeof value === "string" ? value : String(value);
+          const existingStr = typeof mergedAttributes[key2] === "string" ? mergedAttributes[key2] : String(mergedAttributes[key2] || "");
+          const valueClasses = valueStr ? valueStr.split(" ") : [];
+          const existingClasses = existingStr ? existingStr.split(" ") : [];
+          const insertClasses = valueClasses.filter((value2) => !existingClasses.includes(value2));
+          mergedAttributes[key2] = [...existingClasses, ...insertClasses].join(" ");
+        } else if (key2 === "style") {
+          mergedAttributes[key2] = [mergedAttributes[key2], value].join("; ");
+        } else {
+          mergedAttributes[key2] = value;
+        }
+      }
+      attrs = mergedAttributes;
+    }
+    return attrs;
+  }
+  static getSplittedAttributes(extensionAttrs, typeName, attributes) {
+    const entries = Object.entries(attributes).filter(([name]) => {
+      const extensionAttr = extensionAttrs.find((item) => {
+        return item.type === typeName && item.name === name;
+      });
+      if (!extensionAttr)
+        return false;
+      return extensionAttr.attribute.keepOnSplit;
+    });
+    return Object.fromEntries(entries);
+  }
+  static getMarkAttributes(state, typeOrName) {
+    const type = getMarkType2(typeOrName, state.schema);
+    const marks = getMarksFromSelection2(state);
+    const mark2 = marks.find((markItem) => markItem.type.name === type.name);
+    if (!mark2)
+      return {};
+    return { ...mark2.attrs };
+  }
+  static getNodeAttributes(state, typeOrName) {
+    const type = getNodeType2(typeOrName, state.schema);
+    const { from: from4, to } = state.selection;
+    const nodes = [];
+    state.doc.nodesBetween(from4, to, (node5) => {
+      nodes.push(node5);
+    });
+    const node4 = nodes.reverse().find((nodeItem) => nodeItem.type.name === type.name);
+    if (!node4)
+      return {};
+    return { ...node4.attrs };
+  }
+  static getAttributes(state, typeOrName) {
+    const schemaType = getSchemaTypeNameByName2(typeof typeOrName === "string" ? typeOrName : typeOrName.name, state.schema);
+    if (schemaType === "node") {
+      return this.getNodeAttributes(state, typeOrName);
+    }
+    if (schemaType === "mark") {
+      return this.getMarkAttributes(state, typeOrName);
+    }
+    return {};
+  }
+}
+var init_Attribute = __esm(() => {
+  init_getExtensionConfigField();
+  init_getMarksFromSelection();
+});
+
 // ../../packages/super-editor/src/editors/v1/extensions/table/tableHelpers/border-utils.js
 function cloneBorders2(borders, sides) {
   if (!borders || typeof borders !== "object")
@@ -451012,10 +451302,7 @@ function tablesSplitAdapter2(editor, input2, options) {
       const rEnd = tr.mapping.slice(mapFrom).map(rowPositions[i5] + tableNode.child(i5).nodeSize);
       tr.delete(rp, rEnd);
     }
-    const newTableAttrs = { ...tableNode.attrs };
-    delete newTableAttrs.sdBlockId;
-    delete newTableAttrs.paraId;
-    delete newTableAttrs.textId;
+    const newTableAttrs = Attribute4.getSplittedAttributes(editor.extensionService?.attributes ?? [], tableNode.type.name, tableNode.attrs);
     const newTable = schema.nodes.table.create(newTableAttrs, secondTableRows);
     const separatorParagraph = createSeparatorParagraph2(schema);
     if (!separatorParagraph) {
@@ -452845,6 +453132,7 @@ var init_tables_adapter = __esm(() => {
   init_errors4();
   init_node_address_resolver();
   init_ooxml();
+  init_Attribute();
   init_document_settings();
   init_mutate_part();
   init_table_attr_sync();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@superdoc-dev/mcp",
-  "version": "0.8.0-next.6",
+  "version": "0.8.0-next.8",
   "type": "module",
   "engines": {
     "node": ">=20"