@datalayer/lexical-loro 0.2.5 → 1.0.0

package/lib/plugins/MarkdownTransformers/index.js

@@ -1,238 +0,0 @@
-/*
- * Copyright (c) 2023-2025 Datalayer, Inc.
- * Distributed under the terms of the MIT License.
- */
-import { $convertFromMarkdownString, $convertToMarkdownString, CHECK_LIST, ELEMENT_TRANSFORMERS, MULTILINE_ELEMENT_TRANSFORMERS, TEXT_FORMAT_TRANSFORMERS, TEXT_MATCH_TRANSFORMERS, } from '@lexical/markdown';
-import { $createHorizontalRuleNode, $isHorizontalRuleNode, HorizontalRuleNode, } from '@lexical/react/LexicalHorizontalRuleNode';
-import { $createTableCellNode, $createTableNode, $createTableRowNode, $isTableCellNode, $isTableNode, $isTableRowNode, TableCellHeaderStates, TableCellNode, TableNode, TableRowNode, } from '@lexical/table';
-import { $createTextNode, $isParagraphNode, $isTextNode, } from 'lexical';
-import { $createEquationNode, $isEquationNode, EquationNode, } from '../../nodes/EquationNode';
-import { $createImageNode, $isImageNode, ImageNode } from '../../nodes/ImageNode';
-import { $createTweetNode, $isTweetNode, TweetNode } from '../../nodes/TweetNode';
-import emojiList from '../../utils/emoji-list';
-export const HR = {
-    dependencies: [HorizontalRuleNode],
-    export: (node) => {
-        return $isHorizontalRuleNode(node) ? '***' : null;
-    },
-    regExp: /^(---|\*\*\*|___)\s?$/,
-    replace: (parentNode, _1, _2, isImport) => {
-        const line = $createHorizontalRuleNode();
-        // TODO: Get rid of isImport flag
-        if (isImport || parentNode.getNextSibling() != null) {
-            parentNode.replace(line);
-        }
-        else {
-            parentNode.insertBefore(line);
-        }
-        line.selectNext();
-    },
-    type: 'element',
-};
-export const IMAGE = {
-    dependencies: [ImageNode],
-    export: (node) => {
-        if (!$isImageNode(node)) {
-            return null;
-        }
-        return `![${node.getAltText()}](${node.getSrc()})`;
-    },
-    importRegExp: /!(?:\[([^[]*)\])(?:\(([^(]+)\))/,
-    regExp: /!(?:\[([^[]*)\])(?:\(([^(]+)\))$/,
-    replace: (textNode, match) => {
-        const [, altText, src] = match;
-        const imageNode = $createImageNode({
-            altText,
-            maxWidth: 800,
-            src,
-        });
-        textNode.replace(imageNode);
-    },
-    trigger: ')',
-    type: 'text-match',
-};
-export const EMOJI = {
-    dependencies: [],
-    export: () => null,
-    importRegExp: /:([a-z0-9_]+):/,
-    regExp: /:([a-z0-9_]+):$/,
-    replace: (textNode, [, name]) => {
-        const emoji = emojiList.find((e) => e.aliases.includes(name))?.emoji;
-        if (emoji) {
-            textNode.replace($createTextNode(emoji));
-        }
-    },
-    trigger: ':',
-    type: 'text-match',
-};
-export const EQUATION = {
-    dependencies: [EquationNode],
-    export: (node) => {
-        if (!$isEquationNode(node)) {
-            return null;
-        }
-        return `$${node.getEquation()}$`;
-    },
-    importRegExp: /\$([^$]+?)\$/,
-    regExp: /\$([^$]+?)\$$/,
-    replace: (textNode, match) => {
-        const [, equation] = match;
-        const equationNode = $createEquationNode(equation, true);
-        textNode.replace(equationNode);
-    },
-    trigger: '$',
-    type: 'text-match',
-};
-export const TWEET = {
-    dependencies: [TweetNode],
-    export: (node) => {
-        if (!$isTweetNode(node)) {
-            return null;
-        }
-        return `<tweet id="${node.getId()}" />`;
-    },
-    regExp: /<tweet id="([^"]+?)"\s?\/>\s?$/,
-    replace: (textNode, _1, match) => {
-        const [, id] = match;
-        const tweetNode = $createTweetNode(id);
-        textNode.replace(tweetNode);
-    },
-    type: 'element',
-};
-// Very primitive table setup
-const TABLE_ROW_REG_EXP = /^(?:\|)(.+)(?:\|)\s?$/;
-const TABLE_ROW_DIVIDER_REG_EXP = /^(\| ?:?-*:? ?)+\|\s?$/;
-export const TABLE = {
-    dependencies: [TableNode, TableRowNode, TableCellNode],
-    export: (node) => {
-        if (!$isTableNode(node)) {
-            return null;
-        }
-        const output = [];
-        for (const row of node.getChildren()) {
-            const rowOutput = [];
-            if (!$isTableRowNode(row)) {
-                continue;
-            }
-            let isHeaderRow = false;
-            for (const cell of row.getChildren()) {
-                // It's TableCellNode so it's just to make flow happy
-                if ($isTableCellNode(cell)) {
-                    rowOutput.push($convertToMarkdownString(PLAYGROUND_TRANSFORMERS, cell)
-                        .replace(/\n/g, '\\n')
-                        .trim());
-                    if (cell.__headerState === TableCellHeaderStates.ROW) {
-                        isHeaderRow = true;
-                    }
-                }
-            }
-            output.push(`| ${rowOutput.join(' | ')} |`);
-            if (isHeaderRow) {
-                output.push(`| ${rowOutput.map((_) => '---').join(' | ')} |`);
-            }
-        }
-        return output.join('\n');
-    },
-    regExp: TABLE_ROW_REG_EXP,
-    replace: (parentNode, _1, match) => {
-        // Header row
-        if (TABLE_ROW_DIVIDER_REG_EXP.test(match[0])) {
-            const table = parentNode.getPreviousSibling();
-            if (!table || !$isTableNode(table)) {
-                return;
-            }
-            const rows = table.getChildren();
-            const lastRow = rows[rows.length - 1];
-            if (!lastRow || !$isTableRowNode(lastRow)) {
-                return;
-            }
-            // Add header state to row cells
-            lastRow.getChildren().forEach((cell) => {
-                if (!$isTableCellNode(cell)) {
-                    return;
-                }
-                cell.setHeaderStyles(TableCellHeaderStates.ROW, TableCellHeaderStates.ROW);
-            });
-            // Remove line
-            parentNode.remove();
-            return;
-        }
-        const matchCells = mapToTableCells(match[0]);
-        if (matchCells == null) {
-            return;
-        }
-        const rows = [matchCells];
-        let sibling = parentNode.getPreviousSibling();
-        let maxCells = matchCells.length;
-        while (sibling) {
-            if (!$isParagraphNode(sibling)) {
-                break;
-            }
-            if (sibling.getChildrenSize() !== 1) {
-                break;
-            }
-            const firstChild = sibling.getFirstChild();
-            if (!$isTextNode(firstChild)) {
-                break;
-            }
-            const cells = mapToTableCells(firstChild.getTextContent());
-            if (cells == null) {
-                break;
-            }
-            maxCells = Math.max(maxCells, cells.length);
-            rows.unshift(cells);
-            const previousSibling = sibling.getPreviousSibling();
-            sibling.remove();
-            sibling = previousSibling;
-        }
-        const table = $createTableNode();
-        for (const cells of rows) {
-            const tableRow = $createTableRowNode();
-            table.append(tableRow);
-            for (let i = 0; i < maxCells; i++) {
-                tableRow.append(i < cells.length ? cells[i] : $createTableCell(''));
-            }
-        }
-        const previousSibling = parentNode.getPreviousSibling();
-        if ($isTableNode(previousSibling) &&
-            getTableColumnsSize(previousSibling) === maxCells) {
-            previousSibling.append(...table.getChildren());
-            parentNode.remove();
-        }
-        else {
-            parentNode.replace(table);
-        }
-        table.selectEnd();
-    },
-    type: 'element',
-};
-function getTableColumnsSize(table) {
-    const row = table.getFirstChild();
-    return $isTableRowNode(row) ? row.getChildrenSize() : 0;
-}
-const $createTableCell = (textContent) => {
-    textContent = textContent.replace(/\\n/g, '\n');
-    const cell = $createTableCellNode(TableCellHeaderStates.NO_STATUS);
-    $convertFromMarkdownString(textContent, PLAYGROUND_TRANSFORMERS, cell);
-    return cell;
-};
-const mapToTableCells = (textContent) => {
-    const match = textContent.match(TABLE_ROW_REG_EXP);
-    if (!match || !match[1]) {
-        return null;
-    }
-    return match[1].split('|').map((text) => $createTableCell(text));
-};
-export const PLAYGROUND_TRANSFORMERS = [
-    TABLE,
-    HR,
-    IMAGE,
-    EMOJI,
-    EQUATION,
-    TWEET,
-    CHECK_LIST,
-    ...ELEMENT_TRANSFORMERS,
-    ...MULTILINE_ELEMENT_TRANSFORMERS,
-    ...TEXT_FORMAT_TRANSFORMERS,
-    ...TEXT_MATCH_TRANSFORMERS,
-];

package/lib/plugins/MaxLengthPlugin/index.d.ts

@@ -1,3 +0,0 @@
-export declare function MaxLengthPlugin({ maxLength }: {
-    maxLength: number;
-}): null;

package/lib/plugins/MaxLengthPlugin/index.js

@@ -1,41 +0,0 @@
-/*
- * Copyright (c) 2023-2025 Datalayer, Inc.
- * Distributed under the terms of the MIT License.
- */
-import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext';
-import { $trimTextContentFromAnchor } from '@lexical/selection';
-import { $restoreEditorState } from '@lexical/utils';
-import { $getSelection, $isRangeSelection, RootNode } from 'lexical';
-import { useEffect } from 'react';
-export function MaxLengthPlugin({ maxLength }) {
-    const [editor] = useLexicalComposerContext();
-    useEffect(() => {
-        let lastRestoredEditorState = null;
-        return editor.registerNodeTransform(RootNode, (rootNode) => {
-            const selection = $getSelection();
-            if (!$isRangeSelection(selection) || !selection.isCollapsed()) {
-                return;
-            }
-            const prevEditorState = editor.getEditorState();
-            const prevTextContentSize = prevEditorState.read(() => rootNode.getTextContentSize());
-            const textContentSize = rootNode.getTextContentSize();
-            if (prevTextContentSize !== textContentSize) {
-                const delCount = textContentSize - maxLength;
-                const anchor = selection.anchor;
-                if (delCount > 0) {
-                    // Restore the old editor state instead if the last
-                    // text content was already at the limit.
-                    if (prevTextContentSize === maxLength &&
-                        lastRestoredEditorState !== prevEditorState) {
-                        lastRestoredEditorState = prevEditorState;
-                        $restoreEditorState(editor, prevEditorState);
-                    }
-                    else {
-                        $trimTextContentFromAnchor(editor, anchor, delCount);
-                    }
-                }
-            }
-        });
-    }, [editor, maxLength]);
-    return null;
-}

package/lib/plugins/MentionsPlugin/index.d.ts

@@ -1,2 +0,0 @@
-import type { JSX } from 'react';
-export default function NewMentionsPlugin(): JSX.Element | null;