@doist/typist 1.0.0

package/dist/components/typist-editor.js

@@ -0,0 +1,160 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { forwardRef, useImperativeHandle, useMemo } from 'react';
+import { useEvent } from 'react-use-event-hook';
+import { getSchema } from '@tiptap/core';
+import { Placeholder } from '@tiptap/extension-placeholder';
+import { EditorContent } from '@tiptap/react';
+import { ExtraEditorCommands } from '../extensions/core/extra-editor-commands/extra-editor-commands';
+import { ViewEventHandlers } from '../extensions/core/view-event-handlers';
+import { isMultilineDocument, isPlainTextDocument } from '../helpers/schema';
+import { useEditor } from '../hooks/use-editor';
+import { createHTMLSerializer } from '../serializers/html/html';
+import { createMarkdownSerializer } from '../serializers/markdown/markdown';
+import { getAllNodesAttributesByType, resolveContentSelection } from './typist-editor.helper';
+/**
+ * The `TypistEditor` component represents a plain-text or a rich-text editing control, built on
+ * top of the amazing [Tiptap](https://tiptap.dev/) library.
+ */
+const TypistEditor = forwardRef(function TypistEditor({ autoFocus, className, content = '', contentSelection, editable = true, extensions, placeholder, onBeforeCreate, onCreate, onUpdate, onSelectionUpdate, onTransaction, onFocus, onBlur, onDestroy, 'aria-describedby': ariaDescribedBy, 'aria-label': ariaLabel, 'aria-labelledby': ariaLabelledBy, onClick, onKeyDown, }, ref) {
+    const allExtensions = useMemo(function initializeExtensions() {
+        return [
+            // Custom core extensions
+            ...(placeholder
+                ? [
+                    Placeholder.configure({
+                        placeholder,
+                    }),
+                ]
+                : []),
+            ExtraEditorCommands,
+            ViewEventHandlers.configure({
+                onClick,
+                onKeyDown,
+            }),
+            // Always register external extensions at the end so they get a higher priority and
+            // are loaded earlier (necessary to override behaviors from built-in extensions)
+            ...extensions,
+        ];
+    }, [extensions, onClick, onKeyDown, placeholder]);
+    const schema = useMemo(function generateProseMirrorSchema() {
+        return getSchema(allExtensions);
+    }, [allExtensions]);
+    const htmlSerializer = useMemo(function initializeHTMLSerializer() {
+        return createHTMLSerializer(schema);
+    }, [schema]);
+    const markdownSerializer = useMemo(function initializeMarkdownSerializer() {
+        return createMarkdownSerializer(schema);
+    }, [schema]);
+    const htmlContent = useMemo(function generateHTMLContent() {
+        return htmlSerializer.serialize(content);
+    }, [content, htmlSerializer]);
+    const ariaAttributes = useMemo(function initializeAriaAttributes() {
+        return {
+            'aria-readonly': String(!editable),
+            'aria-multiline': String(isMultilineDocument(schema)),
+            ...(ariaDescribedBy ? { 'aria-describedby': ariaDescribedBy } : {}),
+            ...(ariaLabel ? { 'aria-label': ariaLabel } : {}),
+            ...(ariaLabelledBy ? { 'aria-labelledby': ariaLabelledBy } : {}),
+        };
+    }, [ariaDescribedBy, ariaLabel, ariaLabelledBy, editable, schema]);
+    const handleCreate = useEvent(function handleCreate(props) {
+        const { view } = props.editor;
+        // Apply a selection to the document if one was given and `autoFocus` is `true`
+        if (autoFocus && contentSelection) {
+            view.dispatch(view.state.tr
+                .setSelection(resolveContentSelection(view.state.doc, contentSelection))
+                .scrollIntoView());
+        }
+        // Move the suggestion plugins to the top of the plugins list so they have a higher priority
+        // than all input rules (such as the ones used for Markdown shortcuts)
+        // ref: https://github.com/ueberdosis/tiptap/issues/2570
+        if (view.state.plugins.length > 0) {
+            const restOfPlugins = [];
+            const suggestionPlugins = [];
+            view.state.plugins.forEach((plugin) => {
+                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                // @ts-ignore: The `Plugin` type does not include `key`
+                if (plugin.key.includes('Suggestion')) {
+                    suggestionPlugins.push(plugin);
+                }
+                else {
+                    restOfPlugins.push(plugin);
+                }
+            });
+            view.updateState(view.state.reconfigure({
+                plugins: [...suggestionPlugins, ...restOfPlugins],
+            }));
+        }
+        // Invoke the user `onCreate` handle after all internal initializations
+        onCreate?.(props);
+    });
+    const editor = useEditor({
+        autofocus: autoFocus ? 'end' : false,
+        content: htmlContent,
+        editable,
+        editorProps: {
+            attributes: {
+                'data-typist-editor': 'true',
+                ...(isPlainTextDocument(schema)
+                    ? { 'data-plain-text': 'true' }
+                    : { 'data-rich-text': 'true' }),
+                role: 'textbox',
+                ...ariaAttributes,
+            },
+        },
+        extensions: allExtensions,
+        parseOptions: {
+            preserveWhitespace: isPlainTextDocument(schema),
+        },
+        ...(onBeforeCreate ? { onBeforeCreate } : {}),
+        onCreate: handleCreate,
+        ...(onUpdate
+            ? {
+                onUpdate(props) {
+                    onUpdate({
+                        ...props,
+                        getMarkdown() {
+                            return markdownSerializer.serialize(props.editor.getHTML());
+                        },
+                    });
+                },
+            }
+            : {}),
+        ...(onSelectionUpdate ? { onSelectionUpdate } : {}),
+        ...(onTransaction ? { onTransaction } : {}),
+        ...(onFocus ? { onFocus } : {}),
+        ...(onBlur ? { onBlur } : {}),
+        ...(onDestroy ? { onDestroy } : {}),
+    }, [
+        allExtensions,
+        ariaAttributes,
+        autoFocus,
+        editable,
+        handleCreate,
+        htmlContent,
+        markdownSerializer,
+        onBeforeCreate,
+        onBlur,
+        onDestroy,
+        onFocus,
+        onSelectionUpdate,
+        onTransaction,
+        onUpdate,
+        schema,
+    ]);
+    useImperativeHandle(ref, function exposeHelperFunctionsToParent() {
+        return {
+            getEditor() {
+                return editor;
+            },
+            getMarkdown() {
+                return markdownSerializer.serialize(editor.getHTML());
+            },
+            getAllNodesAttributesByType(nodeType) {
+                return getAllNodesAttributesByType(editor.state.doc, nodeType);
+            },
+        };
+    }, [editor, markdownSerializer]);
+    return _jsx(EditorContent, { className: className, editor: editor });
+});
+export { TypistEditor };

package/dist/constants/common.d.ts

@@ -0,0 +1,10 @@
+/**
+ * An enum-like constant for clipboard `DataTransfer.types` that are supported by the editor.
+ */
+declare const ClipboardDataType: {
+    readonly Text: "text/plain";
+    readonly HTML: "text/html";
+    readonly VSCode: "vscode-editor-data";
+};
+export { ClipboardDataType };
+//# sourceMappingURL=common.d.ts.map

package/dist/constants/common.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../src/constants/common.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,QAAA,MAAM,iBAAiB;;;;CAIb,CAAA;AAEV,OAAO,EAAE,iBAAiB,EAAE,CAAA"}

package/dist/constants/common.js

@@ -0,0 +1,9 @@
+/**
+ * An enum-like constant for clipboard `DataTransfer.types` that are supported by the editor.
+ */
+const ClipboardDataType = {
+    Text: 'text/plain',
+    HTML: 'text/html',
+    VSCode: 'vscode-editor-data',
+};
+export { ClipboardDataType };

package/dist/constants/extension-priorities.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Priority for the extensions created by the suggestion extension factory function. This needs to
+ * be higher than most extensions, so that event handlers from the dropdown render function can take
+ * precedence over all other event handlers in the chain.
+ */
+declare const SUGGESTION_EXTENSION_PRIORITY = 1000;
+/**
+ * Priority for the `SmartMarkdownTyping` extension. This needs to be higher than the
+ * `ViewEventHandlers` extension, so that event handlers from the ProseMirror plugins built into the
+ * extension can take precedence over the `ViewEventHandlers` extension event handlers.
+ */
+declare const SMART_MARKDOWN_TYPING_PRIORITY = 110;
+/**
+ * Priority for the `ViewEventHandlers` extension. This needs to be higher than the default for most
+ * of the built-in and official extensions (i.e. `100`), so that the event handlers from the
+ * extension can take precedence over the built-in and official extensions event handlers.
+ */
+declare const VIEW_EVENT_HANDLERS_PRIORITY = 105;
+/**
+ * Priority for the official `Blockquote` extension. This needs to be higher than the default for
+ * most built-in and official extensions (i.e. `100`), so that the keyboard shortcut can take
+ * precedence over the `Bold` extension keyboard shortcut.
+ */
+declare const BLOCKQUOTE_EXTENSION_PRIORITY = 101;
+export { BLOCKQUOTE_EXTENSION_PRIORITY, SMART_MARKDOWN_TYPING_PRIORITY, SUGGESTION_EXTENSION_PRIORITY, VIEW_EVENT_HANDLERS_PRIORITY, };
+//# sourceMappingURL=extension-priorities.d.ts.map

package/dist/constants/extension-priorities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extension-priorities.d.ts","sourceRoot":"","sources":["../../src/constants/extension-priorities.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,QAAA,MAAM,6BAA6B,OAAO,CAAA;AAE1C;;;;GAIG;AACH,QAAA,MAAM,8BAA8B,MAAM,CAAA;AAE1C;;;;GAIG;AACH,QAAA,MAAM,4BAA4B,MAAM,CAAA;AAExC;;;;GAIG;AACH,QAAA,MAAM,6BAA6B,MAAM,CAAA;AAEzC,OAAO,EACH,6BAA6B,EAC7B,8BAA8B,EAC9B,6BAA6B,EAC7B,4BAA4B,GAC/B,CAAA"}

package/dist/constants/extension-priorities.js

@@ -0,0 +1,25 @@
+/**
+ * Priority for the extensions created by the suggestion extension factory function. This needs to
+ * be higher than most extensions, so that event handlers from the dropdown render function can take
+ * precedence over all other event handlers in the chain.
+ */
+const SUGGESTION_EXTENSION_PRIORITY = 1000;
+/**
+ * Priority for the `SmartMarkdownTyping` extension. This needs to be higher than the
+ * `ViewEventHandlers` extension, so that event handlers from the ProseMirror plugins built into the
+ * extension can take precedence over the `ViewEventHandlers` extension event handlers.
+ */
+const SMART_MARKDOWN_TYPING_PRIORITY = 110;
+/**
+ * Priority for the `ViewEventHandlers` extension. This needs to be higher than the default for most
+ * of the built-in and official extensions (i.e. `100`), so that the event handlers from the
+ * extension can take precedence over the built-in and official extensions event handlers.
+ */
+const VIEW_EVENT_HANDLERS_PRIORITY = 105;
+/**
+ * Priority for the official `Blockquote` extension. This needs to be higher than the default for
+ * most built-in and official extensions (i.e. `100`), so that the keyboard shortcut can take
+ * precedence over the `Bold` extension keyboard shortcut.
+ */
+const BLOCKQUOTE_EXTENSION_PRIORITY = 101;
+export { BLOCKQUOTE_EXTENSION_PRIORITY, SMART_MARKDOWN_TYPING_PRIORITY, SUGGESTION_EXTENSION_PRIORITY, VIEW_EVENT_HANDLERS_PRIORITY, };

package/dist/constants/regular-expressions.d.ts

@@ -0,0 +1,6 @@
+/**
+ * A common regex for all line termination conventions.
+ */
+declare const REGEX_LINE_BREAKS: RegExp;
+export { REGEX_LINE_BREAKS };
+//# sourceMappingURL=regular-expressions.d.ts.map

package/dist/constants/regular-expressions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"regular-expressions.d.ts","sourceRoot":"","sources":["../../src/constants/regular-expressions.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,QAAA,MAAM,iBAAiB,QAAoB,CAAA;AAE3C,OAAO,EAAE,iBAAiB,EAAE,CAAA"}

package/dist/constants/regular-expressions.js

@@ -0,0 +1,5 @@
+/**
+ * A common regex for all line termination conventions.
+ */
+const REGEX_LINE_BREAKS = /(?:\r\n|\r|\n)/g;
+export { REGEX_LINE_BREAKS };

package/dist/extensions/core/extra-editor-commands/commands/extend-word-range.d.ts

@@ -0,0 +1,24 @@
+import { RawCommands } from '@tiptap/core';
+/**
+ * Augment the official `@tiptap/core` module with extra commands so that the compiler knows about
+ * them. For this to work externally, a wildcard export needs to be added to the root `index.ts`.
+ */
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        extendWordRange: {
+            /**
+             * Extends the text selection to the current word.
+             */
+            extendWordRange: () => ReturnType;
+        };
+    }
+}
+/**
+ * Extends the text selection to the current word.
+ *
+ * The solution for this function was inspired by the official `extendMarkRange` and
+ * `setTextSelection` commands.
+ */
+declare function extendWordRange(): ReturnType<RawCommands['extendWordRange']>;
+export { extendWordRange };
+//# sourceMappingURL=extend-word-range.d.ts.map

package/dist/extensions/core/extra-editor-commands/commands/extend-word-range.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extend-word-range.d.ts","sourceRoot":"","sources":["../../../../../src/extensions/core/extra-editor-commands/commands/extend-word-range.ts"],"names":[],"mappings":"AAAA,OAAO,EAA6B,WAAW,EAAE,MAAM,cAAc,CAAA;AAIrE;;;GAGG;AACH,OAAO,QAAQ,cAAc,CAAC;IAC1B,UAAU,QAAQ,CAAC,UAAU;QACzB,eAAe,EAAE;YACb;;eAEG;YACH,eAAe,EAAE,MAAM,UAAU,CAAA;SACpC,CAAA;KACJ;CACJ;AAED;;;;;GAKG;AACH,iBAAS,eAAe,IAAI,UAAU,CAAC,WAAW,CAAC,iBAAiB,CAAC,CAAC,CAkCrE;AAED,OAAO,EAAE,eAAe,EAAE,CAAA"}

package/dist/extensions/core/extra-editor-commands/commands/extend-word-range.js

@@ -0,0 +1,32 @@
+import { isActive, isTextSelection } from '@tiptap/core';
+import { clamp } from 'lodash-es';
+import { TextSelection } from 'prosemirror-state';
+/**
+ * Extends the text selection to the current word.
+ *
+ * The solution for this function was inspired by the official `extendMarkRange` and
+ * `setTextSelection` commands.
+ */
+function extendWordRange() {
+    return ({ state, tr, dispatch }) => {
+        const { doc, selection } = tr;
+        const { $head } = selection;
+        // Do nothing if cursor position is not valid for a text selection
+        if (!isTextSelection(selection) ||
+            isActive(state, 'code') ||
+            isActive(state, 'codeBlock')) {
+            return false;
+        }
+        // Check if the transaction should be dispatched
+        // ref: https://tiptap.dev/api/commands#dry-run-for-commands
+        if (dispatch) {
+            const textBefore = $head.nodeBefore?.text?.match(/[^\s]+$/)?.[0] || '';
+            const textAfter = $head.nodeAfter?.text?.match(/^[^\s]+/)?.[0] || '';
+            const minPos = TextSelection.atStart(doc).from;
+            const maxPos = TextSelection.atEnd(doc).to;
+            tr.setSelection(TextSelection.create(doc, clamp(selection.head - textBefore.length, minPos, maxPos), clamp(selection.head + textAfter.length, minPos, maxPos)));
+        }
+        return true;
+    };
+}
+export { extendWordRange };

package/dist/extensions/core/extra-editor-commands/commands/insert-markdown-content.d.ts

@@ -0,0 +1,28 @@
+import { RawCommands } from '@tiptap/core';
+import type { ParseOptions } from 'prosemirror-model';
+/**
+ * Augment the official `@tiptap/core` module with extra commands so that the compiler knows about
+ * them. For this to work externally, a wildcard export needs to be added to the root `index.ts`.
+ */
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        insertMarkdownContent: {
+            /**
+             * Inserts the provided Markdown as HTML into the editor.
+             *
+             * @param markdown The Markdown to parse and insert as HTML.
+             * @param parseOptions The parse options for ProseMirror's DOMParser.
+             */
+            insertMarkdownContent: (markdown: string, parseOptions?: ParseOptions) => ReturnType;
+        };
+    }
+}
+/**
+ * Inserts the provided Markdown as HTML into the editor.
+ *
+ * The solution for this function was inspired how ProseMirror pastes content from the clipboard,
+ * and how Tiptap inserts content with the `insertContentAt` command.
+ */
+declare function insertMarkdownContent(markdown: string, parseOptions?: ParseOptions): ReturnType<RawCommands['insertMarkdownContent']>;
+export { insertMarkdownContent };
+//# sourceMappingURL=insert-markdown-content.d.ts.map

package/dist/extensions/core/extra-editor-commands/commands/insert-markdown-content.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"insert-markdown-content.d.ts","sourceRoot":"","sources":["../../../../../src/extensions/core/extra-editor-commands/commands/insert-markdown-content.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AAO1C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAErD;;;GAGG;AACH,OAAO,QAAQ,cAAc,CAAC;IAC1B,UAAU,QAAQ,CAAC,UAAU;QACzB,qBAAqB,EAAE;YACnB;;;;;eAKG;YACH,qBAAqB,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,YAAY,KAAK,UAAU,CAAA;SACvF,CAAA;KACJ;CACJ;AAED;;;;;GAKG;AACH,iBAAS,qBAAqB,CAC1B,QAAQ,EAAE,MAAM,EAChB,YAAY,CAAC,EAAE,YAAY,GAC5B,UAAU,CAAC,WAAW,CAAC,uBAAuB,CAAC,CAAC,CAoBlD;AAED,OAAO,EAAE,qBAAqB,EAAE,CAAA"}

package/dist/extensions/core/extra-editor-commands/commands/insert-markdown-content.js

@@ -0,0 +1,25 @@
+import { DOMParser } from 'prosemirror-model';
+import { parseHtmlToElement } from '../../../../helpers/dom';
+import { isPlainTextDocument } from '../../../../helpers/schema';
+import { createHTMLSerializer } from '../../../../serializers/html/html';
+/**
+ * Inserts the provided Markdown as HTML into the editor.
+ *
+ * The solution for this function was inspired how ProseMirror pastes content from the clipboard,
+ * and how Tiptap inserts content with the `insertContentAt` command.
+ */
+function insertMarkdownContent(markdown, parseOptions) {
+    return ({ dispatch, editor, tr }) => {
+        // Check if the transaction should be dispatched
+        // ref: https://tiptap.dev/api/commands#dry-run-for-commands
+        if (dispatch) {
+            const htmlContent = !isPlainTextDocument(editor.schema)
+                ? createHTMLSerializer(editor.schema).serialize(markdown)
+                : markdown;
+            // Inserts the HTML content into the editor while preserving the current selection
+            tr.replaceSelection(DOMParser.fromSchema(editor.schema).parseSlice(parseHtmlToElement(htmlContent), parseOptions));
+        }
+        return true;
+    };
+}
+export { insertMarkdownContent };

package/dist/extensions/core/extra-editor-commands/extra-editor-commands.d.ts

@@ -0,0 +1,9 @@
+import { Extension } from '@tiptap/core';
+/**
+ * The `ExtraEditorCommands` extension is a collection of editor commands that provide additional
+ * helper commands not available with the built-in commands. This extension was built similarly to
+ * the official `Commands` extension.
+ */
+declare const ExtraEditorCommands: Extension<any, any>;
+export { ExtraEditorCommands };
+//# sourceMappingURL=extra-editor-commands.d.ts.map

package/dist/extensions/core/extra-editor-commands/extra-editor-commands.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extra-editor-commands.d.ts","sourceRoot":"","sources":["../../../../src/extensions/core/extra-editor-commands/extra-editor-commands.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AAKxC;;;;GAIG;AACH,QAAA,MAAM,mBAAmB,qBAQvB,CAAA;AAEF,OAAO,EAAE,mBAAmB,EAAE,CAAA"}

package/dist/extensions/core/extra-editor-commands/extra-editor-commands.js

@@ -0,0 +1,18 @@
+import { Extension } from '@tiptap/core';
+import { extendWordRange } from './commands/extend-word-range';
+import { insertMarkdownContent } from './commands/insert-markdown-content';
+/**
+ * The `ExtraEditorCommands` extension is a collection of editor commands that provide additional
+ * helper commands not available with the built-in commands. This extension was built similarly to
+ * the official `Commands` extension.
+ */
+const ExtraEditorCommands = Extension.create({
+    name: 'extraEditorCommands',
+    addCommands() {
+        return {
+            extendWordRange,
+            insertMarkdownContent,
+        };
+    },
+});
+export { ExtraEditorCommands };

package/dist/extensions/core/view-event-handlers.d.ts

@@ -0,0 +1,33 @@
+import { Extension } from '@tiptap/core';
+import type { EditorView } from 'prosemirror-view';
+/**
+ * The options available to customize the `ViewEventHandlers` extension.
+ *
+ * If more view handlers are needed, please look into the available event handlers in
+ * [`prosemirror-view`](https://prosemirror.net/docs/ref/#view.Props), and add them below.
+ */
+declare type ViewEventHandlersOptions = {
+    /**
+     * Called when the editor is clicked, after `handleClickOn` handlers have been called.
+     */
+    onClick?: (event: MouseEvent, view: EditorView, pos: number) => boolean | void;
+    /**
+     * Called when the editor receives a `keydown` event.
+     */
+    onKeyDown?: (event: KeyboardEvent, view: EditorView) => boolean | void;
+};
+/**
+ * The `ViewEventHandlers` extension allows handling of various ProseMirror view events.
+ *
+ * The various event-handling functions may all return `true` to indicate that they handled the
+ * given event. The view will then take care to call `preventDefault` on the event, except with
+ * `handleDOMEvents`, where the handler itself is responsible for that. Return `false` or
+ * `undefined` for the default event handler to be called.
+ *
+ * These event handlers should be used sparingly, please consider if a reusable extension would be
+ * more appropriate for your use case.
+ */
+declare const ViewEventHandlers: Extension<ViewEventHandlersOptions, any>;
+export { ViewEventHandlers };
+export type { ViewEventHandlersOptions };
+//# sourceMappingURL=view-event-handlers.d.ts.map

package/dist/extensions/core/view-event-handlers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"view-event-handlers.d.ts","sourceRoot":"","sources":["../../../src/extensions/core/view-event-handlers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AAKxC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAElD;;;;;GAKG;AACH,aAAK,wBAAwB,GAAG;IAC5B;;OAEG;IACH,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,UAAU,EAAE,GAAG,EAAE,MAAM,KAAK,OAAO,GAAG,IAAI,CAAA;IAE9E;;OAEG;IACH,SAAS,CAAC,EAAE,CAAC,KAAK,EAAE,aAAa,EAAE,IAAI,EAAE,UAAU,KAAK,OAAO,GAAG,IAAI,CAAA;CACzE,CAAA;AAED;;;;;;;;;;GAUG;AACH,QAAA,MAAM,iBAAiB,0CAoBrB,CAAA;AAEF,OAAO,EAAE,iBAAiB,EAAE,CAAA;AAE5B,YAAY,EAAE,wBAAwB,EAAE,CAAA"}

package/dist/extensions/core/view-event-handlers.js

@@ -0,0 +1,35 @@
+import { Extension } from '@tiptap/core';
+import { Plugin, PluginKey } from 'prosemirror-state';
+import { VIEW_EVENT_HANDLERS_PRIORITY } from '../../constants/extension-priorities';
+/**
+ * The `ViewEventHandlers` extension allows handling of various ProseMirror view events.
+ *
+ * The various event-handling functions may all return `true` to indicate that they handled the
+ * given event. The view will then take care to call `preventDefault` on the event, except with
+ * `handleDOMEvents`, where the handler itself is responsible for that. Return `false` or
+ * `undefined` for the default event handler to be called.
+ *
+ * These event handlers should be used sparingly, please consider if a reusable extension would be
+ * more appropriate for your use case.
+ */
+const ViewEventHandlers = Extension.create({
+    name: 'viewEventHandlers',
+    priority: VIEW_EVENT_HANDLERS_PRIORITY,
+    addProseMirrorPlugins() {
+        const { options } = this;
+        return [
+            new Plugin({
+                key: new PluginKey('viewEventHandlers'),
+                props: {
+                    handleClick(view, pos, event) {
+                        return options.onClick?.(event, view, pos) || false;
+                    },
+                    handleKeyDown(view, event) {
+                        return options.onKeyDown?.(event, view) || false;
+                    },
+                },
+            }),
+        ];
+    },
+});
+export { ViewEventHandlers };

package/dist/extensions/plain-text/paste-multiline-text.d.ts

@@ -0,0 +1,10 @@
+import { Extension } from '@tiptap/core';
+/**
+ * The `MultilineDocumentPaste` extension preserves paragraphs (including empty ones) when
+ * copying-and-pasting text into the editor, or when inputting multiline text with some sort of
+ * automatic text insertion shortcut. This custom extension is required for a plain-text editor
+ * configured with `multiline: true`, so that multiline clipboard text is pasted correctly.
+ */
+declare const PasteMultilineText: Extension<any, any>;
+export { PasteMultilineText };
+//# sourceMappingURL=paste-multiline-text.d.ts.map

package/dist/extensions/plain-text/paste-multiline-text.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paste-multiline-text.d.ts","sourceRoot":"","sources":["../../../src/extensions/plain-text/paste-multiline-text.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AA+CxC;;;;;GAKG;AACH,QAAA,MAAM,kBAAkB,qBA0BtB,CAAA;AAEF,OAAO,EAAE,kBAAkB,EAAE,CAAA"}

package/dist/extensions/plain-text/paste-multiline-text.js

@@ -0,0 +1,66 @@
+/* eslint-disable no-console */
+import { Extension } from '@tiptap/core';
+import { Fragment, Slice } from 'prosemirror-model';
+import { Plugin, PluginKey } from 'prosemirror-state';
+import { ClipboardDataType } from '../../constants/common';
+import { REGEX_LINE_BREAKS } from '../../constants/regular-expressions';
+/**
+ * Handles a text input or paste event, and replaces all found line breaks with paragraph nodes.
+ *
+ * @param view The current editor view to process.
+ * @param text The multiline text input to parse.
+ */
+function handleTextInputOrPaste(view, text) {
+    const { schema } = view.state;
+    const { tr } = view.state;
+    const textLines = text.split(REGEX_LINE_BREAKS);
+    // Do not handle the event without a multiline input
+    // (i.e. when the user is only typing)
+    if (textLines.length === 1) {
+        return false;
+    }
+    // Build an array of paragraphs nodes (including empty ones)
+    const paragraphNodes = textLines.map((textLine) => {
+        if (textLine.length === 0) {
+            return schema.nodes.paragraph.create();
+        }
+        return schema.nodes.paragraph.create(null, schema.text(textLine));
+    });
+    // Inserts the new paragraph nodes at the current cursor position
+    // (takes into account if a selection needs to be replaced)
+    view.dispatch(tr.replaceSelection(Slice.maxOpen(Fragment.fromArray(paragraphNodes))).scrollIntoView());
+    // Suppress the default handling behaviour
+    return true;
+}
+/**
+ * The `MultilineDocumentPaste` extension preserves paragraphs (including empty ones) when
+ * copying-and-pasting text into the editor, or when inputting multiline text with some sort of
+ * automatic text insertion shortcut. This custom extension is required for a plain-text editor
+ * configured with `multiline: true`, so that multiline clipboard text is pasted correctly.
+ */
+const PasteMultilineText = Extension.create({
+    name: 'pasteMultilineText',
+    addProseMirrorPlugins() {
+        return [
+            new Plugin({
+                key: new PluginKey('pasteMultilineText'),
+                props: {
+                    handleTextInput(view, _, __, inputText) {
+                        return handleTextInputOrPaste(view, inputText);
+                    },
+                    handlePaste(view, event) {
+                        const clipboardText = event.clipboardData
+                            ?.getData(ClipboardDataType.Text)
+                            .trim();
+                        // Do not handle the event if the clipboard doesn't contain text
+                        if (!clipboardText) {
+                            return false;
+                        }
+                        return handleTextInputOrPaste(view, clipboardText);
+                    },
+                },
+            }),
+        ];
+    },
+});
+export { PasteMultilineText };

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

@@ -0,0 +1,17 @@
+/**
+ * The options available to customize the `PlainTextDocument` extension.
+ */
+declare type PlainTextDocumentOptions = {
+    /**
+     * 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 plain-text documents (as opposed to the multiple block nodes by default).
+ */
+declare const PlainTextDocument: import("@tiptap/core").Node<PlainTextDocumentOptions, any>;
+export { PlainTextDocument };
+export type { PlainTextDocumentOptions };
+//# sourceMappingURL=plain-text-document.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"plain-text-document.d.ts","sourceRoot":"","sources":["../../../src/extensions/plain-text/plain-text-document.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,aAAK,wBAAwB,GAAG;IAC5B;;OAEG;IACH,SAAS,EAAE,OAAO,CAAA;CACrB,CAAA;AAED;;;GAGG;AACH,QAAA,MAAM,iBAAiB,4DAUrB,CAAA;AAEF,OAAO,EAAE,iBAAiB,EAAE,CAAA;AAE5B,YAAY,EAAE,wBAAwB,EAAE,CAAA"}

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

@@ -0,0 +1,17 @@
+import { Document } from '@tiptap/extension-document';
+/**
+ * Custom extension that extends the built-in `Document` extension to define a schema for multiline
+ * or singleline plain-text documents (as opposed to the multiple block nodes by default).
+ */
+const PlainTextDocument = Document.extend({
+    addOptions() {
+        return {
+            multiline: true,
+        };
+    },
+    content() {
+        // ref: https://tiptap.dev/api/schema#content
+        return `paragraph${this.options.multiline ? '+' : ''}`;
+    },
+});
+export { PlainTextDocument };