@timbenniks/contentstack-platform-sdk 0.1.0

package/dist/rte/index.cjs

@@ -0,0 +1,683 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/rte/index.ts
+var rte_exports = {};
+__export(rte_exports, {
+  fromHTML: () => fromHTML,
+  toHTML: () => toHTML,
+  toMarkdown: () => toMarkdown,
+  toPlainText: () => toPlainText,
+  transform: () => transform,
+  validate: () => validate
+});
+module.exports = __toCommonJS(rte_exports);
+
+// src/rte/to-html.ts
+var import_json_rte_serializer = require("@contentstack/json-rte-serializer");
+
+// src/rte/utils.ts
+var KNOWN_RTE_TYPES = /* @__PURE__ */ new Set([
+  "doc",
+  "p",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "ul",
+  "ol",
+  "li",
+  "blockquote",
+  "code",
+  "img",
+  "a",
+  "table",
+  "tr",
+  "td",
+  "th",
+  "hr",
+  "reference"
+]);
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function isTextNode(value) {
+  return isRecord(value) && typeof value.text === "string" && typeof value.type !== "string";
+}
+function isElementNode(value) {
+  return isRecord(value) && typeof value.type === "string" && typeof value.uid === "string";
+}
+function decodeHTML(value) {
+  return value.replace(/&nbsp;/g, " ").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&");
+}
+function createUid() {
+  const uuid = globalThis.crypto?.randomUUID;
+  if (typeof uuid === "function") {
+    return uuid.call(globalThis.crypto);
+  }
+  return `rte-${Math.random().toString(36).slice(2, 10)}`;
+}
+
+// src/rte/serializer.ts
+var DEFAULT_TABLE_COLUMN_WIDTH = 250;
+function normalizeForSerializer(doc) {
+  const normalized = normalizeNode(doc);
+  if (!isTextNode(normalized) && normalized.type === "doc") {
+    return normalized;
+  }
+  return {
+    ...doc,
+    children: []
+  };
+}
+function normalizeNode(node) {
+  if (isTextNode(node)) {
+    return { ...node };
+  }
+  const children = node.children?.map((child) => normalizeNode(child));
+  const attrs = isRecord(node.attrs) ? { ...node.attrs } : {};
+  if (node.type === "a" && typeof attrs.url !== "string" && typeof attrs.href === "string") {
+    attrs.url = attrs.href;
+  }
+  if (node.type === "img" && typeof attrs.url !== "string" && typeof attrs.src === "string") {
+    attrs.url = attrs.src;
+  }
+  if (node.type === "table") {
+    const tableRows = (children ?? []).filter(
+      (row) => !isTextNode(row) && row.type === "tr"
+    );
+    const inferredCols = tableRows.reduce((max, row) => {
+      const columnCount = (row.children ?? []).filter(
+        (cell) => !isTextNode(cell) && (cell.type === "td" || cell.type === "th")
+      ).length;
+      return Math.max(max, columnCount);
+    }, 0);
+    const normalizedCols = typeof attrs.cols === "number" && attrs.cols > 0 ? attrs.cols : inferredCols;
+    const normalizedRows = typeof attrs.rows === "number" && attrs.rows > 0 ? attrs.rows : tableRows.length;
+    const normalizedWidths = Array.isArray(attrs.colWidths) && attrs.colWidths.length > 0 && attrs.colWidths.every((width) => typeof width === "number") ? attrs.colWidths : Array.from({ length: Math.max(normalizedCols, 1) }, () => DEFAULT_TABLE_COLUMN_WIDTH);
+    return {
+      ...node,
+      attrs: {
+        ...attrs,
+        rows: normalizedRows,
+        cols: Math.max(normalizedCols, 1),
+        colWidths: normalizedWidths
+      },
+      ...children ? { children } : {}
+    };
+  }
+  return {
+    ...node,
+    attrs,
+    ...children ? { children } : {}
+  };
+}
+
+// src/rte/to-html.ts
+function toHTML(doc, options = {}) {
+  return (0, import_json_rte_serializer.jsonToHtml)(
+    normalizeForSerializer(doc),
+    buildSerializerOptions(options)
+  );
+}
+function buildSerializerOptions(options) {
+  const { renderEntry, renderAsset, serializerOptions } = options;
+  if (!renderEntry && !renderAsset) {
+    return serializerOptions;
+  }
+  const customElementTypes = {
+    ...serializerOptions?.customElementTypes ?? {}
+  };
+  const existingReferenceRenderer = customElementTypes.reference;
+  customElementTypes.reference = (attrs, child, jsonBlock, extraProps) => {
+    const block = asRTENode(jsonBlock);
+    const referenceAttrs = isRecord(block.attrs) ? block.attrs : {};
+    if (referenceAttrs.type === "entry" && renderEntry) {
+      return renderEntry(referenceAttrs, block);
+    }
+    if (referenceAttrs.type === "asset" && renderAsset) {
+      return renderAsset(referenceAttrs, block);
+    }
+    return typeof existingReferenceRenderer === "function" ? existingReferenceRenderer(attrs, child, jsonBlock, extraProps) : "";
+  };
+  return {
+    ...serializerOptions,
+    customElementTypes
+  };
+}
+function asRTENode(value) {
+  if (isRecord(value) && typeof value.type === "string" && typeof value.uid === "string") {
+    return value;
+  }
+  return {
+    type: "reference",
+    uid: "reference"
+  };
+}
+
+// src/rte/to-markdown.ts
+var import_json_rte_serializer2 = require("@contentstack/json-rte-serializer");
+function toMarkdown(doc, options = {}) {
+  const mappedDoc = options.renderEntry || options.renderAsset ? mapReferenceNodes(doc, options) : doc;
+  const markdown = (0, import_json_rte_serializer2.jsonToMarkdown)(normalizeForSerializer(mappedDoc)).trim();
+  return normalizeMarkdownOutput(markdown);
+}
+function mapReferenceNodes(doc, options) {
+  const mapped = mapNode(doc, options);
+  if (isTextNode(mapped)) {
+    return {
+      ...doc,
+      children: []
+    };
+  }
+  return {
+    ...doc,
+    ...mapped,
+    type: "doc",
+    uid: mapped.uid ?? doc.uid
+  };
+}
+function mapNode(node, options) {
+  if (isTextNode(node)) {
+    return { ...node };
+  }
+  if (node.type === "reference") {
+    const attrs = node.attrs ?? {};
+    if (attrs.type === "entry" && options.renderEntry) {
+      return { text: options.renderEntry(attrs, node) };
+    }
+    if (attrs.type === "asset" && options.renderAsset) {
+      return { text: options.renderAsset(attrs, node) };
+    }
+    return { text: "" };
+  }
+  return {
+    ...node,
+    ...node.children ? { children: node.children.map((child) => mapNode(child, options)) } : {}
+  };
+}
+function normalizeMarkdownOutput(markdown) {
+  return markdown.replace(/!\[([^\]]*)\]\s*\n\s*\(([^)\n]+)\)/g, "![$1]($2)");
+}
+
+// src/rte/to-plaintext.ts
+var DOUBLE_BREAK_TYPES = /* @__PURE__ */ new Set([
+  "p",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "blockquote",
+  "code",
+  "ul",
+  "ol",
+  "table"
+]);
+var SINGLE_BREAK_TYPES = /* @__PURE__ */ new Set(["li", "tr", "td", "th"]);
+function toPlainText(doc) {
+  return renderNode(doc).replace(/\n{3,}/g, "\n\n").trim();
+}
+function renderNode(node) {
+  if (isTextNode(node)) {
+    return node.text;
+  }
+  const children = (node.children ?? []).map((child) => renderNode(child)).join("");
+  if (node.type === "doc") {
+    return children;
+  }
+  if (node.type === "img") {
+    const alt = node.attrs?.alt;
+    if (typeof alt === "string" && alt.trim()) {
+      return `${alt}
+
+`;
+    }
+    return "\n";
+  }
+  if (node.type === "a") {
+    const href = node.attrs?.href;
+    const text = children || (typeof href === "string" ? href : "");
+    return text;
+  }
+  if (node.type === "hr") {
+    return "\n";
+  }
+  if (node.type === "reference") {
+    return "";
+  }
+  if (DOUBLE_BREAK_TYPES.has(node.type)) {
+    return `${children}
+
+`;
+  }
+  if (SINGLE_BREAK_TYPES.has(node.type)) {
+    return `${children}
+`;
+  }
+  return children;
+}
+
+// src/rte/from-html.ts
+var import_json_rte_serializer3 = require("@contentstack/json-rte-serializer");
+var VOID_TAGS = /* @__PURE__ */ new Set(["img", "hr", "br", "meta", "link", "input"]);
+function fromHTML(html, options = {}) {
+  const parsed = parseWithSerializer(html, options);
+  if (parsed) {
+    return parsed;
+  }
+  return parseWithFallback(html);
+}
+function parseWithSerializer(html, options) {
+  try {
+    const parsed = (0, import_json_rte_serializer3.htmlToJson)(html, options.serializerOptions);
+    return normalizeDoc(parsed);
+  } catch {
+    return null;
+  }
+}
+function normalizeDoc(value) {
+  if (isRecord(value) && value.type === "doc" && Array.isArray(value.children)) {
+    return {
+      ...value,
+      type: "doc",
+      uid: typeof value.uid === "string" && value.uid.length > 0 ? value.uid : createUid(),
+      children: value.children
+    };
+  }
+  return null;
+}
+function parseWithFallback(html) {
+  const root = parseHTML(html);
+  const children = convertNodes(root.children);
+  return {
+    type: "doc",
+    uid: createUid(),
+    children
+  };
+}
+function parseHTML(html) {
+  const root = {
+    kind: "element",
+    tag: "root",
+    attrs: {},
+    children: []
+  };
+  const stack = [root];
+  const tokenPattern = /<!--[\s\S]*?-->|<\/?[^>]+>|[^<]+/g;
+  const tokens = html.match(tokenPattern) ?? [];
+  for (const token of tokens) {
+    if (!token) {
+      continue;
+    }
+    if (token.startsWith("<!--")) {
+      continue;
+    }
+    if (!token.startsWith("<")) {
+      const text = decodeHTML(token);
+      if (text.length === 0) {
+        continue;
+      }
+      const parent2 = stack[stack.length - 1];
+      if (!parent2) {
+        continue;
+      }
+      parent2.children.push({
+        kind: "text",
+        value: text
+      });
+      continue;
+    }
+    if (token.startsWith("</")) {
+      const closingTag = token.slice(2, -1).trim().toLowerCase();
+      while (stack.length > 1) {
+        const current = stack.pop();
+        if (current?.tag === closingTag) {
+          break;
+        }
+      }
+      continue;
+    }
+    const parsed = parseOpeningTag(token);
+    if (!parsed) {
+      continue;
+    }
+    const parent = stack[stack.length - 1];
+    if (!parent) {
+      continue;
+    }
+    parent.children.push(parsed.element);
+    const isVoid = parsed.selfClosing || VOID_TAGS.has(parsed.element.tag);
+    if (!isVoid) {
+      stack.push(parsed.element);
+    }
+  }
+  return root;
+}
+function parseOpeningTag(token) {
+  const isSelfClosing = token.endsWith("/>");
+  const content = token.slice(1, token.length - (isSelfClosing ? 2 : 1)).trim();
+  if (!content) {
+    return null;
+  }
+  const tagMatch = content.match(/^([a-zA-Z0-9-]+)/);
+  if (!tagMatch?.[1]) {
+    return null;
+  }
+  const tag = tagMatch[1].toLowerCase();
+  const attrs = parseAttributes(content.slice(tag.length).trim());
+  return {
+    element: {
+      kind: "element",
+      tag,
+      attrs,
+      children: []
+    },
+    selfClosing: isSelfClosing
+  };
+}
+function parseAttributes(input) {
+  const attrs = {};
+  const attrPattern = /([:@a-zA-Z0-9_-]+)(?:\s*=\s*("([^"]*)"|'([^']*)'|([^\s"'>/]+)))?/g;
+  let match = attrPattern.exec(input);
+  while (match) {
+    const key = match[1];
+    if (key) {
+      const value = decodeHTML(match[3] ?? match[4] ?? match[5] ?? "");
+      attrs[key] = value;
+    }
+    match = attrPattern.exec(input);
+  }
+  return attrs;
+}
+function convertNodes(nodes, marks = {}) {
+  const output = [];
+  for (const node of nodes) {
+    if (node.kind === "text") {
+      const cleaned = normalizeText(node.value);
+      if (!cleaned) {
+        continue;
+      }
+      output.push({
+        text: cleaned,
+        ...marks.bold ? { bold: true } : {},
+        ...marks.italic ? { italic: true } : {},
+        ...marks.underline ? { underline: true } : {},
+        ...marks.strikethrough ? { strikethrough: true } : {},
+        ...marks.code ? { code: true } : {},
+        ...marks.superscript ? { superscript: true } : {},
+        ...marks.subscript ? { subscript: true } : {}
+      });
+      continue;
+    }
+    output.push(...convertElement(node, marks));
+  }
+  return output;
+}
+function convertElement(element, marks) {
+  switch (element.tag) {
+    case "strong":
+    case "b":
+      return convertNodes(element.children, { ...marks, bold: true });
+    case "em":
+    case "i":
+      return convertNodes(element.children, { ...marks, italic: true });
+    case "u":
+      return convertNodes(element.children, { ...marks, underline: true });
+    case "s":
+    case "strike":
+    case "del":
+      return convertNodes(element.children, { ...marks, strikethrough: true });
+    case "sup":
+      return convertNodes(element.children, { ...marks, superscript: true });
+    case "sub":
+      return convertNodes(element.children, { ...marks, subscript: true });
+    case "code":
+      return convertNodes(element.children, { ...marks, code: true });
+    case "br":
+      return [{ text: "\n" }];
+    case "img":
+      return [
+        {
+          type: "img",
+          uid: createUid(),
+          attrs: {
+            src: element.attrs.src ?? "",
+            alt: element.attrs.alt ?? ""
+          }
+        }
+      ];
+    case "hr":
+      return [
+        {
+          type: "hr",
+          uid: createUid()
+        }
+      ];
+    case "a":
+      return [
+        {
+          type: "a",
+          uid: createUid(),
+          attrs: {
+            href: element.attrs.href ?? "",
+            ...element.attrs.target ? { target: element.attrs.target } : {}
+          },
+          children: convertNodes(element.children)
+        }
+      ];
+    case "reference":
+      return [
+        {
+          type: "reference",
+          uid: createUid(),
+          attrs: {
+            ...element.attrs
+          }
+        }
+      ];
+    case "pre": {
+      const codeText = extractTextContent(element);
+      return [
+        {
+          type: "code",
+          uid: createUid(),
+          children: codeText ? [{ text: codeText }] : []
+        }
+      ];
+    }
+    case "p":
+    case "h1":
+    case "h2":
+    case "h3":
+    case "h4":
+    case "h5":
+    case "h6":
+    case "ul":
+    case "ol":
+    case "li":
+    case "blockquote":
+    case "table":
+    case "tr":
+    case "td":
+    case "th":
+      return [
+        {
+          type: element.tag,
+          uid: createUid(),
+          children: convertNodes(element.children)
+        }
+      ];
+    default:
+      return convertNodes(element.children, marks);
+  }
+}
+function extractTextContent(node) {
+  if (node.kind === "text") {
+    return decodeHTML(node.value);
+  }
+  return node.children.map((child) => extractTextContent(child)).join("");
+}
+function normalizeText(value) {
+  const collapsed = value.replace(/\s+/g, " ");
+  if (collapsed.trim().length === 0) {
+    return " ";
+  }
+  return collapsed;
+}
+
+// src/rte/transform.ts
+function transform(doc, visitors) {
+  const transformed = visitNode(doc, visitors);
+  if (!transformed || isTextNode(transformed) || transformed.type !== "doc") {
+    return {
+      ...doc,
+      children: []
+    };
+  }
+  return transformed;
+}
+function visitNode(node, visitors) {
+  if (isTextNode(node)) {
+    return { ...node };
+  }
+  const nextChildren = (node.children ?? []).map((child) => visitNode(child, visitors)).filter((child) => Boolean(child));
+  const withChildren = {
+    ...node,
+    ...node.children ? { children: nextChildren } : {}
+  };
+  const visitor = visitors[withChildren.type];
+  if (!visitor) {
+    return withChildren;
+  }
+  return visitor(withChildren);
+}
+
+// src/rte/validate.ts
+function validate(doc) {
+  const errors = [];
+  if (!isElementNode(doc)) {
+    errors.push("Document must be an object node with type and uid");
+    return { valid: false, errors };
+  }
+  if (doc.type !== "doc") {
+    errors.push('Document root node must have type "doc"');
+  }
+  if (!Array.isArray(doc.children)) {
+    errors.push('Document root node must include a "children" array');
+  } else {
+    validateChildren(doc.children, "doc.children", errors);
+  }
+  return { valid: errors.length === 0, errors };
+}
+function validateChildren(children, path, errors) {
+  children.forEach((child, index) => {
+    validateNode(child, `${path}[${index}]`, errors);
+  });
+}
+function validateNode(node, path, errors) {
+  if (isTextNode(node)) {
+    if (typeof node.text !== "string") {
+      errors.push(`${path} must have a string text value`);
+    }
+    return;
+  }
+  if (!isElementNode(node)) {
+    errors.push(`${path} must be a valid element node or text node`);
+    return;
+  }
+  validateElementNode(node, path, errors);
+}
+function validateElementNode(node, path, errors) {
+  if (!KNOWN_RTE_TYPES.has(node.type)) {
+    errors.push(`${path}.type "${node.type}" is not a supported RTE node type`);
+  }
+  if (typeof node.uid !== "string" || node.uid.trim().length === 0) {
+    errors.push(`${path}.uid must be a non-empty string`);
+  }
+  if (node.children !== void 0) {
+    if (!Array.isArray(node.children)) {
+      errors.push(`${path}.children must be an array when provided`);
+    } else {
+      validateChildren(node.children, `${path}.children`, errors);
+    }
+  }
+  switch (node.type) {
+    case "img":
+      validateImgNode(node, path, errors);
+      break;
+    case "a":
+      validateAnchorNode(node, path, errors);
+      break;
+    case "reference":
+      validateReferenceNode(node, path, errors);
+      break;
+    case "hr":
+      if (Array.isArray(node.children) && node.children.length > 0) {
+        errors.push(`${path}.children must be empty for hr nodes`);
+      }
+      break;
+  }
+}
+function validateImgNode(node, path, errors) {
+  if (!isRecord(node.attrs) || typeof node.attrs.src !== "string" || node.attrs.src.length === 0) {
+    errors.push(`${path}.attrs.src must be a non-empty string for img nodes`);
+  }
+  if (isRecord(node.attrs) && node.attrs.alt !== void 0 && typeof node.attrs.alt !== "string") {
+    errors.push(`${path}.attrs.alt must be a string when provided`);
+  }
+}
+function validateAnchorNode(node, path, errors) {
+  if (!isRecord(node.attrs) || typeof node.attrs.href !== "string" || node.attrs.href.length === 0) {
+    errors.push(`${path}.attrs.href must be a non-empty string for a nodes`);
+  }
+  if (isRecord(node.attrs) && node.attrs.target !== void 0 && typeof node.attrs.target !== "string") {
+    errors.push(`${path}.attrs.target must be a string when provided`);
+  }
+}
+function validateReferenceNode(node, path, errors) {
+  if (!isRecord(node.attrs)) {
+    errors.push(`${path}.attrs must be present for reference nodes`);
+    return;
+  }
+  const refType = node.attrs.type;
+  if (refType !== "entry" && refType !== "asset") {
+    errors.push(`${path}.attrs.type must be "entry" or "asset" for reference nodes`);
+    return;
+  }
+  if (refType === "entry" && typeof node.attrs["entry-uid"] !== "string") {
+    errors.push(`${path}.attrs["entry-uid"] must be provided for entry references`);
+  }
+  if (refType === "asset" && typeof node.attrs["asset-uid"] !== "string") {
+    errors.push(`${path}.attrs["asset-uid"] must be provided for asset references`);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  fromHTML,
+  toHTML,
+  toMarkdown,
+  toPlainText,
+  transform,
+  validate
+});
+//# sourceMappingURL=index.cjs.map