@harbour-enterprises/superdoc 0.18.1-next.2 → 0.19.0-next.1

package/dist/superdoc.umd.js

@@ -54901,8 +54901,307 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     }
     node2.elements = next;
   }
+  function createRelationshipsValidator({ editor, logger }) {
+    return () => {
+      const results = [];
+      let modified = false;
+      const convertedXml = editor?.converter?.convertedXml;
+      if (!convertedXml || typeof convertedXml !== "object") {
+        return { results, modified };
+      }
+      const { relsKey, wasNormalized } = findAndNormalizeRelationshipsFile(convertedXml, results);
+      if (!relsKey) {
+        return { results, modified };
+      }
+      if (wasNormalized) modified = true;
+      const { root: root2, wasFixed } = validateRelationshipsRoot(convertedXml[relsKey], relsKey, results);
+      if (!root2) {
+        return { results, modified };
+      }
+      if (wasFixed) modified = true;
+      const wasCleaned = cleanupRootChildren(root2);
+      if (wasCleaned) modified = true;
+      const { filteredIds, binMediaTargets, wasProcessed } = processRelationships(root2, convertedXml, results);
+      if (wasProcessed) modified = true;
+      const wasDocumentFixed = fixMissingDocumentRefs(convertedXml, filteredIds, results, logger);
+      if (wasDocumentFixed) modified = true;
+      const contentTypesKey = "[Content_Types].xml";
+      const contentTypesXml = convertedXml[contentTypesKey];
+      if (binMediaTargets.size > 0 || contentTypesXml) {
+        const wasContentTypesUpdated = updateContentTypes(convertedXml, binMediaTargets, results);
+        if (wasContentTypesUpdated) modified = true;
+      } else {
+        results.push("[Content_Types].xml not found or not parseable. Skipped content types patch.");
+      }
+      return { results, modified };
+    };
+  }
+  function findAndNormalizeRelationshipsFile(convertedXml, results) {
+    const candidateKeys = [
+      "word/_rels/document.xml.rels",
+      "word/document.xml.rels",
+      "_rels/document.xml.rels",
+      "document.xml.rels"
+    ];
+    const relsKey = candidateKeys.find((k) => convertedXml?.[k]?.elements);
+    if (!relsKey) return { relsKey: null, wasNormalized: false };
+    const canonicalKey = "word/_rels/document.xml.rels";
+    if (relsKey !== canonicalKey) {
+      convertedXml[canonicalKey] = convertedXml[relsKey];
+      delete convertedXml[relsKey];
+      results.push(`Normalized relationships location to ${canonicalKey} (was ${relsKey})`);
+      return { relsKey: canonicalKey, wasNormalized: true };
+    }
+    return { relsKey, wasNormalized: false };
+  }
+  function validateRelationshipsRoot(relsTree, relsKey, results) {
+    const root2 = relsTree?.elements?.[0];
+    if (!root2 || root2.type !== "element") {
+      results.push(`${relsKey} is not a valid xml`);
+      return { root: null, wasFixed: false };
+    }
+    const RELS_NS = "http://schemas.openxmlformats.org/package/2006/relationships";
+    let wasFixed = false;
+    if (root2.name !== "Relationships") {
+      root2.name = "Relationships";
+      results.push(`Fixed relationships root element name to "Relationships"`);
+      wasFixed = true;
+    }
+    root2.attributes = root2.attributes || {};
+    if (root2.attributes.xmlns !== RELS_NS) {
+      root2.attributes.xmlns = RELS_NS;
+      results.push(`Set relationships xmlns to ${RELS_NS}`);
+      wasFixed = true;
+    }
+    return { root: root2, wasFixed };
+  }
+  function cleanupRootChildren(root2, results) {
+    const validChildren = root2.elements?.filter((child) => child?.type === "element" && child.name === "Relationship") || [];
+    if (root2.elements?.length !== validChildren.length) {
+      root2.elements = validChildren;
+      return true;
+    }
+    return false;
+  }
+  function processRelationships(root2, convertedXml, results) {
+    const binMediaTargets = /* @__PURE__ */ new Set();
+    const filteredIds = /* @__PURE__ */ new Set();
+    let wasProcessed = false;
+    const ridNum = (id) => {
+      const m2 = /^rId(\d+)$/.exec(String(id || ""));
+      return m2 ? parseInt(m2[1], 10) : null;
+    };
+    const isType2 = (type2, tail) => typeof type2 === "string" && new RegExp(`/relationships/${tail}$`, "i").test(type2);
+    const isHyperlinkType = (type2) => isType2(type2, "hyperlink");
+    const isImageType = (type2) => isType2(type2, "image");
+    const looksExternal = (target) => /^https?:\/\//i.test(target || "") || /^mailto:/i.test(target || "");
+    const usedIds = /* @__PURE__ */ new Set();
+    let maxRid = 0;
+    for (const el of root2.elements) {
+      el.attributes = el.attributes || {};
+      const id = el.attributes.Id;
+      const n = ridNum(id);
+      if (Number.isInteger(n)) maxRid = Math.max(maxRid, n);
+      if (typeof id === "string" && id) {
+        usedIds.add(id);
+      }
+    }
+    let ridCounter = maxRid;
+    const allocateId = (preferred) => {
+      let newId;
+      do {
+        ridCounter += 1;
+        newId = `rId${ridCounter}`;
+      } while (usedIds.has(newId));
+      usedIds.add(newId);
+      return newId;
+    };
+    const seenIds = /* @__PURE__ */ new Set();
+    const filtered = [];
+    function extractStringAttr(attrs, key) {
+      return typeof attrs[key] === "string" ? attrs[key].trim() : "";
+    }
+    for (const rel of root2.elements) {
+      rel.attributes = rel.attributes || {};
+      const attrs = rel.attributes;
+      let id = extractStringAttr(attrs, "Id");
+      const type2 = extractStringAttr(attrs, "Type");
+      let target = extractStringAttr(attrs, "Target");
+      let targetMode = extractStringAttr(attrs, "TargetMode");
+      if (!target) {
+        results.push(`Removed relationship "${id}" without Target`);
+        wasProcessed = true;
+        continue;
+      }
+      if (isHyperlinkType(type2) && looksExternal(target) && targetMode.toLowerCase() !== "external") {
+        attrs.TargetMode = "External";
+        targetMode = "External";
+        results.push(`Set TargetMode="External" for hyperlink ${id}`);
+        wasProcessed = true;
+      }
+      if (isImageType(type2)) {
+        const relPath = `word/${target.replace(/^\.?\//, "")}`;
+        if (/^media\/.+\.bin$/i.test(target) && relPath in convertedXml) {
+          binMediaTargets.add(`/${relPath}`);
+        }
+      }
+      if (targetMode.toLowerCase() !== "external" && !looksExternal(target)) {
+        const likelyPath = `word/${target.replace(/^\.?\//, "")}`;
+        if (!(likelyPath in convertedXml)) {
+          if (!isImageType(type2)) {
+            results.push(`Removed relationship ${id} with missing target: ${target}`);
+            wasProcessed = true;
+            continue;
+          } else {
+            results.push(`Warning: image relationship ${id} target not found: ${target}.`);
+          }
+        }
+      }
+      if (!id) {
+        const newId = allocateId();
+        attrs.Id = newId;
+        results.push(`Assigned missing Id "${newId}"`);
+        wasProcessed = true;
+        id = newId;
+      }
+      if (seenIds.has(id)) {
+        results.push(`Removed duplicate relationship with ID "${id}"`);
+        wasProcessed = true;
+        continue;
+      }
+      seenIds.add(id);
+      filtered.push(rel);
+    }
+    if (root2.elements.length !== filtered.length) {
+      root2.elements = filtered;
+      wasProcessed = true;
+    } else {
+      const contentChanged = root2.elements.some((el, i2) => el !== filtered[i2]);
+      if (contentChanged) {
+        root2.elements = filtered;
+        wasProcessed = true;
+      }
+    }
+    for (const rel of root2.elements) {
+      const id = rel.attributes?.Id;
+      if (typeof id === "string" && id) {
+        filteredIds.add(id);
+      }
+    }
+    return { filteredIds, binMediaTargets, wasProcessed };
+  }
+  function fixMissingDocumentRefs(convertedXml, filteredIds, results, logger) {
+    const documentPath = "word/document.xml";
+    const document2 = convertedXml[documentPath];
+    if (document2?.elements?.length) {
+      const documentRoot = document2.elements[0];
+      if (documentRoot?.type === "element") {
+        const missingRefs = [];
+        processDocumentForMissingRefs(documentRoot, filteredIds, missingRefs);
+        if (missingRefs.length) {
+          results.push(`Fixed ${missingRefs.length} missing relationship references`);
+          logger?.debug?.(`Fixed ${missingRefs.length} missing relationship references in document`);
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+  function updateContentTypes(convertedXml, binMediaTargets, results) {
+    const contentTypesKey = "[Content_Types].xml";
+    const contentTypesXml = convertedXml[contentTypesKey];
+    if (typeof contentTypesXml === "string") {
+      return updateContentTypesString(contentTypesXml, binMediaTargets, results, convertedXml, contentTypesKey);
+    } else if (contentTypesXml?.elements?.length) {
+      return updateContentTypesElements(contentTypesXml, binMediaTargets, results);
+    } else {
+      return false;
+    }
+  }
+  function updateContentTypesString(contentTypesXml, binMediaTargets, results, convertedXml, contentTypesKey) {
+    const CONTENT_TYPES_NS = '<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types">';
+    const ensureDefault = (xmlString, ext, contentType) => {
+      const defRe = new RegExp(`<Default\\s+Extension="${ext}"\\b`, "i");
+      if (defRe.test(xmlString)) return xmlString;
+      return xmlString.replace(
+        CONTENT_TYPES_NS,
+        `${CONTENT_TYPES_NS}<Default Extension="${ext}" ContentType="${contentType}"/>`
+      );
+    };
+    const ensureOverride = (xmlString, partName, contentType) => {
+      const esc = partName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      const ovRe = new RegExp(`<Override\\s+PartName="${esc}"\\b`, "i");
+      if (ovRe.test(xmlString)) return xmlString;
+      return xmlString.replace(
+        CONTENT_TYPES_NS,
+        `${CONTENT_TYPES_NS}<Override PartName="${partName}" ContentType="${contentType}" />`
+      );
+    };
+    let updated = contentTypesXml;
+    updated = ensureDefault(updated, "rels", "application/vnd.openxmlformats-package.relationships+xml");
+    updated = ensureDefault(updated, "xml", "application/xml");
+    for (const partName of binMediaTargets) {
+      updated = ensureOverride(updated, partName, "image/png");
+      results.push(`Added Content Types Override for "${partName}" as image/png`);
+    }
+    if (updated !== contentTypesXml) {
+      convertedXml[contentTypesKey] = updated;
+      return true;
+    }
+    return false;
+  }
+  function updateContentTypesElements(contentTypesXml, binMediaTargets, results) {
+    const typesRoot = contentTypesXml.elements.find((el) => el.name === "Types") || contentTypesXml.elements[0];
+    typesRoot.elements = typesRoot.elements || [];
+    const hasDefault = (ext) => typesRoot.elements.some((el) => el.name === "Default" && el.attributes?.Extension === ext);
+    const addDefault = (ext, ct) => {
+      typesRoot.elements.unshift({
+        type: "element",
+        name: "Default",
+        attributes: { Extension: ext, ContentType: ct }
+      });
+    };
+    const hasOverride = (part) => typesRoot.elements.some((el) => el.name === "Override" && el.attributes?.PartName === part);
+    const addOverride = (part, ct) => {
+      typesRoot.elements.unshift({
+        type: "element",
+        name: "Override",
+        attributes: { PartName: part, ContentType: ct }
+      });
+    };
+    let wasUpdated = false;
+    if (!hasDefault("rels")) {
+      addDefault("rels", "application/vnd.openxmlformats-package.relationships+xml");
+      wasUpdated = true;
+    }
+    if (!hasDefault("xml")) {
+      addDefault("xml", "application/xml");
+      wasUpdated = true;
+    }
+    for (const partName of binMediaTargets) {
+      if (!hasOverride(partName)) {
+        addOverride(partName, "image/png");
+        results.push(`Added Content Types Override for "${partName}" as image/png`);
+        wasUpdated = true;
+      }
+    }
+    return wasUpdated;
+  }
+  function processDocumentForMissingRefs(node2, usedIds, fixed) {
+    if (!node2?.elements?.length) return;
+    for (const element of node2.elements) {
+      if (element?.type !== "element") continue;
+      const rIdValue = element.attributes?.["r:id"];
+      if (typeof rIdValue === "string" && !usedIds.has(rIdValue)) {
+        delete element.attributes["r:id"];
+        fixed.push(`Removed invalid r:id="${rIdValue}"`);
+      }
+      processDocumentForMissingRefs(element, usedIds, fixed);
+    }
+  }
   const XmlValidators = {
-    numberingValidator: createNumberingValidator
+    numberingValidator: createNumberingValidator,
+    relationshipsValidator: createRelationshipsValidator
   };
   class SuperValidator {
     /**