@doist/typist 1.0.0

package/dist/extensions/plain-text/plain-text-kit.d.ts

@@ -0,0 +1,42 @@
+import { Extension } from '@tiptap/core';
+import { HistoryOptions } from '@tiptap/extension-history';
+import type { PlainTextDocumentOptions } from './plain-text-document';
+import type { PlainTextParagraphOptions } from './plain-text-paragraph';
+/**
+ * The options available to customize the `PlainTextKit` extension.
+ */
+declare type PlainTextKitOptions = {
+    /**
+     * Set options for the `Document` extension, or `false` to disable.
+     */
+    document: Partial<PlainTextDocumentOptions> | false;
+    /**
+     * Set options for the `History` extension, or `false` to disable.
+     */
+    history: Partial<HistoryOptions> | false;
+    /**
+     * Set options for the `Paragraph` extension, or `false` to disable.
+     */
+    paragraph: Partial<PlainTextParagraphOptions> | false;
+    /**
+     * Set to `false` to disable the `Text` extension.
+     */
+    text: false;
+    /**
+     * Set to `false` to disable the `Typography` extension.
+     */
+    typography: false;
+    /**
+     * Set to `false` to disable the `SmartMarkdownTyping` extension.
+     */
+    smartMarkdownTyping: false;
+};
+/**
+ * The `PlainTextKit` extension is a collection of the minimal required extensions to have a basic
+ * plain-text editor working. This extension is based on the official `StarterKit` extension
+ * implementation, allowing almost every extension to be customized or disabled.
+ */
+declare const PlainTextKit: Extension<PlainTextKitOptions, any>;
+export { PlainTextKit };
+export type { PlainTextKitOptions };
+//# sourceMappingURL=plain-text-kit.d.ts.map

package/dist/extensions/plain-text/plain-text-kit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plain-text-kit.d.ts","sourceRoot":"","sources":["../../../src/extensions/plain-text/plain-text-kit.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AACxC,OAAO,EAAW,cAAc,EAAE,MAAM,2BAA2B,CAAA;AAanE,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,uBAAuB,CAAA;AACrE,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,wBAAwB,CAAA;AAEvE;;GAEG;AACH,aAAK,mBAAmB,GAAG;IACvB;;OAEG;IACH,QAAQ,EAAE,OAAO,CAAC,wBAAwB,CAAC,GAAG,KAAK,CAAA;IAEnD;;OAEG;IACH,OAAO,EAAE,OAAO,CAAC,cAAc,CAAC,GAAG,KAAK,CAAA;IAExC;;OAEG;IACH,SAAS,EAAE,OAAO,CAAC,yBAAyB,CAAC,GAAG,KAAK,CAAA;IAErD;;OAEG;IACH,IAAI,EAAE,KAAK,CAAA;IAEX;;OAEG;IACH,UAAU,EAAE,KAAK,CAAA;IAEjB;;OAEG;IACH,mBAAmB,EAAE,KAAK,CAAA;CAC7B,CAAA;AAED;;;;GAIG;AACH,QAAA,MAAM,YAAY,qCAyChB,CAAA;AAEF,OAAO,EAAE,YAAY,EAAE,CAAA;AAEvB,YAAY,EAAE,mBAAmB,EAAE,CAAA"}

package/dist/extensions/plain-text/plain-text-kit.js

@@ -0,0 +1,47 @@
+import { Extension } from '@tiptap/core';
+import { History } from '@tiptap/extension-history';
+import { Text } from '@tiptap/extension-text';
+import { Typography } from '@tiptap/extension-typography';
+import { CopyMarkdownSource } from '../shared/copy-markdown-source';
+import { PasteSinglelineText } from '../shared/paste-singleline-text';
+import { SmartMarkdownTyping } from './smart-markdown-typing/smart-markdown-typing';
+import { PasteMultilineText } from './paste-multiline-text';
+import { PlainTextDocument } from './plain-text-document';
+import { PlainTextParagraph } from './plain-text-paragraph';
+/**
+ * The `PlainTextKit` extension is a collection of the minimal required extensions to have a basic
+ * plain-text editor working. This extension is based on the official `StarterKit` extension
+ * implementation, allowing almost every extension to be customized or disabled.
+ */
+const PlainTextKit = Extension.create({
+    name: 'plainTextKit',
+    addExtensions() {
+        const extensions = [];
+        if (this.options.document !== false) {
+            extensions.push(PlainTextDocument.configure(this.options?.document), 
+            // Supports copying the underlying Markdown source to the clipboard
+            CopyMarkdownSource, 
+            // Supports pasting plain-text into both a singleline and multiline editor
+            this.options?.document?.multiline === false
+                ? PasteSinglelineText
+                : PasteMultilineText);
+        }
+        if (this.options.history !== false) {
+            extensions.push(History.configure(this.options?.history));
+        }
+        if (this.options.paragraph !== false) {
+            extensions.push(PlainTextParagraph.configure(this.options?.paragraph));
+        }
+        if (this.options.text !== false) {
+            extensions.push(Text);
+        }
+        if (this.options.typography !== false) {
+            extensions.push(Typography);
+        }
+        if (this.options.smartMarkdownTyping !== false) {
+            extensions.push(SmartMarkdownTyping);
+        }
+        return extensions;
+    },
+});
+export { PlainTextKit };

package/dist/extensions/plain-text/plain-text-paragraph.d.ts

@@ -0,0 +1,9 @@
+import { ParagraphOptions } from '@tiptap/extension-paragraph';
+/**
+ * Custom extension that extends the built-in `Paragraph` extension to add an additional keyboard
+ * shortcut to insert a newline (needed to behave more closely to the `<textarea>` component).
+ */
+declare const PlainTextParagraph: import("@tiptap/core").Node<ParagraphOptions, any>;
+export { PlainTextParagraph };
+export type { ParagraphOptions as PlainTextParagraphOptions };
+//# sourceMappingURL=plain-text-paragraph.d.ts.map

package/dist/extensions/plain-text/plain-text-paragraph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plain-text-paragraph.d.ts","sourceRoot":"","sources":["../../../src/extensions/plain-text/plain-text-paragraph.ts"],"names":[],"mappings":"AAAA,OAAO,EAAa,gBAAgB,EAAE,MAAM,6BAA6B,CAAA;AAEzE;;;GAGG;AACH,QAAA,MAAM,kBAAkB,oDAMtB,CAAA;AAEF,OAAO,EAAE,kBAAkB,EAAE,CAAA;AAE7B,YAAY,EAAE,gBAAgB,IAAI,yBAAyB,EAAE,CAAA"}

package/dist/extensions/plain-text/plain-text-paragraph.js

@@ -0,0 +1,13 @@
+import { Paragraph } from '@tiptap/extension-paragraph';
+/**
+ * Custom extension that extends the built-in `Paragraph` extension to add an additional keyboard
+ * shortcut to insert a newline (needed to behave more closely to the `<textarea>` component).
+ */
+const PlainTextParagraph = Paragraph.extend({
+    addKeyboardShortcuts() {
+        return {
+            'Shift-Enter': () => this.editor.commands.enter(),
+        };
+    },
+});
+export { PlainTextParagraph };

package/dist/extensions/plain-text/smart-markdown-typing/plugins/smart-lists.d.ts

@@ -0,0 +1,9 @@
+import { Plugin } from 'prosemirror-state';
+/**
+ * This plugin provides a more plesant typing experience for both standard and task lists, adding
+ * the list marker automatically when pressing the `Enter` key, and it also supports list items
+ * indentation with the `Tab` and `Shift+Tab` keys, forward and backward, respectively.
+ */
+declare const smartLists: Plugin<any>;
+export { smartLists };
+//# sourceMappingURL=smart-lists.d.ts.map

package/dist/extensions/plain-text/smart-markdown-typing/plugins/smart-lists.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"smart-lists.d.ts","sourceRoot":"","sources":["../../../../../src/extensions/plain-text/smart-markdown-typing/plugins/smart-lists.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAa,MAAM,mBAAmB,CAAA;AAsBrD;;;;GAIG;AACH,QAAA,MAAM,UAAU,aAsFd,CAAA;AAEF,OAAO,EAAE,UAAU,EAAE,CAAA"}

package/dist/extensions/plain-text/smart-markdown-typing/plugins/smart-lists.js

@@ -0,0 +1,89 @@
+import { Plugin, PluginKey } from 'prosemirror-state';
+import { isMultilineDocument } from '../../../../helpers/schema';
+/**
+ * A list of the allowed keys that might trigger smart typing.
+ */
+const ALLOWED_KEYS = ['Enter', 'Tab'];
+/**
+ * The standard and task list item regex for smart typing triggers.
+ */
+const REGEX_LIST_ITEM = /^( *(?:(?:\*|-)(?: \[[ x]\])?|\d+\.) )[^\n]*$/i;
+/**
+ * A string with the minimum required spaces to properly indent list items.
+ */
+const INDENT_SPACES = '    ';
+/**
+ * This plugin provides a more plesant typing experience for both standard and task lists, adding
+ * the list marker automatically when pressing the `Enter` key, and it also supports list items
+ * indentation with the `Tab` and `Shift+Tab` keys, forward and backward, respectively.
+ */
+const smartLists = new Plugin({
+    key: new PluginKey('smartLists'),
+    props: {
+        handleKeyDown(view, event) {
+            const { schema } = view.state;
+            const { selection, tr } = view.state;
+            // Do not handle the event if not in a multiline document
+            if (!isMultilineDocument(schema)) {
+                return false;
+            }
+            // Do not handle the event if allowed keys were not pressed
+            if (!ALLOWED_KEYS.includes(event.key)) {
+                return false;
+            }
+            const match = selection.$from.nodeBefore?.text?.match(REGEX_LIST_ITEM);
+            // Do not handle the event if a list/task item was not found
+            if (!match) {
+                return false;
+            }
+            // Insert a new list marker with `Enter`?
+            if (event.key === 'Enter') {
+                // If the whole match is different from the first group match, the list item is not
+                // empty, and a new list marker is inserted; If they are equal, the list item is
+                // empty, and the list marker is deleted
+                if (match[0] !== match[1]) {
+                    // Attempt to parse the first group match as an ordered list item marker
+                    const orderedListItemMarkerIndex = parseInt(match[1], 10);
+                    // Increment the ordered list item marker by 1 if it's a number, otherwise
+                    // use the first group match as the list item marker
+                    const nextListItemMarker = orderedListItemMarkerIndex
+                        ? `${orderedListItemMarkerIndex + 1}. `
+                        : // Make sure the next task item marker is unchecked
+                            match[1].replace(/\[x\]/i, '[ ]');
+                    view.dispatch(tr
+                        .replaceSelectionWith(schema.node('paragraph', {}, schema.text(nextListItemMarker)))
+                        .scrollIntoView());
+                }
+                else {
+                    view.dispatch(tr.delete(selection.from - match[1].length, selection.to));
+                }
+            }
+            // Indent the list item with `Tab` or `Shift+Tab`?
+            else if (event.key === 'Tab') {
+                // If the whole match is different from the first group match, the text cursor is
+                // not at the beginning of the list item (i.e., `* |<Text>`, where the pipe is), and
+                // the event is not handled (for now this restriction is disabled)
+                // if (match[0] !== match[1]) {
+                //     return false
+                // }
+                // Indent the list item forward or backward?
+                if (!event.shiftKey) {
+                    // Indent the list item forward
+                    view.dispatch(tr
+                        .insertText(INDENT_SPACES, selection.from - match[0].length)
+                        .scrollIntoView());
+                }
+                else {
+                    // Indent the list item backward if the whole match starts with a whitespace,
+                    // otherwise do nothing as the list item is already at the start of the line
+                    if (match[0].startsWith(INDENT_SPACES)) {
+                        view.dispatch(tr.delete(selection.from - match[0].length, selection.to - match[0].length + INDENT_SPACES.length));
+                    }
+                }
+            }
+            // Suppress the default handling behaviour
+            return true;
+        },
+    },
+});
+export { smartLists };

package/dist/extensions/plain-text/smart-markdown-typing/plugins/smart-select-wrap.d.ts

@@ -0,0 +1,9 @@
+import { Plugin } from 'prosemirror-state';
+/**
+ * This plugin wraps a selection with matching symbols based on the typed character, wrapping the
+ * selection with the corresponding opening and closing bracket symbols when appropriate. This
+ * plugin does not have support for multiple selection ranges.
+ */
+declare const smartSelectWrap: Plugin<any>;
+export { smartSelectWrap };
+//# sourceMappingURL=smart-select-wrap.d.ts.map

package/dist/extensions/plain-text/smart-markdown-typing/plugins/smart-select-wrap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"smart-select-wrap.d.ts","sourceRoot":"","sources":["../../../../../src/extensions/plain-text/smart-markdown-typing/plugins/smart-select-wrap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAA4B,MAAM,mBAAmB,CAAA;AAsBpE;;;;GAIG;AACH,QAAA,MAAM,eAAe,aA+BnB,CAAA;AAEF,OAAO,EAAE,eAAe,EAAE,CAAA"}

package/dist/extensions/plain-text/smart-markdown-typing/plugins/smart-select-wrap.js

@@ -0,0 +1,49 @@
+import { Plugin, PluginKey, TextSelection } from 'prosemirror-state';
+/**
+ * An object holding the acceptable wrapping symbols. The key represents the trigger character, and
+ * the character to be added before the selection, while the value represents the character to be
+ * added after the selection.
+ */
+const WRAPPING_SYMBOLS = {
+    '*': '*',
+    _: '_',
+    '~': '~',
+    '"': '"',
+    "'": "'",
+    '`': '`',
+    '(': ')',
+    '[': ']',
+    '{': '}',
+    '<': '>',
+};
+/**
+ * This plugin wraps a selection with matching symbols based on the typed character, wrapping the
+ * selection with the corresponding opening and closing bracket symbols when appropriate. This
+ * plugin does not have support for multiple selection ranges.
+ */
+const smartSelectWrap = new Plugin({
+    key: new PluginKey('smartSelectWrap'),
+    props: {
+        handleTextInput(view, from, to, symbol) {
+            const { selection, tr } = view.state;
+            // Do not handle the event if the selection is empty
+            if (selection.empty) {
+                return false;
+            }
+            const wrappingSymbol = WRAPPING_SYMBOLS[symbol];
+            // Do not handle the event if no wrapping symbol was typed
+            if (wrappingSymbol === undefined) {
+                return false;
+            }
+            // Insert wrapping symbols around the selected text
+            view.dispatch(tr
+                .insertText(symbol, from, from)
+                .insertText(wrappingSymbol, to + 1, to + 1)
+                .setSelection(TextSelection.create(tr.doc, from + 1, to + 1))
+                .scrollIntoView());
+            // Suppress the default handling behaviour
+            return true;
+        },
+    },
+});
+export { smartSelectWrap };

package/dist/extensions/plain-text/smart-markdown-typing/plugins/smart-url-pasting.d.ts

@@ -0,0 +1,9 @@
+import { Plugin } from 'prosemirror-state';
+/**
+ * This plugin replaces a selection with the pasted URL using proper link syntax; unless the
+ * selection is itself a URL, which in that case the selection will just be replaced by the pasted
+ * URL. This plugin does not have support for multiple selection ranges.
+ */
+declare const smartUrlPasting: Plugin<any>;
+export { smartUrlPasting };
+//# sourceMappingURL=smart-url-pasting.d.ts.map

package/dist/extensions/plain-text/smart-markdown-typing/plugins/smart-url-pasting.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"smart-url-pasting.d.ts","sourceRoot":"","sources":["../../../../../src/extensions/plain-text/smart-markdown-typing/plugins/smart-url-pasting.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAA4B,MAAM,mBAAmB,CAAA;AAcpE;;;;GAIG;AACH,QAAA,MAAM,eAAe,aAsCnB,CAAA;AAEF,OAAO,EAAE,eAAe,EAAE,CAAA"}

package/dist/extensions/plain-text/smart-markdown-typing/plugins/smart-url-pasting.js

@@ -0,0 +1,43 @@
+import { Plugin, PluginKey, TextSelection } from 'prosemirror-state';
+import { ClipboardDataType } from '../../../../constants/common';
+/**
+ * The perfect URL validation regex for Web URLs.
+ *
+ * @see https://mathiasbynens.be/demo/url-regex
+ */
+const REGEX_WEB_URL = /^(?:(?:(?:https?|ftp):)?\/\/)(?:\S+(?::\S*)?@)?(?:(?!(?:10|127)(?:\.\d{1,3}){3})(?!(?:169\.254|192\.168)(?:\.\d{1,3}){2})(?!172\.(?:1[6-9]|2\d|3[0-1])(?:\.\d{1,3}){2})(?:[1-9]\d?|1\d\d|2[01]\d|22[0-3])(?:\.(?:1?\d{1,2}|2[0-4]\d|25[0-5])){2}(?:\.(?:[1-9]\d?|1\d\d|2[0-4]\d|25[0-4]))|(?:(?:[a-z0-9\u00a1-\uffff][a-z0-9\u00a1-\uffff_-]{0,62})?[a-z0-9\u00a1-\uffff]\.)+(?:[a-z\u00a1-\uffff]{2,}\.?))(?::\d{2,5})?(?:[/?#]\S*)?$/i;
+/**
+ * This plugin replaces a selection with the pasted URL using proper link syntax; unless the
+ * selection is itself a URL, which in that case the selection will just be replaced by the pasted
+ * URL. This plugin does not have support for multiple selection ranges.
+ */
+const smartUrlPasting = new Plugin({
+    key: new PluginKey('smartUrlPasting'),
+    props: {
+        handlePaste(view, event) {
+            const { selection, tr } = view.state;
+            // Do not handle the event if the selection is empty
+            if (selection.empty) {
+                return false;
+            }
+            // Do not handle the event if the selected text is already a URL
+            if (REGEX_WEB_URL.test(selection.$head.parent.textContent)) {
+                return false;
+            }
+            const clipboardText = event.clipboardData?.getData(ClipboardDataType.Text).trim();
+            // Do not handle the event if the clipboard text is not a URL
+            if (!clipboardText || !REGEX_WEB_URL.test(clipboardText)) {
+                return false;
+            }
+            // Apply the Markdown link syntax to the selected and clipboard text pair
+            view.dispatch(tr
+                .insertText('[', selection.from, selection.from)
+                .insertText(`](${clipboardText})`, selection.to + 1, selection.to + 1)
+                .setSelection(TextSelection.create(tr.doc, selection.from + 1, selection.to + 1))
+                .scrollIntoView());
+            // Suppress the default handling behaviour
+            return true;
+        },
+    },
+});
+export { smartUrlPasting };

package/dist/extensions/plain-text/smart-markdown-typing/smart-markdown-typing.d.ts

@@ -0,0 +1,8 @@
+import { Extension } from '@tiptap/core';
+/**
+ * The `SmartMarkdownTyping` extension is a collection of ProseMirror plugins that attempts to mimic
+ * a smart GitHub like typing experience, and is only meant to be used with a plain-text editor.
+ */
+declare const SmartMarkdownTyping: Extension<any, any>;
+export { SmartMarkdownTyping };
+//# sourceMappingURL=smart-markdown-typing.d.ts.map

package/dist/extensions/plain-text/smart-markdown-typing/smart-markdown-typing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"smart-markdown-typing.d.ts","sourceRoot":"","sources":["../../../../src/extensions/plain-text/smart-markdown-typing/smart-markdown-typing.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AAQxC;;;GAGG;AACH,QAAA,MAAM,mBAAmB,qBAMvB,CAAA;AAEF,OAAO,EAAE,mBAAmB,EAAE,CAAA"}

package/dist/extensions/plain-text/smart-markdown-typing/smart-markdown-typing.js

@@ -0,0 +1,17 @@
+import { Extension } from '@tiptap/core';
+import { SMART_MARKDOWN_TYPING_PRIORITY } from '../../../constants/extension-priorities';
+import { smartLists } from './plugins/smart-lists';
+import { smartSelectWrap } from './plugins/smart-select-wrap';
+import { smartUrlPasting } from './plugins/smart-url-pasting';
+/**
+ * The `SmartMarkdownTyping` extension is a collection of ProseMirror plugins that attempts to mimic
+ * a smart GitHub like typing experience, and is only meant to be used with a plain-text editor.
+ */
+const SmartMarkdownTyping = Extension.create({
+    name: 'smartMarkdownTyping',
+    priority: SMART_MARKDOWN_TYPING_PRIORITY,
+    addProseMirrorPlugins() {
+        return [smartLists, smartSelectWrap, smartUrlPasting];
+    },
+});
+export { SmartMarkdownTyping };

package/dist/extensions/rich-text/bold-and-italics.d.ts

@@ -0,0 +1,8 @@
+import { Mark } from '@tiptap/core';
+/**
+ * The `BoldAndItalics` extension adds the ability to use the `***` and `___` Markdown shortcuts
+ * when typing and pasting into the editor.
+ */
+declare const BoldAndItalics: Mark<any, any>;
+export { BoldAndItalics };
+//# sourceMappingURL=bold-and-italics.d.ts.map

package/dist/extensions/rich-text/bold-and-italics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bold-and-italics.d.ts","sourceRoot":"","sources":["../../../src/extensions/rich-text/bold-and-italics.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAgC,MAAM,cAAc,CAAA;AAOjE;;;GAGG;AACH,QAAA,MAAM,cAAc,gBA6BlB,CAAA;AAEF,OAAO,EAAE,cAAc,EAAE,CAAA"}

package/dist/extensions/rich-text/bold-and-italics.js

@@ -0,0 +1,40 @@
+import { Mark, markInputRule, markPasteRule } from '@tiptap/core';
+const starInputRegex = /(?:^|\s)((?:\*{3})((?:[^*]+))(?:\*{3}))$/;
+const starPasteRegex = /(?:^|\s)((?:\*{3})((?:[^*]+))(?:\*{3}))/g;
+const underscoreInputRegex = /(?:^|\s)((?:_{3})((?:[^_]+))(?:_{3}))$/;
+const underscorePasteRegex = /(?:^|\s)((?:_{3})((?:[^_]+))(?:_{3}))/g;
+/**
+ * The `BoldAndItalics` extension adds the ability to use the `***` and `___` Markdown shortcuts
+ * when typing and pasting into the editor.
+ */
+const BoldAndItalics = Mark.create({
+    name: 'boldAndItalics',
+    renderHTML({ HTMLAttributes }) {
+        return ['strong', ['em', HTMLAttributes, 0]];
+    },
+    addInputRules() {
+        return [
+            markInputRule({
+                find: starInputRegex,
+                type: this.type,
+            }),
+            markInputRule({
+                find: underscoreInputRegex,
+                type: this.type,
+            }),
+        ];
+    },
+    addPasteRules() {
+        return [
+            markPasteRule({
+                find: starPasteRegex,
+                type: this.type,
+            }),
+            markPasteRule({
+                find: underscorePasteRegex,
+                type: this.type,
+            }),
+        ];
+    },
+});
+export { BoldAndItalics };

package/dist/extensions/rich-text/curvenote-codemark.d.ts

@@ -0,0 +1,11 @@
+import { Extension } from '@tiptap/core';
+/**
+ * The `CurvenoteCodemark` extension adds a plugin for ProseMirror that makes it easier to handle,
+ * and navigate inline code marks. The plugin creates a fake cursor (if necessary) to show if the
+ * next character to be typed will or will not be inside the inline code mark.
+ *
+ * @see https://github.com/curvenote/prosemirror-codemark
+ */
+declare const CurvenoteCodemark: Extension<any, any>;
+export { CurvenoteCodemark };
+//# sourceMappingURL=curvenote-codemark.d.ts.map

package/dist/extensions/rich-text/curvenote-codemark.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"curvenote-codemark.d.ts","sourceRoot":"","sources":["../../../src/extensions/rich-text/curvenote-codemark.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AAGxC;;;;;;GAMG;AACH,QAAA,MAAM,iBAAiB,qBAOrB,CAAA;AAEF,OAAO,EAAE,iBAAiB,EAAE,CAAA"}

package/dist/extensions/rich-text/curvenote-codemark.js

@@ -0,0 +1,18 @@
+import { Extension } from '@tiptap/core';
+import codemark from 'prosemirror-codemark';
+/**
+ * The `CurvenoteCodemark` extension adds a plugin for ProseMirror that makes it easier to handle,
+ * and navigate inline code marks. The plugin creates a fake cursor (if necessary) to show if the
+ * next character to be typed will or will not be inside the inline code mark.
+ *
+ * @see https://github.com/curvenote/prosemirror-codemark
+ */
+const CurvenoteCodemark = Extension.create({
+    name: 'curvenoteCodemark',
+    addProseMirrorPlugins() {
+        return codemark({
+            markType: this.editor.schema.marks.code,
+        });
+    },
+});
+export { CurvenoteCodemark };

package/dist/extensions/rich-text/paste-emojis.d.ts

@@ -0,0 +1,9 @@
+import { Extension } from '@tiptap/core';
+/**
+ * The `PasteEmojis` extension adds the ability to paste HTML image emojis as unicode characters
+ * into the editor, ignoring the HTML image source. This extension works by replacing all `<img>`
+ * tags with the emoji unicode character, if one is found in the `alt` attribute.
+ */
+declare const PasteEmojis: Extension<any, any>;
+export { PasteEmojis };
+//# sourceMappingURL=paste-emojis.d.ts.map

package/dist/extensions/rich-text/paste-emojis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paste-emojis.d.ts","sourceRoot":"","sources":["../../../src/extensions/rich-text/paste-emojis.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AAaxC;;;;GAIG;AACH,QAAA,MAAM,WAAW,qBAcf,CAAA;AAEF,OAAO,EAAE,WAAW,EAAE,CAAA"}

package/dist/extensions/rich-text/paste-emojis.js

@@ -0,0 +1,28 @@
+import { Extension } from '@tiptap/core';
+import emojiRegex from 'emoji-regex';
+import { Plugin, PluginKey } from 'prosemirror-state';
+// Regular expression to match all emoji symbols and sequences (including textual representations)
+const baseEmojiRegExp = emojiRegex();
+// Regular expression to match `<img>` tags with emoji unicode characters in the `alt` attribute
+const imgWithEmojiRegExp = new RegExp(`<img[^>]+alt="(${baseEmojiRegExp.source})"[^>]+/?>`, baseEmojiRegExp.flags);
+/**
+ * The `PasteEmojis` extension adds the ability to paste HTML image emojis as unicode characters
+ * into the editor, ignoring the HTML image source. This extension works by replacing all `<img>`
+ * tags with the emoji unicode character, if one is found in the `alt` attribute.
+ */
+const PasteEmojis = Extension.create({
+    name: 'pasteEmojis',
+    addProseMirrorPlugins() {
+        return [
+            new Plugin({
+                key: new PluginKey('pasteEmojis'),
+                props: {
+                    transformPastedHTML(html) {
+                        return html.replace(imgWithEmojiRegExp, (_, alt) => alt);
+                    },
+                },
+            }),
+        ];
+    },
+});
+export { PasteEmojis };

package/dist/extensions/rich-text/paste-markdown.d.ts

@@ -0,0 +1,11 @@
+import { Extension } from '@tiptap/core';
+/**
+ * The `PasteMarkdown` extension adds the ability to paste Markdown as HTML into the editor,
+ * providing full rich-text support to the pasted content. The pasting behavior was inspired from
+ * the GitLab implementation, and adapted to our requirements.
+ *
+ * @see https://gitlab.com/gitlab-org/gitlab/-/blob/v14.10.0-ee/app/assets/javascripts/content_editor/extensions/paste_markdown.js
+ */
+declare const PasteMarkdown: Extension<any, any>;
+export { PasteMarkdown };
+//# sourceMappingURL=paste-markdown.d.ts.map

package/dist/extensions/rich-text/paste-markdown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paste-markdown.d.ts","sourceRoot":"","sources":["../../../src/extensions/rich-text/paste-markdown.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AAexC;;;;;;GAMG;AACH,QAAA,MAAM,aAAa,qBA4EjB,CAAA;AAEF,OAAO,EAAE,aAAa,EAAE,CAAA"}

package/dist/extensions/rich-text/paste-markdown.js

@@ -0,0 +1,68 @@
+import { Extension } from '@tiptap/core';
+import { Fragment, Slice } from 'prosemirror-model';
+import { Plugin, PluginKey } from 'prosemirror-state';
+import { ClipboardDataType } from '../../constants/common';
+/**
+ * The `PasteMarkdown` extension adds the ability to paste Markdown as HTML into the editor,
+ * providing full rich-text support to the pasted content. The pasting behavior was inspired from
+ * the GitLab implementation, and adapted to our requirements.
+ *
+ * @see https://gitlab.com/gitlab-org/gitlab/-/blob/v14.10.0-ee/app/assets/javascripts/content_editor/extensions/paste_markdown.js
+ */
+const PasteMarkdown = Extension.create({
+    name: 'pasteMarkdown',
+    addProseMirrorPlugins() {
+        const { editor } = this;
+        return [
+            new Plugin({
+                key: new PluginKey('pasteMarkdown'),
+                props: {
+                    clipboardTextParser(text) {
+                        // Override the default parser behavior of splitting text into lines (which
+                        // does not match the CommonMark spec for handling break lines), and instead
+                        // return a document slice with a single text node containing the whole
+                        // clipboard text, so that we can rely on the slice on `handlePaste` below)
+                        return Slice.maxOpen(Fragment.from(editor.schema.text(text)));
+                    },
+                    handlePaste(_, event, slice) {
+                        const clipboardText = event.clipboardData
+                            ?.getData(ClipboardDataType.Text)
+                            .trim();
+                        const clipboardContainsHTML = Boolean(event.clipboardData?.types.some((type) => type === ClipboardDataType.HTML));
+                        // Unfortunately, the VS Code clipboard data type is not supported by
+                        // Firefox or Safari, which means that copy/paste experience from VS Code
+                        // into the editor with any of those browsers is supbar:
+                        //  * The Markdown syntax is not fully converted to rich-text
+                        //  * Code is not detected nor converted to a code-block
+                        const clipboardContainsVSCodeMetadata = Boolean(event.clipboardData?.types.some((type) => type === ClipboardDataType.VSCode));
+                        const vsCodeClipboardMetadata = clipboardContainsVSCodeMetadata
+                            ? JSON.parse(event.clipboardData?.getData(ClipboardDataType.VSCode) ||
+                                '{}')
+                            : {};
+                        // Do not handle the paste event if:
+                        //  * The clipboard doesn't contain plain-text
+                        //  * The clipboard HTML content doesn't come with VS Code metadata
+                        //  * The clipboard VS Code metadata does not represent plain-Markdown
+                        //  * The user is pasting inside a code block element
+                        if (!clipboardText ||
+                            (clipboardContainsHTML && !clipboardContainsVSCodeMetadata) ||
+                            (clipboardContainsVSCodeMetadata &&
+                                vsCodeClipboardMetadata.mode !== 'markdown') ||
+                            editor.state.selection.$from.parent.type.name === 'codeBlock') {
+                            return false;
+                        }
+                        // Send the clipboard text through the HTML serializer to convert potential
+                        // Markdown into HTML, and then insert it into the editor
+                        editor.commands.insertMarkdownContent(
+                        // The slice content is used instead of `clipboardText` as the pasted
+                        // content could have already been transformed by other plugins
+                        slice.content.textBetween(0, slice.content.size));
+                        // Suppress the default handling behaviour
+                        return true;
+                    },
+                },
+            }),
+        ];
+    },
+});
+export { PasteMarkdown };

package/dist/extensions/rich-text/rich-text-document.d.ts

@@ -0,0 +1,17 @@
+/**
+ * The options available to customize the `RichTextDocumentOptions` extension.
+ */
+declare type RichTextDocumentOptions = {
+    /**
+     * Indicates whether the document accepts multiple lines of input or only a single line.
+     */
+    multiline: boolean;
+};
+/**
+ * Custom extension that extends the built-in `Document` extension to define a schema for multiline
+ * or singleline rich-text documents (as opposed to the multiple block nodes by default).
+ */
+declare const RichTextDocument: import("@tiptap/core").Node<RichTextDocumentOptions, any>;
+export { RichTextDocument };
+export type { RichTextDocumentOptions };
+//# sourceMappingURL=rich-text-document.d.ts.map

package/dist/extensions/rich-text/rich-text-document.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rich-text-document.d.ts","sourceRoot":"","sources":["../../../src/extensions/rich-text/rich-text-document.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,aAAK,uBAAuB,GAAG;IAC3B;;OAEG;IACH,SAAS,EAAE,OAAO,CAAA;CACrB,CAAA;AAED;;;GAGG;AACH,QAAA,MAAM,gBAAgB,2DAUpB,CAAA;AAEF,OAAO,EAAE,gBAAgB,EAAE,CAAA;AAE3B,YAAY,EAAE,uBAAuB,EAAE,CAAA"}