@tiptap/static-renderer 3.20.1 → 3.20.3

package/dist/index.js

@@ -1,601 +0,0 @@
-// src/helpers.ts
-import { mergeAttributes } from "@tiptap/core";
-function getAttributes(nodeOrMark, extensionAttributes, onlyRenderedAttributes) {
-  const nodeOrMarkAttributes = nodeOrMark.attrs;
-  if (!nodeOrMarkAttributes) {
-    return {};
-  }
-  return extensionAttributes.filter((item) => {
-    if (item.type !== (typeof nodeOrMark.type === "string" ? nodeOrMark.type : nodeOrMark.type.name)) {
-      return false;
-    }
-    if (onlyRenderedAttributes) {
-      return item.attribute.rendered;
-    }
-    return true;
-  }).map((item) => {
-    if (!item.attribute.renderHTML) {
-      return {
-        [item.name]: item.name in nodeOrMarkAttributes ? nodeOrMarkAttributes[item.name] : item.attribute.default
-      };
-    }
-    return item.attribute.renderHTML(nodeOrMarkAttributes) || {
-      [item.name]: item.name in nodeOrMarkAttributes ? nodeOrMarkAttributes[item.name] : item.attribute.default
-    };
-  }).reduce((attributes, attribute) => mergeAttributes(attributes, attribute), {});
-}
-function getHTMLAttributes(nodeOrMark, extensionAttributes) {
-  return getAttributes(nodeOrMark, extensionAttributes, true);
-}
-
-// src/json/renderer.ts
-function TiptapStaticRenderer(renderComponent, {
-  nodeMapping,
-  markMapping,
-  unhandledNode,
-  unhandledMark
-}) {
-  return function renderContent({
-    content,
-    parent
-  }) {
-    var _a;
-    const nodeType = typeof content.type === "string" ? content.type : content.type.name;
-    const NodeHandler = (_a = nodeMapping[nodeType]) != null ? _a : unhandledNode;
-    if (!NodeHandler) {
-      throw new Error(`missing handler for node type ${nodeType}`);
-    }
-    const nodeContent = renderComponent({
-      component: NodeHandler,
-      props: {
-        node: content,
-        parent,
-        renderElement: renderContent,
-        // Lazily compute the children to avoid unnecessary recursion
-        get children() {
-          const children = [];
-          if (content.content) {
-            content.content.forEach((child) => {
-              children.push(
-                renderContent({
-                  content: child,
-                  parent: content
-                })
-              );
-            });
-          }
-          return children;
-        }
-      }
-    });
-    const markedContent = content.marks ? content.marks.reduce((acc, mark) => {
-      var _a2;
-      const markType = typeof mark.type === "string" ? mark.type : mark.type.name;
-      const MarkHandler = (_a2 = markMapping[markType]) != null ? _a2 : unhandledMark;
-      if (!MarkHandler) {
-        throw new Error(`missing handler for mark type ${markType}`);
-      }
-      return renderComponent({
-        component: MarkHandler,
-        props: {
-          mark,
-          parent,
-          node: content,
-          children: acc
-        }
-      });
-    }, nodeContent) : nodeContent;
-    return markedContent;
-  };
-}
-
-// src/json/html-string/string.ts
-function renderJSONContentToString(options) {
-  return TiptapStaticRenderer((ctx) => {
-    return ctx.component(ctx.props);
-  }, options);
-}
-function serializeAttrsToHTMLString(attrs) {
-  const output = Object.entries(attrs || {}).map(([key, value]) => `${key.split(" ").at(-1)}=${JSON.stringify(value)}`).join(" ");
-  return output ? ` ${output}` : "";
-}
-function serializeChildrenToHTMLString(children) {
-  return [].concat(children || "").filter(Boolean).join("");
-}
-
-// src/json/react/react.ts
-import React from "react";
-function renderJSONContentToReactElement(options) {
-  let key = 0;
-  return TiptapStaticRenderer(({ component, props: { children, ...props } }) => {
-    return React.createElement(
-      component,
-      // eslint-disable-next-line no-plusplus
-      Object.assign(props, { key: key++ }),
-      [].concat(children)
-    );
-  }, options);
-}
-
-// src/pm/extensionRenderer.ts
-import {
-  getAttributesFromExtensions,
-  getExtensionField,
-  getSchemaByResolvedExtensions,
-  resolveExtensions,
-  splitExtensions
-} from "@tiptap/core";
-import { Node } from "@tiptap/pm/model";
-function mapNodeExtensionToReactNode(domOutputSpecToElement, extension, extensionAttributes, options) {
-  const context = {
-    name: extension.name,
-    options: extension.options,
-    storage: extension.storage,
-    parent: extension.parent
-  };
-  const renderToHTML = getExtensionField(extension, "renderHTML", context);
-  if (!renderToHTML) {
-    if (options == null ? void 0 : options.unhandledNode) {
-      return [extension.name, options.unhandledNode];
-    }
-    return [
-      extension.name,
-      () => {
-        throw new Error(
-          `[tiptap error]: Node ${extension.name} cannot be rendered, it is missing a "renderToHTML" method, please implement it or override the corresponding "nodeMapping" method to have a custom rendering`
-        );
-      }
-    ];
-  }
-  return [
-    extension.name,
-    ({ node, children }) => {
-      try {
-        return domOutputSpecToElement(
-          renderToHTML({
-            node,
-            HTMLAttributes: getHTMLAttributes(node, extensionAttributes)
-          })
-        )(children);
-      } catch (e) {
-        throw new Error(
-          `[tiptap error]: Node ${extension.name} cannot be rendered, it's "renderToHTML" method threw an error: ${e.message}`,
-          { cause: e }
-        );
-      }
-    }
-  ];
-}
-function mapMarkExtensionToReactNode(domOutputSpecToElement, extension, extensionAttributes, options) {
-  const context = {
-    name: extension.name,
-    options: extension.options,
-    storage: extension.storage,
-    parent: extension.parent
-  };
-  const renderToHTML = getExtensionField(extension, "renderHTML", context);
-  if (!renderToHTML) {
-    if (options == null ? void 0 : options.unhandledMark) {
-      return [extension.name, options.unhandledMark];
-    }
-    return [
-      extension.name,
-      () => {
-        throw new Error(`Node ${extension.name} cannot be rendered, it is missing a "renderToHTML" method`);
-      }
-    ];
-  }
-  return [
-    extension.name,
-    ({ mark, children }) => {
-      try {
-        return domOutputSpecToElement(
-          renderToHTML({
-            mark,
-            HTMLAttributes: getHTMLAttributes(mark, extensionAttributes)
-          })
-        )(children);
-      } catch (e) {
-        throw new Error(
-          `[tiptap error]: Mark ${extension.name} cannot be rendered, it's "renderToHTML" method threw an error: ${e.message}`,
-          { cause: e }
-        );
-      }
-    }
-  ];
-}
-function renderToElement({
-  renderer,
-  domOutputSpecToElement,
-  mapDefinedTypes,
-  content,
-  extensions,
-  options
-}) {
-  extensions = resolveExtensions(extensions);
-  const extensionAttributes = getAttributesFromExtensions(extensions);
-  const { nodeExtensions, markExtensions } = splitExtensions(extensions);
-  if (!(content instanceof Node)) {
-    content = Node.fromJSON(getSchemaByResolvedExtensions(extensions), content);
-  }
-  return renderer({
-    ...options,
-    nodeMapping: {
-      ...Object.fromEntries(
-        nodeExtensions.filter((e) => {
-          if (e.name in mapDefinedTypes) {
-            return false;
-          }
-          if (options == null ? void 0 : options.nodeMapping) {
-            return !(e.name in options.nodeMapping);
-          }
-          return true;
-        }).map(
-          (nodeExtension) => mapNodeExtensionToReactNode(domOutputSpecToElement, nodeExtension, extensionAttributes, options)
-        )
-      ),
-      ...mapDefinedTypes,
-      ...options == null ? void 0 : options.nodeMapping
-    },
-    markMapping: {
-      ...Object.fromEntries(
-        markExtensions.filter((e) => {
-          if (options == null ? void 0 : options.markMapping) {
-            return !(e.name in options.markMapping);
-          }
-          return true;
-        }).map((mark) => mapMarkExtensionToReactNode(domOutputSpecToElement, mark, extensionAttributes, options))
-      ),
-      ...options == null ? void 0 : options.markMapping
-    }
-  })({ content });
-}
-
-// src/pm/html-string/html-string.ts
-var NON_SELF_CLOSING_TAGS = /* @__PURE__ */ new Set(["iframe", "script", "style", "title", "textarea", "div", "span", "a", "button"]);
-function domOutputSpecToHTMLString(content) {
-  if (typeof content === "string") {
-    return () => content;
-  }
-  if (typeof content === "object" && "length" in content) {
-    const [_tag, attrs, children, ...rest] = content;
-    let tag = _tag;
-    const parts = tag.split(" ");
-    if (parts.length > 1) {
-      tag = `${parts[1]} xmlns="${parts[0]}"`;
-    }
-    if (attrs === void 0) {
-      return () => `<${tag}/>`;
-    }
-    if (attrs === 0) {
-      return (child) => `<${tag}>${serializeChildrenToHTMLString(child)}</${tag}>`;
-    }
-    if (typeof attrs === "object") {
-      if (Array.isArray(attrs)) {
-        if (children === void 0) {
-          return (child) => `<${tag}>${domOutputSpecToHTMLString(attrs)(child)}</${tag}>`;
-        }
-        if (children === 0) {
-          return (child) => `<${tag}>${domOutputSpecToHTMLString(attrs)(child)}</${tag}>`;
-        }
-        return (child) => `<${tag}>${domOutputSpecToHTMLString(attrs)(child)}${[children].concat(rest).map((a) => domOutputSpecToHTMLString(a)(child))}</${tag}>`;
-      }
-      if (children === void 0) {
-        if (NON_SELF_CLOSING_TAGS.has(tag)) {
-          return () => `<${tag}${serializeAttrsToHTMLString(attrs)}></${tag}>`;
-        }
-        return () => `<${tag}${serializeAttrsToHTMLString(attrs)}/>`;
-      }
-      if (children === 0) {
-        return (child) => `<${tag}${serializeAttrsToHTMLString(attrs)}>${serializeChildrenToHTMLString(child)}</${tag}>`;
-      }
-      return (child) => `<${tag}${serializeAttrsToHTMLString(attrs)}>${[children].concat(rest).map((a) => domOutputSpecToHTMLString(a)(child)).join("")}</${tag}>`;
-    }
-  }
-  throw new Error(
-    "[tiptap error]: Unsupported DomOutputSpec type, check the `renderHTML` method output or implement a node mapping",
-    {
-      cause: content
-    }
-  );
-}
-function renderToHTMLString({
-  content,
-  extensions,
-  options
-}) {
-  return renderToElement({
-    renderer: renderJSONContentToString,
-    domOutputSpecToElement: domOutputSpecToHTMLString,
-    mapDefinedTypes: {
-      // Map a doc node to concatenated children
-      doc: ({ children }) => serializeChildrenToHTMLString(children),
-      // Map a text node to its text content
-      text: ({ node }) => {
-        var _a;
-        return (_a = node.text) != null ? _a : "";
-      }
-    },
-    content,
-    extensions,
-    options
-  });
-}
-
-// src/pm/markdown/markdown.ts
-function renderToMarkdown({
-  content,
-  extensions,
-  options
-}) {
-  return renderToHTMLString({
-    content,
-    extensions,
-    options: {
-      ...options,
-      nodeMapping: {
-        bulletList({ children }) {
-          return `
-${serializeChildrenToHTMLString(children)}`;
-        },
-        orderedList({ children }) {
-          return `
-${serializeChildrenToHTMLString(children)}`;
-        },
-        listItem({ node, children, parent }) {
-          if ((parent == null ? void 0 : parent.type.name) === "bulletList") {
-            return `- ${serializeChildrenToHTMLString(children).trim()}
-`;
-          }
-          if ((parent == null ? void 0 : parent.type.name) === "orderedList") {
-            let number = parent.attrs.start || 1;
-            parent.forEach((parentChild, _offset, index) => {
-              if (node === parentChild) {
-                number = index + 1;
-              }
-            });
-            return `${number}. ${serializeChildrenToHTMLString(children).trim()}
-`;
-          }
-          return serializeChildrenToHTMLString(children);
-        },
-        paragraph({ children }) {
-          return `
-${serializeChildrenToHTMLString(children)}
-`;
-        },
-        heading({ node, children }) {
-          const level = node.attrs.level;
-          return `${new Array(level).fill("#").join("")} ${children}
-`;
-        },
-        codeBlock({ node, children }) {
-          return `
-\`\`\`${node.attrs.language}
-${serializeChildrenToHTMLString(children)}
-\`\`\`
-`;
-        },
-        blockquote({ children }) {
-          return `
-${serializeChildrenToHTMLString(children).trim().split("\n").map((a) => `> ${a}`).join("\n")}`;
-        },
-        image({ node }) {
-          return `![${node.attrs.alt}](${node.attrs.src})`;
-        },
-        hardBreak() {
-          return "\n";
-        },
-        horizontalRule() {
-          return "\n---\n";
-        },
-        table({ children, node }) {
-          if (!Array.isArray(children)) {
-            return `
-${serializeChildrenToHTMLString(children)}
-`;
-          }
-          const columnCount = node.children[0].childCount;
-          return `
-${serializeChildrenToHTMLString(children[0])}| ${new Array(columnCount).fill("---").join(" | ")} |
-${serializeChildrenToHTMLString(children.slice(1))}
-`;
-        },
-        tableRow({ children }) {
-          if (Array.isArray(children)) {
-            return `| ${children.join(" | ")} |
-`;
-          }
-          return `${serializeChildrenToHTMLString(children)}
-`;
-        },
-        tableHeader({ children }) {
-          return serializeChildrenToHTMLString(children).trim();
-        },
-        tableCell({ children }) {
-          return serializeChildrenToHTMLString(children).trim();
-        },
-        ...options == null ? void 0 : options.nodeMapping
-      },
-      markMapping: {
-        bold({ children }) {
-          return `**${serializeChildrenToHTMLString(children)}**`;
-        },
-        italic({ children, node }) {
-          let isBoldToo = false;
-          if (node == null ? void 0 : node.marks.some((m) => m.type.name === "bold")) {
-            isBoldToo = true;
-          }
-          if (isBoldToo) {
-            return `*${serializeChildrenToHTMLString(children)}*`;
-          }
-          return `_${serializeChildrenToHTMLString(children)}_`;
-        },
-        code({ children }) {
-          return `\`${serializeChildrenToHTMLString(children)}\``;
-        },
-        strike({ children }) {
-          return `~~${serializeChildrenToHTMLString(children)}~~`;
-        },
-        underline({ children }) {
-          return `<u>${serializeChildrenToHTMLString(children)}</u>`;
-        },
-        subscript({ children }) {
-          return `<sub>${serializeChildrenToHTMLString(children)}</sub>`;
-        },
-        superscript({ children }) {
-          return `<sup>${serializeChildrenToHTMLString(children)}</sup>`;
-        },
-        link({ mark, children }) {
-          return `[${serializeChildrenToHTMLString(children)}](${mark.attrs.href})`;
-        },
-        highlight({ children }) {
-          return `==${serializeChildrenToHTMLString(children)}==`;
-        },
-        ...options == null ? void 0 : options.markMapping
-      }
-    }
-  });
-}
-
-// src/pm/react/react.ts
-import React2 from "react";
-function mapAttrsToHTMLAttributes(attrs, key) {
-  if (!attrs) {
-    return { key };
-  }
-  return Object.entries(attrs).reduce(
-    (acc, [name, value]) => {
-      if (name === "class") {
-        return Object.assign(acc, { className: value });
-      }
-      if (name === "style" && typeof value === "string") {
-        const styleObject = {};
-        value.split(";").forEach((style) => {
-          const [styleKey, val] = style.split(":");
-          if (styleKey && val) {
-            const camelCaseKey = styleKey.trim().replace(/-([a-z])/g, (g) => g[1].toUpperCase());
-            styleObject[camelCaseKey] = val.trim();
-          }
-        });
-        return Object.assign(acc, { style: styleObject });
-      }
-      return Object.assign(acc, { [name]: value });
-    },
-    { key }
-  );
-}
-function domOutputSpecToReactElement(content, key = 0) {
-  if (typeof content === "string") {
-    return () => content;
-  }
-  if (typeof content === "object" && "length" in content) {
-    let [tag, attrs, children, ...rest] = content;
-    const parts = tag.split(" ");
-    if (parts.length > 1) {
-      tag = parts[1];
-      if (attrs === void 0) {
-        attrs = {
-          xmlns: parts[0]
-        };
-      }
-      if (attrs === 0) {
-        attrs = {
-          xmlns: parts[0]
-        };
-        children = 0;
-      }
-      if (typeof attrs === "object") {
-        attrs = Object.assign(attrs, { xmlns: parts[0] });
-      }
-    }
-    if (attrs === void 0) {
-      return () => React2.createElement(tag, mapAttrsToHTMLAttributes(void 0, key.toString()));
-    }
-    if (attrs === 0) {
-      return (child) => React2.createElement(tag, mapAttrsToHTMLAttributes(void 0, key.toString()), child);
-    }
-    if (typeof attrs === "object") {
-      if (Array.isArray(attrs)) {
-        if (children === void 0) {
-          return (child) => React2.createElement(
-            tag,
-            mapAttrsToHTMLAttributes(void 0, key.toString()),
-            domOutputSpecToReactElement(attrs, key++)(child)
-          );
-        }
-        if (children === 0) {
-          return (child) => React2.createElement(
-            tag,
-            mapAttrsToHTMLAttributes(void 0, key.toString()),
-            domOutputSpecToReactElement(attrs, key++)(child)
-          );
-        }
-        return (child) => React2.createElement(
-          tag,
-          mapAttrsToHTMLAttributes(void 0, key.toString()),
-          domOutputSpecToReactElement(attrs)(child),
-          [children].concat(rest).map((outputSpec) => domOutputSpecToReactElement(outputSpec, key++)(child))
-        );
-      }
-      if (children === void 0) {
-        return () => React2.createElement(tag, mapAttrsToHTMLAttributes(attrs, key.toString()));
-      }
-      if (children === 0) {
-        return (child) => React2.createElement(tag, mapAttrsToHTMLAttributes(attrs, key.toString()), child);
-      }
-      return (child) => React2.createElement(
-        tag,
-        mapAttrsToHTMLAttributes(attrs, key.toString()),
-        [children].concat(rest).map((outputSpec) => domOutputSpecToReactElement(outputSpec, key++)(child))
-      );
-    }
-  }
-  throw new Error(
-    "[tiptap error]: Unsupported DomOutputSpec type, check the `renderHTML` method output or implement a node mapping",
-    {
-      cause: content
-    }
-  );
-}
-function renderToReactElement({
-  content,
-  extensions,
-  options
-}) {
-  return renderToElement({
-    renderer: renderJSONContentToReactElement,
-    domOutputSpecToElement: domOutputSpecToReactElement,
-    mapDefinedTypes: {
-      // Map a doc node to concatenated children
-      doc: ({ children }) => React2.createElement(React2.Fragment, {}, children),
-      // Map a text node to its text content
-      text: ({ node }) => {
-        var _a;
-        return (_a = node.text) != null ? _a : "";
-      }
-    },
-    content,
-    extensions,
-    options
-  });
-}
-export {
-  TiptapStaticRenderer,
-  domOutputSpecToHTMLString,
-  domOutputSpecToReactElement,
-  getAttributes,
-  getHTMLAttributes,
-  mapAttrsToHTMLAttributes,
-  mapMarkExtensionToReactNode,
-  mapNodeExtensionToReactNode,
-  renderJSONContentToReactElement,
-  renderJSONContentToString,
-  renderToElement,
-  renderToHTMLString,
-  renderToMarkdown,
-  renderToReactElement,
-  serializeAttrsToHTMLString,
-  serializeChildrenToHTMLString
-};
-//# sourceMappingURL=index.js.map