@doist/typist 1.0.11 → 1.0.13

package/CHANGELOG.md

@@ -1,3 +1,15 @@
+## [1.0.13](https://github.com/Doist/typist/compare/v1.0.12...v1.0.13) (2023-02-13)
+
+### Bug Fixes
+
+-   **deps:** update tiptap packages to v2.0.0-beta.215 ([#129](https://github.com/Doist/typist/issues/129)) ([af22d22](https://github.com/Doist/typist/commit/af22d22eff6531c11114cb3122daa184657e504e))
+
+## [1.0.12](https://github.com/Doist/typist/compare/v1.0.11...v1.0.12) (2023-01-06)
+
+### Bug Fixes
+
+-   **html-serializer:** Disables tokenizers if marks/nodes are not found in the editor schema ([#86](https://github.com/Doist/typist/issues/86)) ([0ed4a9b](https://github.com/Doist/typist/commit/0ed4a9b694d2b7dcfadce0c5aa3fdefec6d492c5))
+
 ## [1.0.11](https://github.com/Doist/typist/compare/v1.0.10...v1.0.11) (2022-12-21)
 
 ### Bug Fixes

package/LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2022 Doist Inc.
+Copyright (c) 2022-2023 Doist Inc.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/dist/helpers/serializer.d.ts

@@ -1,4 +1,14 @@
-import type { ParseRule } from 'prosemirror-model';
+import type { ParseRule, Schema } from 'prosemirror-model';
+/**
+ * Builds a partial regular expression that includes valid URL schemas used by all the available
+ * suggestion nodes from the given editor schema.
+ *
+ * @param schema The editor schema to be used for suggestion nodes detection.
+ *
+ * @returns A partial regular expression with valid URL schemas for the available suggestion nodes,
+ * `null` if there are no suggestion nodes in the editor schema.
+ */
+declare function buildSuggestionSchemaPartialRegex(schema: Schema): string | null;
 /**
  * Extract all tags from the given parse rules argument, and returns an array of said tags.
  *
@@ -7,5 +17,5 @@ import type { ParseRule } from 'prosemirror-model';
  * @returns An array of tags extracted from the parse rules.
  */
 declare function extractTagsFromParseRules(parseRules?: readonly ParseRule[]): (keyof HTMLElementTagNameMap)[];
-export { extractTagsFromParseRules };
+export { buildSuggestionSchemaPartialRegex, extractTagsFromParseRules };
 //# sourceMappingURL=serializer.d.ts.map

package/dist/helpers/serializer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"serializer.d.ts","sourceRoot":"","sources":["../../src/helpers/serializer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAA;AAElD;;;;;;GAMG;AACH,iBAAS,yBAAyB,CAC9B,UAAU,CAAC,EAAE,SAAS,SAAS,EAAE,GAClC,CAAC,MAAM,qBAAqB,CAAC,EAAE,CAQjC;AAED,OAAO,EAAE,yBAAyB,EAAE,CAAA"}
+{"version":3,"file":"serializer.d.ts","sourceRoot":"","sources":["../../src/helpers/serializer.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAA;AAE1D;;;;;;;;GAQG;AACH,iBAAS,iCAAiC,CAAC,MAAM,EAAE,MAAM,iBAYxD;AAED;;;;;;GAMG;AACH,iBAAS,yBAAyB,CAC9B,UAAU,CAAC,EAAE,SAAS,SAAS,EAAE,GAClC,CAAC,MAAM,qBAAqB,CAAC,EAAE,CAQjC;AAED,OAAO,EAAE,iCAAiC,EAAE,yBAAyB,EAAE,CAAA"}

package/dist/helpers/serializer.js

@@ -1,3 +1,22 @@
+import { kebabCase } from 'lodash-es';
+/**
+ * Builds a partial regular expression that includes valid URL schemas used by all the available
+ * suggestion nodes from the given editor schema.
+ *
+ * @param schema The editor schema to be used for suggestion nodes detection.
+ *
+ * @returns A partial regular expression with valid URL schemas for the available suggestion nodes,
+ * `null` if there are no suggestion nodes in the editor schema.
+ */
+function buildSuggestionSchemaPartialRegex(schema) {
+    const suggestionNodes = Object.values(schema.nodes).filter((node) => node.name.endsWith('Suggestion'));
+    if (suggestionNodes.length === 0) {
+        return null;
+    }
+    return `(?:${suggestionNodes
+        .map((suggestionNode) => kebabCase(suggestionNode.name.replace(/Suggestion$/, '')))
+        .join('|')})://`;
+}
 /**
  * Extract all tags from the given parse rules argument, and returns an array of said tags.
  *
@@ -13,4 +32,4 @@ function extractTagsFromParseRules(parseRules) {
         .filter((rule) => rule.tag)
         .map((rule) => rule.tag);
 }
-export { extractTagsFromParseRules };
+export { buildSuggestionSchemaPartialRegex, extractTagsFromParseRules };

package/dist/serializers/html/extensions/disabled.d.ts

@@ -0,0 +1,13 @@
+import { marked } from 'marked';
+import type { Schema } from 'prosemirror-model';
+/**
+ * A Marked extension which disables multiple parsing rules by disabling the rules respective
+ * tokenizers based on the availability of marks and/or nodes in the editor schema.
+ *
+ * @param schema The editor schema to be used for nodes and marks detection.
+ */
+declare function disabled(schema: Schema): {
+    tokenizer: Partial<Omit<marked.Tokenizer<false>, "constructor" | "options">>;
+};
+export { disabled };
+//# sourceMappingURL=disabled.d.ts.map

package/dist/serializers/html/extensions/disabled.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"disabled.d.ts","sourceRoot":"","sources":["../../../../src/serializers/html/extensions/disabled.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAK/B,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAA;AAS/C;;;;;GAKG;AACH,iBAAS,QAAQ,CAAC,MAAM,EAAE,MAAM;;EAyI/B;AAED,OAAO,EAAE,QAAQ,EAAE,CAAA"}

package/dist/serializers/html/extensions/disabled.js

@@ -0,0 +1,125 @@
+import { marked } from 'marked';
+import { buildSuggestionSchemaPartialRegex } from '../../../helpers/serializer';
+import { INITIAL_MARKED_OPTIONS } from '../html';
+/**
+ * A Marked extension which disables multiple parsing rules by disabling the rules respective
+ * tokenizers based on the availability of marks and/or nodes in the editor schema.
+ *
+ * @param schema The editor schema to be used for nodes and marks detection.
+ */
+function disabled(schema) {
+    const markedTokenizer = new marked.Tokenizer(INITIAL_MARKED_OPTIONS);
+    const tokenizer = {};
+    if (!schema.nodes.blockquote) {
+        Object.assign(tokenizer, {
+            blockquote() {
+                return undefined;
+            },
+        });
+    }
+    if (!schema.marks.bold || !schema.marks.italic) {
+        Object.assign(tokenizer, {
+            emStrong() {
+                return undefined;
+            },
+        });
+    }
+    // Given that there isn't a one to one mapping between the bullet/ordered list nodes and Marked
+    // tokenizers, we need to conditionally disable the `list` tokenizer based on the input
+    if (!schema.nodes.bulletList || !schema.nodes.orderedList) {
+        Object.assign(tokenizer, {
+            list(src) {
+                const isOrdered = /^\d+/.test(src);
+                if ((isOrdered && schema.nodes.orderedList) ||
+                    (!isOrdered && schema.nodes.bulletList)) {
+                    return markedTokenizer.list.apply(this, [src]);
+                }
+                return undefined;
+            },
+        });
+    }
+    if (!schema.marks.code) {
+        Object.assign(tokenizer, {
+            codespan() {
+                return undefined;
+            },
+        });
+    }
+    if (!schema.nodes.codeBlock) {
+        Object.assign(tokenizer, {
+            code() {
+                return undefined;
+            },
+            fences() {
+                return undefined;
+            },
+        });
+    }
+    if (!schema.nodes.hardBreak) {
+        Object.assign(tokenizer, {
+            br() {
+                return undefined;
+            },
+        });
+    }
+    if (!schema.nodes.heading) {
+        Object.assign(tokenizer, {
+            heading() {
+                return undefined;
+            },
+        });
+    }
+    if (!schema.nodes.horizontalRule) {
+        Object.assign(tokenizer, {
+            hr() {
+                return undefined;
+            },
+        });
+    }
+    if (!schema.marks.link) {
+        Object.assign(tokenizer, {
+            url() {
+                return undefined;
+            },
+        });
+    }
+    // Given that there isn't a one to one mapping between the link/image mark/node and Marked
+    // tokenizers, nor Marked supports our custom Markdown syntax for suggestions, we need to
+    // conditionally disable the `link` tokenizer based on the input
+    if (!schema.marks.link || !schema.nodes.image) {
+        const suggestionSchemaPartialRegex = buildSuggestionSchemaPartialRegex(schema);
+        const suggestionSchemaRegex = suggestionSchemaPartialRegex
+            ? new RegExp(`^\\[[^\\]]*\\]\\(${suggestionSchemaPartialRegex}`)
+            : null;
+        Object.assign(tokenizer, {
+            link(src) {
+                const isImage = /^!\[[^\]]*\]\([^)]+\)/.test(src);
+                const isSuggestion = suggestionSchemaRegex?.test(src);
+                if ((isImage && schema.nodes.image) ||
+                    (!isImage && schema.marks.link) ||
+                    isSuggestion) {
+                    return markedTokenizer.link.apply(this, [src]);
+                }
+                return undefined;
+            },
+        });
+    }
+    if (!schema.marks.strike) {
+        Object.assign(tokenizer, {
+            del() {
+                return undefined;
+            },
+        });
+    }
+    if (!schema.nodes.table) {
+        Object.assign(tokenizer, {
+            table() {
+                return undefined;
+            },
+        });
+    }
+    return {
+        tokenizer,
+    };
+}
+export { disabled };

package/dist/serializers/html/extensions/link.d.ts

@@ -1,11 +1,11 @@
 import { marked } from 'marked';
-import type { NodeType } from 'prosemirror-model';
 /**
  * A Marked extension which tweaks the `link` renderer to add support for suggestion nodes, while
  * preserving the original renderer for standard links.
  *
- * @param suggestionNodes An array of the suggestion nodes to serialize.
+ * @param suggestionSchemaRegex A regular expression with valid URL schemas for the available
+ * suggestion nodes.
  */
-declare function link(suggestionNodes: NodeType[]): marked.MarkedExtension;
+declare function link(suggestionSchemaRegex: RegExp): marked.MarkedExtension;
 export { link };
 //# sourceMappingURL=link.d.ts.map

package/dist/serializers/html/extensions/link.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"link.d.ts","sourceRoot":"","sources":["../../../../src/serializers/html/extensions/link.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAE/B,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAA;AAIjD;;;;;GAKG;AACH,iBAAS,IAAI,CAAC,eAAe,EAAE,QAAQ,EAAE,GAAG,MAAM,CAAC,eAAe,CAsBjE;AAED,OAAO,EAAE,IAAI,EAAE,CAAA"}
+{"version":3,"file":"link.d.ts","sourceRoot":"","sources":["../../../../src/serializers/html/extensions/link.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAI/B;;;;;;GAMG;AACH,iBAAS,IAAI,CAAC,qBAAqB,EAAE,MAAM,GAAG,MAAM,CAAC,eAAe,CAgBnE;AAED,OAAO,EAAE,IAAI,EAAE,CAAA"}

package/dist/serializers/html/extensions/link.js

@@ -1,20 +1,17 @@
-import { kebabCase } from 'lodash-es';
 import { marked } from 'marked';
 const markedRenderer = new marked.Renderer();
 /**
  * A Marked extension which tweaks the `link` renderer to add support for suggestion nodes, while
  * preserving the original renderer for standard links.
  *
- * @param suggestionNodes An array of the suggestion nodes to serialize.
+ * @param suggestionSchemaRegex A regular expression with valid URL schemas for the available
+ * suggestion nodes.
  */
-function link(suggestionNodes) {
-    const linkSchemaRegex = new RegExp(`^(?:${suggestionNodes
-        .map((suggestionNode) => kebabCase(suggestionNode.name.replace(/Suggestion$/, '')))
-        .join('|')})://`);
+function link(suggestionSchemaRegex) {
     return {
         renderer: {
             link(href, title, text) {
-                if (href && linkSchemaRegex.test(href)) {
+                if (href && suggestionSchemaRegex?.test(href)) {
                     const [, schema, id] = /^([a-z-]+):\/\/(\S+)$/i.exec(href) || [];
                     if (schema && id && text) {
                         return `<span data-${schema} data-id="${id}" data-label="${text}"></span>`;

package/dist/serializers/html/html.d.ts

@@ -1,3 +1,4 @@
+import { marked } from 'marked';
 import type { Schema } from 'prosemirror-model';
 /**
  * The return type for the `createHTMLSerializer` function.
@@ -12,6 +13,12 @@ type HTMLSerializerReturnType = {
      */
     serialize: (markdown: string) => string;
 };
+/**
+ * Sensible default options to initialize the Marked parser with.
+ *
+ * @see https://marked.js.org/using_advanced#options
+ */
+declare const INITIAL_MARKED_OPTIONS: marked.MarkedOptions;
 /**
  * Create a Markdown to HTML serializer with the Marked library for a rich-text editor, or use a
  * custom serializer for a plain-text editor. The editor schema is used to detect which nodes and
@@ -19,9 +26,9 @@ type HTMLSerializerReturnType = {
  *
  * @param schema The editor schema to be used for nodes and marks detection.
  *
- * @returns A normalized `serialize` function.
+ * @returns A normalized object for the HTML serializer.
  */
 declare function createHTMLSerializer(schema: Schema): HTMLSerializerReturnType;
-export { createHTMLSerializer };
+export { createHTMLSerializer, INITIAL_MARKED_OPTIONS };
 export type { HTMLSerializerReturnType };
 //# sourceMappingURL=html.d.ts.map

package/dist/serializers/html/html.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"html.d.ts","sourceRoot":"","sources":["../../../src/serializers/html/html.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAA;AAE/C;;GAEG;AACH,KAAK,wBAAwB,GAAG;IAC5B;;;;;;OAMG;IACH,SAAS,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,MAAM,CAAA;CAC1C,CAAA;AA0HD;;;;;;;;GAQG;AACH,iBAAS,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG,wBAAwB,CAQtE;AAED,OAAO,EAAE,oBAAoB,EAAE,CAAA;AAE/B,YAAY,EAAE,wBAAwB,EAAE,CAAA"}
+{"version":3,"file":"html.d.ts","sourceRoot":"","sources":["../../../src/serializers/html/html.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAc/B,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAA;AAE/C;;GAEG;AACH,KAAK,wBAAwB,GAAG;IAC5B;;;;;;OAMG;IACH,SAAS,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,MAAM,CAAA;CAC1C,CAAA;AAED;;;;GAIG;AACH,QAAA,MAAM,sBAAsB,EAAE,MAAM,CAAC,aAMpC,CAAA;AAmCD;;;;;;;;GAQG;AACH,iBAAS,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG,wBAAwB,CAiDtE;AAED,OAAO,EAAE,oBAAoB,EAAE,sBAAsB,EAAE,CAAA;AAEvD,YAAY,EAAE,wBAAwB,EAAE,CAAA"}

package/dist/serializers/html/html.js

@@ -2,8 +2,10 @@ import { escape, kebabCase } from 'lodash-es';
 import { marked } from 'marked';
 import { REGEX_LINE_BREAKS } from '../../constants/regular-expressions';
 import { isPlainTextDocument } from '../../helpers/schema';
+import { buildSuggestionSchemaPartialRegex } from '../../helpers/serializer';
 import { checkbox } from './extensions/checkbox';
 import { code } from './extensions/code';
+import { disabled } from './extensions/disabled';
 import { html } from './extensions/html';
 import { link } from './extensions/link';
 import { paragraph } from './extensions/paragraph';
@@ -14,76 +16,56 @@ import { taskList } from './extensions/task-list';
  * @see https://marked.js.org/using_advanced#options
  */
 const INITIAL_MARKED_OPTIONS = {
+    ...marked.getDefaults(),
     breaks: true,
     gfm: true,
     headerIds: false,
     silent: true,
 };
 /**
- * Serialize the Markdown input to HTML with a custom serializer, ready for a plain-text editor.
+ * Create a custom Markdown to HTML serializer for plain-text editors only.
  *
  * @param schema The editor schema to be used for nodes and marks detection.
  *
- * @returns The serialized HTML output.
+ * @returns A normalized object for the HTML serializer.
  */
-function serializeForPlainTextEditor(markdown, schema) {
-    // Converts special characters (i.e. `&`, `<`, `>`, `"`, and `'`) to their corresponding HTML
-    // entities. Unlike the `sanitize` option that is used by the rich-text serializer, it's safe
-    // for the plain-text serializer to escape the full input considering we need to output the full
-    // content as valid HTML (i.e. the editor should not drop invalid HTML).
-    let htmlResult = escape(markdown);
-    // Serialize all suggestion links if any suggestion node exists in the schema
-    Object.values(schema.nodes)
-        .filter((node) => node.name.endsWith('Suggestion'))
-        .forEach((suggestionNode) => {
-        const linkSchema = kebabCase(suggestionNode.name.replace(/Suggestion$/, ''));
-        htmlResult = htmlResult.replace(new RegExp(`\\[([^\\[]+)\\]\\((?:${linkSchema}):\\/\\/(\\d+)\\)`, 'gm'), `<span data-${linkSchema} data-id="$2" data-label="$1"></span>`);
-    });
-    // Return the serialized HTML with every line wrapped in a paragraph element
-    return htmlResult.replace(/^([^\n]+)\n?|\n+/gm, `<p>$1</p>`);
+function createHTMLSerializerForPlainTextEditor(schema) {
+    return {
+        serialize(markdown) {
+            // Converts special characters (i.e. `&`, `<`, `>`, `"`, and `'`) to their corresponding
+            // HTML entities because we need to output the full content as valid HTML (i.e. the
+            // editor should not drop invalid HTML).
+            let htmlResult = escape(markdown);
+            // Serialize all suggestion links if any suggestion node exists in the schema
+            Object.values(schema.nodes)
+                .filter((node) => node.name.endsWith('Suggestion'))
+                .forEach((suggestionNode) => {
+                const linkSchema = kebabCase(suggestionNode.name.replace(/Suggestion$/, ''));
+                htmlResult = htmlResult.replace(new RegExp(`\\[([^\\[]+)\\]\\((?:${linkSchema}):\\/\\/(\\d+)\\)`, 'gm'), `<span data-${linkSchema} data-id="$2" data-label="$1"></span>`);
+            });
+            // Return the serialized HTML with every line wrapped in a paragraph element
+            return htmlResult.replace(/^([^\n]+)\n?|\n+/gm, `<p>$1</p>`);
+        },
+    };
 }
 /**
- * Serialize the Markdown input to HTML with Marked, ready for a rich-text editor.
+ * Create a Markdown to HTML serializer with the Marked library for a rich-text editor, or use a
+ * custom serializer for a plain-text editor. The editor schema is used to detect which nodes and
+ * marks are available in the editor, and only parses the input with the minimal required rules.
  *
- * @param markdown The input Markdown to be serialized to HTML.
  * @param schema The editor schema to be used for nodes and marks detection.
  *
- * @returns The serialized HTML output.
+ * @returns A normalized object for the HTML serializer.
  */
-function serializeForRichTextEditor(markdown, schema) {
-    // Reset Marked to the defaults and set custom options
-    marked.setOptions({
-        ...marked.getDefaults(),
-        ...INITIAL_MARKED_OPTIONS,
-    });
-    // Disable built-in rules that the editor does not yet support
-    marked.use({
-        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-        // @ts-ignore: Returning `undefined` is acceptable to disable tokens
-        tokenizer: {
-            ...(!schema.marks.strike
-                ? {
-                    del() {
-                        /* noop: disables tokenizer */
-                    },
-                }
-                : {}),
-            ...(!schema.nodes.heading
-                ? {
-                    heading() {
-                        /* noop: disables tokenizer */
-                    },
-                }
-                : {}),
-            ...(!schema.nodes.table
-                ? {
-                    table() {
-                        /* noop: disables tokenizer */
-                    },
-                }
-                : {}),
-        },
-    });
+function createHTMLSerializer(schema) {
+    // Returns a custom HTML serializer for plain-text editors
+    if (isPlainTextDocument(schema)) {
+        return createHTMLSerializerForPlainTextEditor(schema);
+    }
+    // Reset Marked instance to the initial options
+    marked.setOptions(INITIAL_MARKED_OPTIONS);
+    // Disable built-in rules that are not supported by the schema
+    marked.use(disabled(schema));
     // Overwrite some built-in rules for handling of special behaviours
     // (see documentation for each extension for more details)
     marked.use(checkbox, html, paragraph(schema.nodes.image));
@@ -95,35 +77,21 @@ function serializeForRichTextEditor(markdown, schema) {
     if (schema.nodes.taskList && schema.nodes.taskItem) {
         marked.use(taskList);
     }
-    // Get all the available suggestion nodes from the schema
-    const suggestionNodes = Object.values(schema.nodes).filter((node) => node.name.endsWith('Suggestion'));
+    // Build a regular expression with all the available suggestion nodes from the schema
+    const suggestionSchemaPartialRegex = buildSuggestionSchemaPartialRegex(schema);
     // Overwrite the built-in link rule if any suggestion node exists in the schema
-    if (suggestionNodes.length > 0) {
-        marked.use(link(suggestionNodes));
+    if (suggestionSchemaPartialRegex) {
+        marked.use(link(new RegExp(`^${suggestionSchemaPartialRegex}`)));
     }
-    // Return the serialized HTML parsed with Marked
-    return (marked
-        .parse(markdown)
-        // Removes newlines after tags from the HTML output with a specially crafted RegExp
-        // (needed to prevent the editor from converting newlines to blank paragraphs)
-        .replace(new RegExp(`>${REGEX_LINE_BREAKS.source}`, REGEX_LINE_BREAKS.flags), '>'));
-}
-/**
- * Create a Markdown to HTML serializer with the Marked library for a rich-text editor, or use a
- * custom serializer for a plain-text editor. The editor schema is used to detect which nodes and
- * marks are available in the editor, and only parses the input with the minimal required rules.
- *
- * @param schema The editor schema to be used for nodes and marks detection.
- *
- * @returns A normalized `serialize` function.
- */
-function createHTMLSerializer(schema) {
     return {
         serialize(markdown) {
-            return isPlainTextDocument(schema)
-                ? serializeForPlainTextEditor(markdown, schema)
-                : serializeForRichTextEditor(markdown, schema);
+            return (marked
+                .parse(markdown)
+                // Removes line breaks after HTML tags from the HTML output with a specially
+                // crafted RegExp (this is needed to prevent the editor from converting newline
+                // control characters to blank paragraphs).
+                .replace(new RegExp(`>${REGEX_LINE_BREAKS.source}`, REGEX_LINE_BREAKS.flags), '>'));
         },
     };
 }
-export { createHTMLSerializer };
+export { createHTMLSerializer, INITIAL_MARKED_OPTIONS };

package/dist/serializers/markdown/markdown.d.ts

@@ -30,9 +30,13 @@ declare const BULLET_LIST_MARKER = "-";
  * a plain-text editor. The editor schema is used to detect which nodes and marks are available in
  * the editor, and only parses the input with the minimal required rules.
  *
+ * **Note:** Unlike the HTML serializer, built-in rules that are not supported by the schema are not
+ * disabled because if the schema does not support certain nodes/marks, the parsing rules don't have
+ * valid HTML elements to match in the editor HTML output.
+ *
  * @param schema The editor schema to be used for nodes and marks detection.
  *
- * @returns A normalized `serialize` function.
+ * @returns A normalized object for the Markdown serializer.
  */
 declare function createMarkdownSerializer(schema: Schema, options?: MarkdownSerializerOptions): MarkdownSerializerReturnType;
 export { BULLET_LIST_MARKER, createMarkdownSerializer };

package/dist/serializers/markdown/markdown.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"markdown.d.ts","sourceRoot":"","sources":["../../../src/serializers/markdown/markdown.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAA;AAE/C;;GAEG;AACH,KAAK,yBAAyB,GAAG;IAC7B;;OAEG;IACH,MAAM,CAAC,EAAE,KAAK,CAAA;CACjB,CAAA;AAED;;GAEG;AACH,KAAK,4BAA4B,GAAG;IAChC;;;;;;OAMG;IACH,SAAS,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAA;CACtC,CAAA;AAED;;GAEG;AACH,QAAA,MAAM,kBAAkB,MAAM,CAAA;AA8C9B;;;;;;;;GAQG;AACH,iBAAS,wBAAwB,CAC7B,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,yBAAyB,GACpC,4BAA4B,CA6E9B;AAED,OAAO,EAAE,kBAAkB,EAAE,wBAAwB,EAAE,CAAA;AAEvD,YAAY,EAAE,4BAA4B,EAAE,CAAA"}
+{"version":3,"file":"markdown.d.ts","sourceRoot":"","sources":["../../../src/serializers/markdown/markdown.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAA;AAE/C;;GAEG;AACH,KAAK,yBAAyB,GAAG;IAC7B;;OAEG;IACH,MAAM,CAAC,EAAE,KAAK,CAAA;CACjB,CAAA;AAED;;GAEG;AACH,KAAK,4BAA4B,GAAG;IAChC;;;;;;OAMG;IACH,SAAS,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAA;CACtC,CAAA;AAED;;GAEG;AACH,QAAA,MAAM,kBAAkB,MAAM,CAAA;AA8C9B;;;;;;;;;;;;GAYG;AACH,iBAAS,wBAAwB,CAC7B,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,yBAAyB,GACpC,4BAA4B,CA4E9B;AAED,OAAO,EAAE,kBAAkB,EAAE,wBAAwB,EAAE,CAAA;AAEvD,YAAY,EAAE,4BAA4B,EAAE,CAAA"}

package/dist/serializers/markdown/markdown.js

@@ -53,35 +53,38 @@ const INITIAL_TURNDOWN_OPTIONS = {
  * a plain-text editor. The editor schema is used to detect which nodes and marks are available in
  * the editor, and only parses the input with the minimal required rules.
  *
+ * **Note:** Unlike the HTML serializer, built-in rules that are not supported by the schema are not
+ * disabled because if the schema does not support certain nodes/marks, the parsing rules don't have
+ * valid HTML elements to match in the editor HTML output.
+ *
  * @param schema The editor schema to be used for nodes and marks detection.
  *
- * @returns A normalized `serialize` function.
+ * @returns A normalized object for the Markdown serializer.
  */
 function createMarkdownSerializer(schema, options) {
     // Initialize Turndown with custom options
     const turndown = new Turndown(INITIAL_TURNDOWN_OPTIONS);
-    // Turndown ensures Markdown characters are escaped (i.e. `\`) by default, so they are not
-    // interpreted as Markdown when the output is compiled back to HTML. For example, the contents
-    // of `<h1>1. Hello world</h1>` need to be escaped to `1\. Hello world`, otherwise it will be
-    // interpreted as a list item rather than a heading. However, if the schema represents a
-    // plain-text document, we need to override the escape function to return the input as-is, so
-    // that Markdown characters are interpreted as Markdown.
-    // ref: https://github.com/mixmark-io/turndown#escaping-markdown-characters
+    // Turndown was built to convert HTML into Markdown, expecting the input to be standards
+    // compliant HTML. As such, it collapses all whitespace by default, and there's
+    // currently no way to opt-out of this behavior. However, for plain-text editors, we
+    // need to preserve Markdown whitespace (otherwise we lose syntax like nested lists) by
+    // replacing all instances of the space character (but only if it's preceded by another
+    // space character) by the non-breaking space character, and after processing the input
+    // with Turndown, we restore the original space character.
     if (isPlainTextDocument(schema) || options?.escape === false) {
         turndown.escape = (str) => str;
     }
+    // Overwrite some built-in rules for handling of special behaviours
+    // (see documentation for each extension for more details)
+    turndown.use(paragraph(schema.nodes.paragraph, isPlainTextDocument(schema)));
     // Overwrite the built-in `image` rule if the corresponding node exists in the schema
     if (schema.nodes.image) {
         turndown.use(image(schema.nodes.image));
     }
     // Overwrite the built-in `listItem` rule if the corresponding node exists in the schema
-    if (schema.nodes.listItem) {
+    if ((schema.nodes.bulletList || schema.nodes.orderedList) && schema.nodes.listItem) {
         turndown.use(listItem(schema.nodes.listItem));
     }
-    // Overwrite the built-in `paragraph` rule if the corresponding node exists in the schema
-    if (schema.nodes.paragraph) {
-        turndown.use(paragraph(schema.nodes.paragraph, isPlainTextDocument(schema)));
-    }
     // Add a rule for `strikethrough` if the corresponding node exists in the schema
     if (schema.marks.strike) {
         turndown.use(strikethrough(schema.marks.strike));

package/dist/serializers/markdown/plugins/image.js

@@ -17,7 +17,7 @@ function image(nodeType) {
     return (turndown) => {
         turndown.addRule(nodeType.name, {
             filter: 'img',
-            replacement: function (_, node) {
+            replacement(_, node) {
                 const src = String(node.getAttribute('src'));
                 // Preserve Data URL image prefix with message about base64 being unsupported
                 const link = src.startsWith('data:') ? `${src.split(',')[0]},NOT_SUPPORTED` : src;

package/dist/serializers/markdown/plugins/list-item.js

@@ -13,11 +13,11 @@ function listItem(nodeType) {
     const tags = extractTagsFromParseRules(nodeType.spec.parseDOM);
     return (turndown) => {
         turndown.addRule(nodeType.name, {
-            filter: (node) => {
+            filter(node) {
                 return (tags.some((tag) => tag.toUpperCase() === node.nodeName) &&
                     node.getAttribute('data-type') !== 'taskItem');
             },
-            replacement: function (content, node) {
+            replacement(content, node) {
                 const parentNode = node.parentNode;
                 let listItemMarker = `${BULLET_LIST_MARKER} `;
                 // Use a sequence of 1–9 digits for the ordered list marker (CommonMark specification)

package/dist/serializers/markdown/plugins/paragraph.js

@@ -9,7 +9,7 @@ function paragraph(nodeType, isPlainText) {
     return (turndown) => {
         turndown.addRule(nodeType.name, {
             filter: 'p',
-            replacement: function (content) {
+            replacement(content) {
                 return isPlainText ? `\n${content}\n` : `\n\n${content}\n\n`;
             },
         });

package/dist/serializers/markdown/plugins/strikethrough.js

@@ -11,10 +11,10 @@ function strikethrough(markType) {
     const tags = extractTagsFromParseRules(markType.spec.parseDOM);
     return (turndown) => {
         turndown.addRule(markType.name, {
-            filter: (node) => {
+            filter(node) {
                 return tags.some((tag) => tag.toUpperCase() === node.nodeName);
             },
-            replacement: (content) => {
+            replacement(content) {
                 return `~~${content}~~`;
             },
         });

package/dist/serializers/markdown/plugins/suggestion.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"suggestion.d.ts","sourceRoot":"","sources":["../../../../src/serializers/markdown/plugins/suggestion.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAA;AACjD,OAAO,KAAK,QAAQ,MAAM,UAAU,CAAA;AAEpC;;;;;GAKG;AACH,iBAAS,UAAU,CAAC,QAAQ,EAAE,QAAQ,GAAG,QAAQ,CAAC,MAAM,CAcvD;AAED,OAAO,EAAE,UAAU,EAAE,CAAA"}
+{"version":3,"file":"suggestion.d.ts","sourceRoot":"","sources":["../../../../src/serializers/markdown/plugins/suggestion.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAA;AACjD,OAAO,KAAK,QAAQ,MAAM,UAAU,CAAA;AAEpC;;;;;GAKG;AACH,iBAAS,UAAU,CAAC,QAAQ,EAAE,QAAQ,GAAG,QAAQ,CAAC,MAAM,CAgBvD;AAED,OAAO,EAAE,UAAU,EAAE,CAAA"}

package/dist/serializers/markdown/plugins/suggestion.js

@@ -9,8 +9,10 @@ function suggestion(nodeType) {
     const attributeType = kebabCase(nodeType.name.replace(/Suggestion$/, ''));
     return (turndown) => {
         turndown.addRule(nodeType.name, {
-            filter: (node) => node.hasAttribute(`data-${attributeType}`),
-            replacement: (_, node) => {
+            filter(node) {
+                return node.hasAttribute(`data-${attributeType}`);
+            },
+            replacement(_, node) {
                 const label = String(node.getAttribute('data-label'));
                 const id = String(node.getAttribute('data-id'));
                 return `[${label}](${attributeType}://${id})`;

package/dist/serializers/markdown/plugins/task-item.js

@@ -13,11 +13,11 @@ function taskItem(nodeType) {
     const tags = extractTagsFromParseRules(nodeType.spec.parseDOM);
     return (turndown) => {
         turndown.addRule(nodeType.name, {
-            filter: (node) => {
+            filter(node) {
                 return (tags.some((tag) => tag.toUpperCase().startsWith(node.nodeName)) &&
                     node.getAttribute('data-type') === 'taskItem');
             },
-            replacement: function (content, node) {
+            replacement(content, node) {
                 const parentNode = node.parentNode;
                 let listItemMarker = `${BULLET_LIST_MARKER} `;
                 if (parentNode?.nodeName === 'UL') {

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@doist/typist",
     "description": "The mighty Tiptap-based rich-text editor React component that powers Doist products.",
-    "version": "1.0.11",
+    "version": "1.0.13",
     "license": "MIT",
     "homepage": "https://typist.doist.dev/",
     "repository": "https://github.com/Doist/typist",
@@ -46,34 +46,34 @@
         "validate:pre-push": "run-s test"
     },
     "dependencies": {
-        "@tiptap/core": "2.0.0-beta.209",
-        "@tiptap/extension-blockquote": "2.0.0-beta.209",
-        "@tiptap/extension-bold": "2.0.0-beta.209",
-        "@tiptap/extension-bullet-list": "2.0.0-beta.209",
-        "@tiptap/extension-character-count": "2.0.0-beta.209",
-        "@tiptap/extension-code": "2.0.0-beta.209",
-        "@tiptap/extension-code-block": "2.0.0-beta.209",
-        "@tiptap/extension-document": "2.0.0-beta.209",
-        "@tiptap/extension-dropcursor": "2.0.0-beta.209",
-        "@tiptap/extension-gapcursor": "2.0.0-beta.209",
-        "@tiptap/extension-hard-break": "2.0.0-beta.209",
-        "@tiptap/extension-heading": "2.0.0-beta.209",
-        "@tiptap/extension-history": "2.0.0-beta.209",
-        "@tiptap/extension-horizontal-rule": "2.0.0-beta.209",
-        "@tiptap/extension-image": "2.0.0-beta.209",
-        "@tiptap/extension-italic": "2.0.0-beta.209",
-        "@tiptap/extension-link": "2.0.0-beta.209",
-        "@tiptap/extension-list-item": "2.0.0-beta.209",
-        "@tiptap/extension-ordered-list": "2.0.0-beta.209",
-        "@tiptap/extension-paragraph": "2.0.0-beta.209",
-        "@tiptap/extension-placeholder": "2.0.0-beta.209",
-        "@tiptap/extension-strike": "2.0.0-beta.209",
-        "@tiptap/extension-task-item": "2.0.0-beta.209",
-        "@tiptap/extension-task-list": "2.0.0-beta.209",
-        "@tiptap/extension-text": "2.0.0-beta.209",
-        "@tiptap/extension-typography": "2.0.0-beta.209",
-        "@tiptap/react": "2.0.0-beta.209",
-        "@tiptap/suggestion": "2.0.0-beta.209",
+        "@tiptap/core": "2.0.0-beta.215",
+        "@tiptap/extension-blockquote": "2.0.0-beta.215",
+        "@tiptap/extension-bold": "2.0.0-beta.215",
+        "@tiptap/extension-bullet-list": "2.0.0-beta.215",
+        "@tiptap/extension-character-count": "2.0.0-beta.215",
+        "@tiptap/extension-code": "2.0.0-beta.215",
+        "@tiptap/extension-code-block": "2.0.0-beta.215",
+        "@tiptap/extension-document": "2.0.0-beta.215",
+        "@tiptap/extension-dropcursor": "2.0.0-beta.215",
+        "@tiptap/extension-gapcursor": "2.0.0-beta.215",
+        "@tiptap/extension-hard-break": "2.0.0-beta.215",
+        "@tiptap/extension-heading": "2.0.0-beta.215",
+        "@tiptap/extension-history": "2.0.0-beta.215",
+        "@tiptap/extension-horizontal-rule": "2.0.0-beta.215",
+        "@tiptap/extension-image": "2.0.0-beta.215",
+        "@tiptap/extension-italic": "2.0.0-beta.215",
+        "@tiptap/extension-link": "2.0.0-beta.215",
+        "@tiptap/extension-list-item": "2.0.0-beta.215",
+        "@tiptap/extension-ordered-list": "2.0.0-beta.215",
+        "@tiptap/extension-paragraph": "2.0.0-beta.215",
+        "@tiptap/extension-placeholder": "2.0.0-beta.215",
+        "@tiptap/extension-strike": "2.0.0-beta.215",
+        "@tiptap/extension-task-item": "2.0.0-beta.215",
+        "@tiptap/extension-task-list": "2.0.0-beta.215",
+        "@tiptap/extension-text": "2.0.0-beta.215",
+        "@tiptap/extension-typography": "2.0.0-beta.215",
+        "@tiptap/react": "2.0.0-beta.215",
+        "@tiptap/suggestion": "2.0.0-beta.215",
         "prosemirror-codemark": "0.4.2",
         "prosemirror-changeset": "2.2.0",
         "prosemirror-collab": "1.3.0",
@@ -97,58 +97,58 @@
     "devDependencies": {
         "@doist/eslint-config": "8.1.3",
         "@doist/prettier-config": "3.0.5",
-        "@doist/reactist": "17.5.0",
+        "@doist/reactist": "17.10.1",
         "@mdx-js/react": "2.2.1",
         "@semantic-release/changelog": "6.0.2",
         "@semantic-release/exec": "6.0.3",
         "@semantic-release/git": "10.0.1",
-        "@storybook/addon-a11y": "6.5.14",
-        "@storybook/addon-essentials": "6.5.14",
-        "@storybook/addons": "6.5.14",
-        "@storybook/builder-vite": "0.2.6",
+        "@storybook/addon-a11y": "6.5.16",
+        "@storybook/addon-essentials": "6.5.16",
+        "@storybook/addons": "6.5.16",
+        "@storybook/builder-vite": "0.2.7",
         "@storybook/mdx2-csf": "0.0.3",
-        "@storybook/react": "6.5.14",
-        "@testing-library/dom": "8.19.0",
+        "@storybook/react": "6.5.16",
+        "@testing-library/dom": "8.20.0",
         "@testing-library/jest-dom": "5.16.5",
         "@testing-library/react": "13.4.0",
-        "@types/jest": "29.2.4",
+        "@types/jest": "29.4.0",
         "@types/lodash-es": "4.17.6",
         "@types/marked": "4.0.8",
-        "@types/react": "18.0.26",
-        "@types/react-dom": "18.0.9",
-        "@types/react-syntax-highlighter": "15.5.5",
+        "@types/react": "18.0.27",
+        "@types/react-dom": "18.0.10",
+        "@types/react-syntax-highlighter": "15.5.6",
         "@types/turndown": "5.0.1",
         "boring-avatars": "1.7.0",
         "classnames": "2.3.2",
         "conventional-changelog-conventionalcommits": "5.0.0",
         "emoji-regex": "10.2.1",
-        "eslint": "8.29.0",
+        "eslint": "8.33.0",
         "eslint-formatter-codeframe": "7.32.1",
-        "eslint-import-resolver-typescript": "3.5.2",
-        "eslint-plugin-jest": "27.1.7",
+        "eslint-import-resolver-typescript": "3.5.3",
+        "eslint-plugin-jest": "27.2.1",
         "eslint-plugin-simple-import-sort": "8.0.0",
         "eslint-plugin-unicorn": "45.0.2",
         "github-markdown-css": "5.1.0",
-        "husky": "8.0.2",
+        "husky": "8.0.3",
         "ignore-sync": "6.0.2",
         "is-ci": "3.0.1",
-        "jest": "29.3.1",
-        "jest-environment-jsdom": "29.3.1",
-        "lint-staged": "13.1.0",
+        "jest": "29.4.2",
+        "jest-environment-jsdom": "29.4.2",
+        "lint-staged": "13.1.1",
         "npm-run-all": "4.1.5",
-        "prettier": "2.8.1",
+        "prettier": "2.8.4",
         "react-icons": "4.7.1",
-        "react-markdown": "8.0.4",
+        "react-markdown": "8.0.5",
         "react-syntax-highlighter": "15.5.0",
         "rehype-raw": "6.1.1",
         "remark-gfm": "3.0.1",
         "rimraf": "3.0.2",
         "semantic-release": "19.0.5",
         "storybook-css-modules": "1.0.8",
-        "ts-jest": "29.0.3",
+        "ts-jest": "29.0.5",
         "ts-node": "10.9.1",
-        "type-fest": "3.4.0",
-        "typescript": "4.9.4",
+        "type-fest": "3.5.6",
+        "typescript": "4.9.5",
         "typescript-plugin-css-modules": "4.1.1"
     },
     "peerDependencies": {