@tiptap/static-renderer 3.0.0-next.1

package/dist/pm/html-string/index.cjs

@@ -0,0 +1,359 @@
+"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/pm/html-string/index.ts
+var html_string_exports = {};
+__export(html_string_exports, {
+  domOutputSpecToHTMLString: () => domOutputSpecToHTMLString,
+  mapMarkExtensionToReactNode: () => mapMarkExtensionToReactNode,
+  mapNodeExtensionToReactNode: () => mapNodeExtensionToReactNode,
+  renderToElement: () => renderToElement,
+  renderToHTMLString: () => renderToHTMLString,
+  serializeAttrsToHTMLString: () => serializeAttrsToHTMLString,
+  serializeChildrenToHTMLString: () => serializeChildrenToHTMLString
+});
+module.exports = __toCommonJS(html_string_exports);
+
+// src/pm/extensionRenderer.ts
+var import_core2 = require("@tiptap/core");
+var import_model = require("@tiptap/pm/model");
+
+// src/helpers.ts
+var import_core = require("@tiptap/core");
+function getAttributes(nodeOrMark, extensionAttributes, onlyRenderedAttributes) {
+  const nodeOrMarkAttributes = nodeOrMark.attrs;
+  if (!nodeOrMarkAttributes) {
+    return {};
+  }
+  return extensionAttributes.filter((item) => {
+    if (item.type !== nodeOrMark.type) {
+      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) => (0, import_core.mergeAttributes)(attributes, attribute), {});
+}
+function getHTMLAttributes(nodeOrMark, extensionAttributes) {
+  return getAttributes(nodeOrMark, extensionAttributes, true);
+}
+
+// src/pm/extensionRenderer.ts
+function mapNodeExtensionToReactNode(domOutputSpecToElement, extension, extensionAttributes, options) {
+  const context = {
+    name: extension.name,
+    options: extension.options,
+    storage: extension.storage,
+    parent: extension.parent
+  };
+  const renderToHTML = (0, import_core2.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 = (0, import_core2.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 = (0, import_core2.resolveExtensions)(extensions);
+  const extensionAttributes = (0, import_core2.getAttributesFromExtensions)(extensions);
+  const { nodeExtensions, markExtensions } = (0, import_core2.splitExtensions)(extensions);
+  if (!(content instanceof import_model.Node)) {
+    content = import_model.Node.fromJSON((0, import_core2.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/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);
+}
+
+// src/pm/html-string/html-string.ts
+function serializeAttrsToHTMLString(attrs) {
+  const output = Object.entries(attrs).map(([key, value]) => `${key}=${JSON.stringify(value)}`).join(" ");
+  return output ? ` ${output}` : "";
+}
+function serializeChildrenToHTMLString(children) {
+  return [].concat(children || "").filter(Boolean).join("");
+}
+function domOutputSpecToHTMLString(content) {
+  if (typeof content === "string") {
+    return () => content;
+  }
+  if (typeof content === "object" && "length" in content) {
+    const [tag, attrs, children, ...rest] = content;
+    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) {
+        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",
+    {
+      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
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  domOutputSpecToHTMLString,
+  mapMarkExtensionToReactNode,
+  mapNodeExtensionToReactNode,
+  renderToElement,
+  renderToHTMLString,
+  serializeAttrsToHTMLString,
+  serializeChildrenToHTMLString
+});
+//# sourceMappingURL=index.cjs.map

package/dist/pm/html-string/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/pm/html-string/index.ts","../../../src/pm/extensionRenderer.ts","../../../src/helpers.ts","../../../src/json/renderer.ts","../../../src/json/html-string/string.ts","../../../src/pm/html-string/html-string.ts"],"sourcesContent":["export * from '../extensionRenderer.js'\nexport * from './html-string.js'\n","/* eslint-disable no-plusplus */\n/* eslint-disable @typescript-eslint/no-explicit-any */\n\nimport {\n  ExtensionAttribute,\n  Extensions,\n  getAttributesFromExtensions,\n  getExtensionField,\n  getSchemaByResolvedExtensions,\n  JSONContent,\n  Mark as MarkExtension,\n  MarkConfig,\n  Node as NodeExtension,\n  NodeConfig,\n  resolveExtensions,\n  splitExtensions,\n} from '@tiptap/core'\nimport { DOMOutputSpec, Mark, Node } from '@tiptap/pm/model'\n\nimport { getHTMLAttributes } from '../helpers.js'\nimport { MarkProps, NodeProps, TiptapStaticRendererOptions } from '../json/renderer.js'\n\nexport type DomOutputSpecToElement<T> = (content: DOMOutputSpec) => (children?: T | T[]) => T;\n\n/**\n * This takes a NodeExtension and maps it to a React component\n * @param extension The node extension to map to a React component\n * @param extensionAttributes All available extension attributes\n * @returns A tuple with the name of the extension and a React component that renders the extension\n */\nexport function mapNodeExtensionToReactNode<T>(\n  domOutputSpecToElement: DomOutputSpecToElement<T>,\n  extension: NodeExtension,\n  extensionAttributes: ExtensionAttribute[],\n  options?: Partial<Pick<TiptapStaticRendererOptions<T, Mark, Node>, 'unhandledNode'>>,\n): [string, (props: NodeProps<Node, T | T[]>) => T] {\n  const context = {\n    name: extension.name,\n    options: extension.options,\n    storage: extension.storage,\n    parent: extension.parent,\n  }\n\n  const renderToHTML = getExtensionField<NodeConfig['renderHTML']>(\n    extension,\n    'renderHTML',\n    context,\n  )\n\n  if (!renderToHTML) {\n    if (options?.unhandledNode) {\n      return [extension.name, options.unhandledNode]\n    }\n    return [\n      extension.name,\n      () => {\n        throw new Error(\n          `[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`,\n        )\n      },\n    ]\n  }\n\n  return [\n    extension.name,\n    ({ node, children }) => {\n      try {\n        return domOutputSpecToElement(\n          renderToHTML({\n            node,\n            HTMLAttributes: getHTMLAttributes(node, extensionAttributes),\n          }),\n        )(children)\n      } catch (e) {\n        throw new Error(\n          `[tiptap error]: Node ${\n            extension.name\n          } cannot be rendered, it's \"renderToHTML\" method threw an error: ${(e as Error).message}`,\n          { cause: e },\n        )\n      }\n    },\n  ]\n}\n\n/**\n * This takes a MarkExtension and maps it to a React component\n * @param extension The mark extension to map to a React component\n * @param extensionAttributes All available extension attributes\n * @returns A tuple with the name of the extension and a React component that renders the extension\n */\nexport function mapMarkExtensionToReactNode<T>(\n  domOutputSpecToElement: DomOutputSpecToElement<T>,\n  extension: MarkExtension,\n  extensionAttributes: ExtensionAttribute[],\n  options?: Partial<Pick<TiptapStaticRendererOptions<T, Mark, Node>, 'unhandledMark'>>,\n): [string, (props: MarkProps<Mark, T | T[]>) => T] {\n  const context = {\n    name: extension.name,\n    options: extension.options,\n    storage: extension.storage,\n    parent: extension.parent,\n  }\n\n  const renderToHTML = getExtensionField<MarkConfig['renderHTML']>(\n    extension,\n    'renderHTML',\n    context,\n  )\n\n  if (!renderToHTML) {\n    if (options?.unhandledMark) {\n      return [extension.name, options.unhandledMark]\n    }\n    return [\n      extension.name,\n      () => {\n        throw new Error(\n          `Node ${extension.name} cannot be rendered, it is missing a \"renderToHTML\" method`,\n        )\n      },\n    ]\n  }\n\n  return [\n    extension.name,\n    ({ mark, children }) => {\n      try {\n        return domOutputSpecToElement(\n          renderToHTML({\n            mark,\n            HTMLAttributes: getHTMLAttributes(mark, extensionAttributes),\n          }),\n        )(children)\n      } catch (e) {\n        throw new Error(\n          `[tiptap error]: Mark ${\n            extension.name\n          } cannot be rendered, it's \"renderToHTML\" method threw an error: ${(e as Error).message}`,\n          { cause: e },\n        )\n      }\n    },\n  ]\n}\n\n/**\n * This function will statically render a Prosemirror Node to a target element type using the given extensions\n * @param renderer The renderer to use to render the Prosemirror Node to the target element type\n * @param domOutputSpecToElement A function that takes a Prosemirror DOMOutputSpec and returns a function that takes children and returns the target element type\n * @param mapDefinedTypes An object with functions to map the doc and text types to the target element type\n * @param content The Prosemirror Node to render\n * @param extensions The extensions to use to render the Prosemirror Node\n * @param options Additional options to pass to the renderer that can override the default behavior\n * @returns The rendered target element type\n */\nexport function renderToElement<T>({\n  renderer,\n  domOutputSpecToElement,\n  mapDefinedTypes,\n  content,\n  extensions,\n  options,\n}: {\n  renderer: (options: TiptapStaticRendererOptions<T, Mark, Node>) => (ctx: { content: Node }) => T;\n  domOutputSpecToElement: DomOutputSpecToElement<T>;\n  mapDefinedTypes: {\n    doc: (props: NodeProps<Node, T | T[]>) => T;\n    text: (props: NodeProps<Node, T | T[]>) => T;\n  };\n  content: Node | JSONContent;\n  extensions: Extensions;\n  options?: Partial<TiptapStaticRendererOptions<T, Mark, Node>>;\n}): T {\n  // get all extensions in order & split them into nodes and marks\n  extensions = resolveExtensions(extensions)\n  const extensionAttributes = getAttributesFromExtensions(extensions)\n  const { nodeExtensions, markExtensions } = splitExtensions(extensions)\n\n  if (!(content instanceof Node)) {\n    content = Node.fromJSON(getSchemaByResolvedExtensions(extensions), content)\n  }\n\n  return renderer({\n    ...options,\n    nodeMapping: {\n      ...Object.fromEntries(\n        nodeExtensions\n          .filter(e => {\n            if (e.name in mapDefinedTypes) {\n              // These are predefined types that we don't need to map\n              return false\n            }\n            // No need to generate mappings for nodes that are already mapped\n            if (options?.nodeMapping) {\n              return !(e.name in options.nodeMapping)\n            }\n            return true\n          })\n          .map(nodeExtension => mapNodeExtensionToReactNode<T>(\n            domOutputSpecToElement,\n            nodeExtension,\n            extensionAttributes,\n            options,\n          )),\n      ),\n      ...mapDefinedTypes,\n      ...options?.nodeMapping,\n    },\n    markMapping: {\n      ...Object.fromEntries(\n        markExtensions\n          .filter(e => {\n            // No need to generate mappings for marks that are already mapped\n            if (options?.markMapping) {\n              return !(e.name in options.markMapping)\n            }\n            return true\n          })\n          .map(mark => mapMarkExtensionToReactNode<T>(\n            domOutputSpecToElement,\n            mark,\n            extensionAttributes,\n            options,\n          )),\n      ),\n      ...options?.markMapping,\n    },\n  })({ content })\n}\n","/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { ExtensionAttribute, mergeAttributes } from '@tiptap/core'\n\nimport type { MarkType, NodeType } from './types'\n\n/**\n * This function returns the attributes of a node or mark that are defined by the given extension attributes.\n * @param nodeOrMark The node or mark to get the attributes from\n * @param extensionAttributes The extension attributes to use\n * @param onlyRenderedAttributes If true, only attributes that are rendered in the HTML are returned\n */\nexport function getAttributes(\n  nodeOrMark: NodeType | MarkType,\n  extensionAttributes: ExtensionAttribute[],\n  onlyRenderedAttributes?: boolean,\n): Record<string, any> {\n  const nodeOrMarkAttributes = nodeOrMark.attrs\n\n  if (!nodeOrMarkAttributes) {\n    return {}\n  }\n\n  return extensionAttributes\n    .filter(item => {\n      if (item.type !== nodeOrMark.type) {\n        return false\n      }\n      if (onlyRenderedAttributes) {\n        return item.attribute.rendered\n      }\n      return true\n    })\n    .map(item => {\n      if (!item.attribute.renderHTML) {\n        return {\n          [item.name]:\n            item.name in nodeOrMarkAttributes\n              ? nodeOrMarkAttributes[item.name]\n              : item.attribute.default,\n        }\n      }\n\n      return (\n        item.attribute.renderHTML(nodeOrMarkAttributes) || {\n          [item.name]:\n            item.name in nodeOrMarkAttributes\n              ? nodeOrMarkAttributes[item.name]\n              : item.attribute.default,\n        }\n      )\n    })\n    .reduce((attributes, attribute) => mergeAttributes(attributes, attribute), {})\n}\n\n/**\n * This function returns the HTML attributes of a node or mark that are defined by the given extension attributes.\n * @param nodeOrMark The node or mark to get the attributes from\n * @param extensionAttributes The extension attributes to use\n */\nexport function getHTMLAttributes(\n  nodeOrMark: NodeType | MarkType,\n  extensionAttributes: ExtensionAttribute[],\n) {\n  return getAttributes(nodeOrMark, extensionAttributes, true)\n}\n","/* eslint-disable @typescript-eslint/no-explicit-any */\nimport type { MarkType, NodeType } from '../types'\n\n/**\n * Props for a node renderer\n */\nexport type NodeProps<TNodeType = any, TChildren = any> = {\n  /**\n   * The current node to render\n   */\n  node: TNodeType;\n  /**\n   * Unless the node is the root node, this will always be defined\n   */\n  parent?: TNodeType;\n  /**\n   * The children of the current node\n   */\n  children?: TChildren;\n  /**\n   * Render a child element\n   */\n  renderElement: (props: {\n    /**\n     * Tiptap JSON content to render\n     */\n    content: TNodeType;\n    /**\n     * The parent node of the current node\n     */\n    parent?: TNodeType;\n  }) => TChildren;\n};\n\n/**\n * Props for a mark renderer\n */\nexport type MarkProps<TMarkType = any, TChildren = any, TNodeType = any> = {\n  /**\n   * The current mark to render\n   */\n  mark: TMarkType;\n  /**\n   * The children of the current mark\n   */\n  children?: TChildren;\n  /**\n   * The node the current mark is applied to\n   */\n  node: TNodeType;\n  /**\n   * The node the current mark is applied to\n   */\n  parent?: TNodeType;\n};\n\nexport type TiptapStaticRendererOptions<\n  /**\n   * The return type of the render function (e.g. React.ReactNode, string)\n   */\n  TReturnType,\n  /**\n   * A mark type is either a JSON representation of a mark or a Prosemirror mark instance\n   */\n  TMarkType extends { type: any } = MarkType,\n  /**\n   * A node type is either a JSON representation of a node or a Prosemirror node instance\n   */\n  TNodeType extends {\n    content?: { forEach: (cb: (node: TNodeType) => void) => void };\n    marks?: readonly TMarkType[];\n    type: string | { name: string };\n  } = NodeType,\n  /**\n   * A node renderer is a function that takes a node and its children and returns the rendered output\n   */\n  TNodeRender extends (ctx: NodeProps<TNodeType, TReturnType | TReturnType[]>) => TReturnType = (\n    ctx: NodeProps<TNodeType, TReturnType | TReturnType[]>\n  ) => TReturnType,\n  /**\n   * A mark renderer is a function that takes a mark and its children and returns the rendered output\n   */\n  TMarkRender extends (ctx: MarkProps<TMarkType, TReturnType | TReturnType[], TNodeType>) => TReturnType = (\n    ctx: MarkProps<TMarkType, TReturnType | TReturnType[], TNodeType>\n  ) => TReturnType,\n> = {\n  /**\n   * Mapping of node types to react components\n   */\n  nodeMapping: Record<string, TNodeRender>;\n  /**\n   * Mapping of mark types to react components\n   */\n  markMapping: Record<string, TMarkRender>;\n  /**\n   * Component to render if a node type is not handled\n   */\n  unhandledNode?: TNodeRender;\n  /**\n   * Component to render if a mark type is not handled\n   */\n  unhandledMark?: TMarkRender;\n};\n\n/**\n * Tiptap Static Renderer\n * ----------------------\n *\n * This function is a basis to allow for different renderers to be created.\n * Generic enough to be able to statically render Prosemirror JSON or Prosemirror Nodes.\n *\n * Using this function, you can create a renderer that takes a JSON representation of a Prosemirror document\n * and renders it using a mapping of node types to React components or even to a string.\n * This function is used as the basis to create the `reactRenderer` and `stringRenderer` functions.\n */\nexport function TiptapStaticRenderer<\n  /**\n   * The return type of the render function (e.g. React.ReactNode, string)\n   */\n  TReturnType,\n  /**\n   * A mark type is either a JSON representation of a mark or a Prosemirror mark instance\n   */\n  TMarkType extends { type: string | { name: string } } = MarkType,\n  /**\n   * A node type is either a JSON representation of a node or a Prosemirror node instance\n   */\n  TNodeType extends {\n    content?: { forEach:(\ncb: (node: TNodeType) => void) => void };\n    marks?: readonly TMarkType[];\n    type: string | { name: string };\n  } = NodeType,\n  /**\n   * A node renderer is a function that takes a node and its children and returns the rendered output\n   */\n  TNodeRender extends (ctx: NodeProps<TNodeType, TReturnType | TReturnType[]>) => TReturnType = (\n    ctx: NodeProps<TNodeType, TReturnType | TReturnType[]>\n  ) => TReturnType,\n  /**\n   * A mark renderer is a function that takes a mark and its children and returns the rendered output\n   */\n  TMarkRender extends (ctx: MarkProps<TMarkType, TReturnType | TReturnType[], TNodeType>) => TReturnType = (\n    ctx: MarkProps<TMarkType, TReturnType | TReturnType[], TNodeType>\n  ) => TReturnType,\n>(\n  /**\n   * The function that actually renders the component\n   */\n  renderComponent: (\n    ctx:\n      | {\n          component: TNodeRender;\n          props: NodeProps<TNodeType, TReturnType | TReturnType[]>;\n        }\n      | {\n          component: TMarkRender;\n          props: MarkProps<TMarkType, TReturnType | TReturnType[], TNodeType>;\n        }\n  ) => TReturnType,\n  {\n    nodeMapping,\n    markMapping,\n    unhandledNode,\n    unhandledMark,\n  }: TiptapStaticRendererOptions<TReturnType, TMarkType, TNodeType, TNodeRender, TMarkRender>,\n) {\n  /**\n   * Render Tiptap JSON and all its children using the provided node and mark mappings.\n   */\n  return function renderContent({\n    content,\n    parent,\n  }: {\n    /**\n     * Tiptap JSON content to render\n     */\n    content: TNodeType;\n    /**\n     * The parent node of the current node\n     */\n    parent?: TNodeType;\n  }): TReturnType {\n    const nodeType = typeof content.type === 'string' ? content.type : content.type.name\n    const NodeHandler = nodeMapping[nodeType] ?? unhandledNode\n\n    if (!NodeHandler) {\n      throw new Error(`missing handler for node type ${nodeType}`)\n    }\n\n    const nodeContent = renderComponent({\n      component: NodeHandler,\n      props: {\n        node: content,\n        parent,\n        renderElement: renderContent,\n        // Lazily compute the children to avoid unnecessary recursion\n        get children() {\n          // recursively render child content nodes\n          const children: TReturnType[] = []\n\n          if (content.content) {\n            content.content.forEach(child => {\n              children.push(\n                renderContent({\n                  content: child,\n                  parent: content,\n                }),\n              )\n            })\n          }\n\n          return children\n        },\n      },\n    })\n\n    // apply marks to the content\n    const markedContent = content.marks\n      ? content.marks.reduce((acc, mark) => {\n        const markType = typeof mark.type === 'string' ? mark.type : mark.type.name\n        const MarkHandler = markMapping[markType] ?? unhandledMark\n\n        if (!MarkHandler) {\n          throw new Error(`missing handler for mark type ${markType}`)\n        }\n\n        return renderComponent({\n          component: MarkHandler,\n          props: {\n            mark,\n            parent,\n            node: content,\n            children: acc,\n          },\n        })\n      }, nodeContent)\n      : nodeContent\n\n    return markedContent\n  }\n}\n","/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { MarkType, NodeType } from '../../types.js'\nimport { TiptapStaticRenderer, TiptapStaticRendererOptions } from '../renderer.js'\n\nexport function renderJSONContentToString<\n/**\n * A mark type is either a JSON representation of a mark or a Prosemirror mark instance\n */\nTMarkType extends { type: any } = MarkType,\n/**\n * A node type is either a JSON representation of a node or a Prosemirror node instance\n */\nTNodeType extends {\n  content?: { forEach:(cb: (node: TNodeType) => void) => void };\n  marks?: readonly TMarkType[];\n  type: string | { name: string };\n} = NodeType,\n>(options: TiptapStaticRendererOptions<string, TMarkType, TNodeType>) {\n  return TiptapStaticRenderer(ctx => {\n    return ctx.component(ctx.props as any)\n  }, options)\n}\n","/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { Extensions, JSONContent } from '@tiptap/core'\nimport type { DOMOutputSpec, Mark, Node } from '@tiptap/pm/model'\n\nimport { renderJSONContentToString } from '../../json/html-string/string.js'\nimport { TiptapStaticRendererOptions } from '../../json/renderer.js'\nimport type { DOMOutputSpecArray } from '../../types.js'\nimport { renderToElement } from '../extensionRenderer.js'\n\n/**\n * Serialize the attributes of a node or mark to a string\n * @param attrs The attributes to serialize\n * @returns The serialized attributes as a string\n */\nexport function serializeAttrsToHTMLString(attrs: Record<string, any>): string {\n  const output = Object.entries(attrs)\n    .map(([key, value]) => `${key}=${JSON.stringify(value)}`)\n    .join(' ')\n\n  return output ? ` ${output}` : ''\n}\n\n/**\n * Serialize the children of a node or mark to a string\n * @param children The children to serialize\n * @returns The serialized children as a string\n */\nexport function serializeChildrenToHTMLString(children?: string | string[]): string {\n  return ([] as string[])\n    .concat(children || '')\n    .filter(Boolean)\n    .join('')\n}\n\n/**\n * Take a DOMOutputSpec and return a function that can render it to a string\n * @param content The DOMOutputSpec to convert to a string\n * @returns A function that can render the DOMOutputSpec to a string\n */\nexport function domOutputSpecToHTMLString(\n  content: DOMOutputSpec,\n): (children?: string | string[]) => string {\n  if (typeof content === 'string') {\n    return () => content\n  }\n  if (typeof content === 'object' && 'length' in content) {\n    const [tag, attrs, children, ...rest] = content as DOMOutputSpecArray\n\n    if (attrs === undefined) {\n      return () => `<${tag}/>`\n    }\n    if (attrs === 0) {\n      return child => `<${tag}>${serializeChildrenToHTMLString(child)}</${tag}>`\n    }\n    if (typeof attrs === 'object') {\n      if (Array.isArray(attrs)) {\n        if (children === undefined) {\n          return child => `<${tag}>${domOutputSpecToHTMLString(attrs as DOMOutputSpecArray)(child)}</${tag}>`\n        }\n        if (children === 0) {\n          return child => `<${tag}>${domOutputSpecToHTMLString(attrs as DOMOutputSpecArray)(child)}</${tag}>`\n        }\n        return child => `<${tag}>${domOutputSpecToHTMLString(attrs as DOMOutputSpecArray)(child)}${[children]\n          .concat(rest)\n          .map(a => domOutputSpecToHTMLString(a)(child))}</${tag}>`\n      }\n      if (children === undefined) {\n        return () => `<${tag}${serializeAttrsToHTMLString(attrs)}/>`\n      }\n      if (children === 0) {\n        return child => `<${tag}${serializeAttrsToHTMLString(attrs)}>${serializeChildrenToHTMLString(\n          child,\n        )}</${tag}>`\n      }\n\n      return child => `<${tag}${serializeAttrsToHTMLString(attrs)}>${[children]\n        .concat(rest)\n        .map(a => domOutputSpecToHTMLString(a)(child))\n        .join('')}</${tag}>`\n    }\n  }\n\n  // TODO support DOM elements? How to handle them?\n  throw new Error(\n    '[tiptap error]: Unsupported DomOutputSpec type, check the `renderHTML` method output',\n    {\n      cause: content,\n    },\n  )\n}\n\n/**\n * This function will statically render a Prosemirror Node to HTML using the provided extensions and options\n * @param content The content to render to HTML\n * @param extensions The extensions to use for rendering\n * @param options The options to use for rendering\n * @returns The rendered HTML string\n */\nexport function renderToHTMLString({\n  content,\n  extensions,\n  options,\n}: {\n  content: Node | JSONContent;\n  extensions: Extensions;\n  options?: Partial<TiptapStaticRendererOptions<string, Mark, Node>>;\n}): string {\n  return renderToElement<string>({\n    renderer: renderJSONContentToString,\n    domOutputSpecToElement: domOutputSpecToHTMLString,\n    mapDefinedTypes: {\n      // Map a doc node to concatenated children\n      doc: ({ children }) => serializeChildrenToHTMLString(children),\n      // Map a text node to its text content\n      text: ({ node }) => node.text ?? '',\n    },\n    content,\n    extensions,\n    options,\n  })\n}\n"],"mappings":"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","names":["import_core","_a"]}

package/dist/pm/html-string/index.d.cts

@@ -0,0 +1,192 @@
+import { Node, ExtensionAttribute, Mark as Mark$1, JSONContent, Extensions } from '@tiptap/core';
+import { DOMOutputSpec, Mark, Node as Node$1 } from '@tiptap/pm/model';
+
+/**
+ * A mark type is either a JSON representation of a mark or a Prosemirror mark instance
+ */
+type MarkType<Type extends string = any, Attributes extends undefined | Record<string, any> = any> = {
+    type: Type;
+    attrs: Attributes;
+};
+/**
+ * A node type is either a JSON representation of a node or a Prosemirror node instance
+ */
+type NodeType<Type extends string = any, Attributes extends undefined | Record<string, any> = any, NodeMarkType extends MarkType = any, Content extends NodeType[] = any> = {
+    type: Type;
+    attrs: Attributes;
+    content?: Content;
+    marks?: NodeMarkType[];
+    text?: string;
+};
+
+/**
+ * Props for a node renderer
+ */
+type NodeProps<TNodeType = any, TChildren = any> = {
+    /**
+     * The current node to render
+     */
+    node: TNodeType;
+    /**
+     * Unless the node is the root node, this will always be defined
+     */
+    parent?: TNodeType;
+    /**
+     * The children of the current node
+     */
+    children?: TChildren;
+    /**
+     * Render a child element
+     */
+    renderElement: (props: {
+        /**
+         * Tiptap JSON content to render
+         */
+        content: TNodeType;
+        /**
+         * The parent node of the current node
+         */
+        parent?: TNodeType;
+    }) => TChildren;
+};
+/**
+ * Props for a mark renderer
+ */
+type MarkProps<TMarkType = any, TChildren = any, TNodeType = any> = {
+    /**
+     * The current mark to render
+     */
+    mark: TMarkType;
+    /**
+     * The children of the current mark
+     */
+    children?: TChildren;
+    /**
+     * The node the current mark is applied to
+     */
+    node: TNodeType;
+    /**
+     * The node the current mark is applied to
+     */
+    parent?: TNodeType;
+};
+type TiptapStaticRendererOptions<
+/**
+ * The return type of the render function (e.g. React.ReactNode, string)
+ */
+TReturnType, 
+/**
+ * A mark type is either a JSON representation of a mark or a Prosemirror mark instance
+ */
+TMarkType extends {
+    type: any;
+} = MarkType, 
+/**
+ * A node type is either a JSON representation of a node or a Prosemirror node instance
+ */
+TNodeType extends {
+    content?: {
+        forEach: (cb: (node: TNodeType) => void) => void;
+    };
+    marks?: readonly TMarkType[];
+    type: string | {
+        name: string;
+    };
+} = NodeType, 
+/**
+ * A node renderer is a function that takes a node and its children and returns the rendered output
+ */
+TNodeRender extends (ctx: NodeProps<TNodeType, TReturnType | TReturnType[]>) => TReturnType = (ctx: NodeProps<TNodeType, TReturnType | TReturnType[]>) => TReturnType, 
+/**
+ * A mark renderer is a function that takes a mark and its children and returns the rendered output
+ */
+TMarkRender extends (ctx: MarkProps<TMarkType, TReturnType | TReturnType[], TNodeType>) => TReturnType = (ctx: MarkProps<TMarkType, TReturnType | TReturnType[], TNodeType>) => TReturnType> = {
+    /**
+     * Mapping of node types to react components
+     */
+    nodeMapping: Record<string, TNodeRender>;
+    /**
+     * Mapping of mark types to react components
+     */
+    markMapping: Record<string, TMarkRender>;
+    /**
+     * Component to render if a node type is not handled
+     */
+    unhandledNode?: TNodeRender;
+    /**
+     * Component to render if a mark type is not handled
+     */
+    unhandledMark?: TMarkRender;
+};
+
+type DomOutputSpecToElement<T> = (content: DOMOutputSpec) => (children?: T | T[]) => T;
+/**
+ * This takes a NodeExtension and maps it to a React component
+ * @param extension The node extension to map to a React component
+ * @param extensionAttributes All available extension attributes
+ * @returns A tuple with the name of the extension and a React component that renders the extension
+ */
+declare function mapNodeExtensionToReactNode<T>(domOutputSpecToElement: DomOutputSpecToElement<T>, extension: Node, extensionAttributes: ExtensionAttribute[], options?: Partial<Pick<TiptapStaticRendererOptions<T, Mark, Node$1>, 'unhandledNode'>>): [string, (props: NodeProps<Node$1, T | T[]>) => T];
+/**
+ * This takes a MarkExtension and maps it to a React component
+ * @param extension The mark extension to map to a React component
+ * @param extensionAttributes All available extension attributes
+ * @returns A tuple with the name of the extension and a React component that renders the extension
+ */
+declare function mapMarkExtensionToReactNode<T>(domOutputSpecToElement: DomOutputSpecToElement<T>, extension: Mark$1, extensionAttributes: ExtensionAttribute[], options?: Partial<Pick<TiptapStaticRendererOptions<T, Mark, Node$1>, 'unhandledMark'>>): [string, (props: MarkProps<Mark, T | T[]>) => T];
+/**
+ * This function will statically render a Prosemirror Node to a target element type using the given extensions
+ * @param renderer The renderer to use to render the Prosemirror Node to the target element type
+ * @param domOutputSpecToElement A function that takes a Prosemirror DOMOutputSpec and returns a function that takes children and returns the target element type
+ * @param mapDefinedTypes An object with functions to map the doc and text types to the target element type
+ * @param content The Prosemirror Node to render
+ * @param extensions The extensions to use to render the Prosemirror Node
+ * @param options Additional options to pass to the renderer that can override the default behavior
+ * @returns The rendered target element type
+ */
+declare function renderToElement<T>({ renderer, domOutputSpecToElement, mapDefinedTypes, content, extensions, options, }: {
+    renderer: (options: TiptapStaticRendererOptions<T, Mark, Node$1>) => (ctx: {
+        content: Node$1;
+    }) => T;
+    domOutputSpecToElement: DomOutputSpecToElement<T>;
+    mapDefinedTypes: {
+        doc: (props: NodeProps<Node$1, T | T[]>) => T;
+        text: (props: NodeProps<Node$1, T | T[]>) => T;
+    };
+    content: Node$1 | JSONContent;
+    extensions: Extensions;
+    options?: Partial<TiptapStaticRendererOptions<T, Mark, Node$1>>;
+}): T;
+
+/**
+ * Serialize the attributes of a node or mark to a string
+ * @param attrs The attributes to serialize
+ * @returns The serialized attributes as a string
+ */
+declare function serializeAttrsToHTMLString(attrs: Record<string, any>): string;
+/**
+ * Serialize the children of a node or mark to a string
+ * @param children The children to serialize
+ * @returns The serialized children as a string
+ */
+declare function serializeChildrenToHTMLString(children?: string | string[]): string;
+/**
+ * Take a DOMOutputSpec and return a function that can render it to a string
+ * @param content The DOMOutputSpec to convert to a string
+ * @returns A function that can render the DOMOutputSpec to a string
+ */
+declare function domOutputSpecToHTMLString(content: DOMOutputSpec): (children?: string | string[]) => string;
+/**
+ * This function will statically render a Prosemirror Node to HTML using the provided extensions and options
+ * @param content The content to render to HTML
+ * @param extensions The extensions to use for rendering
+ * @param options The options to use for rendering
+ * @returns The rendered HTML string
+ */
+declare function renderToHTMLString({ content, extensions, options, }: {
+    content: Node$1 | JSONContent;
+    extensions: Extensions;
+    options?: Partial<TiptapStaticRendererOptions<string, Mark, Node$1>>;
+}): string;
+
+export { type DomOutputSpecToElement, domOutputSpecToHTMLString, mapMarkExtensionToReactNode, mapNodeExtensionToReactNode, renderToElement, renderToHTMLString, serializeAttrsToHTMLString, serializeChildrenToHTMLString };