@quadrats/common 0.6.7 → 0.7.0

package/list/index.cjs.js

@@ -1,199 +1,197 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
 var core = require('@quadrats/core');
 
-const LIST_TYPES = {
-    ol: 'ol',
-    ul: 'ul',
-    li: 'li',
+const LIST_TYPES = {
+    ol: 'ol',
+    ul: 'ul',
+    li: 'li',
 };
 
-function createList(options = {}) {
-    const types = Object.assign(Object.assign({}, LIST_TYPES), options.types);
-    const isListElement = (node) => [types.ol, types.ul].includes(node.type);
-    const isListItemElement = (node) => node.type === types.li;
-    const isSelectionInList = (editor, listTypeKey) => core.isNodesTypeIn(editor, [types[listTypeKey]]);
-    const getAboveListAndItem = (editor, options = {}) => {
-        const { at = editor.selection } = options;
-        /**
-         * (ul|ol) > li > p
-         */
-        if (at && core.isNodesTypeIn(editor, [types.li])) {
-            const parentEntry = core.getAboveByTypes(editor, [types.li]) || core.getParent(editor, at);
-            if (parentEntry && isListItemElement(parentEntry[0])) {
-                const [, listItemPath] = parentEntry;
-                const parentOfListItemEntry = core.getParent(editor, listItemPath);
-                if (parentOfListItemEntry && isListElement(parentOfListItemEntry[0])) {
-                    return {
-                        list: parentOfListItemEntry,
-                        listItem: parentEntry,
-                    };
-                }
-            }
-        }
-    };
-    const unwrapList = (editor) => {
-        core.unwrapNodesByTypes(editor, [types.li]);
-        core.unwrapNodesByTypes(editor, [types.ol, types.ul], { split: true });
-    };
-    const toggleList = (editor, listTypeKey, defaultType = core.PARAGRAPH_TYPE) => {
-        if (!editor.selection) {
-            return;
-        }
-        const isActive = isSelectionInList(editor, listTypeKey);
-        unwrapList(editor);
-        core.Transforms.setNodes(editor, {
-            type: defaultType,
-        });
-        if (!isActive) {
-            core.wrapNodesWithUnhangRange(editor, { type: types[listTypeKey], children: [] });
-            const nodeEntries = core.getNodesByTypes(editor, [defaultType]);
-            const listItem = { type: types.li, children: [] };
-            for (const [, path] of nodeEntries) {
-                core.wrapNodesWithUnhangRange(editor, listItem, {
-                    at: path,
-                });
-            }
-        }
-    };
-    const increaseListItemDepth = (editor, entries) => {
-        var _a, _b, _c, _d, _e;
-        const { list: [listNode], listItem: [, listItemPath], } = entries;
-        if (!core.isFirstChild(listItemPath)) {
-            const previousEntry = core.Editor.node(editor, core.Path.previous(listItemPath));
-            if (previousEntry) {
-                const [previousNode, previousPath] = previousEntry;
-                const lastNodeOfPreviousNode = ((_a = previousNode === null || previousNode === void 0 ? void 0 : previousNode.children) !== null && _a !== void 0 ? _a : [])[((_b = previousNode === null || previousNode === void 0 ? void 0 : previousNode.children) !== null && _b !== void 0 ? _b : []).length - 1];
-                /**
-                 * Move list item next to the last node of previous node of list item.
-                 */
-                if (isListElement(lastNodeOfPreviousNode)) {
-                    core.Transforms.moveNodes(editor, {
-                        at: listItemPath,
-                        to: [
-                            ...previousPath,
-                            ((_c = previousNode === null || previousNode === void 0 ? void 0 : previousNode.children) !== null && _c !== void 0 ? _c : []).length - 1,
-                            ((_d = lastNodeOfPreviousNode === null || lastNodeOfPreviousNode === void 0 ? void 0 : lastNodeOfPreviousNode.children) !== null && _d !== void 0 ? _d : []).length,
-                        ],
-                    });
-                    /**
-                     * Wrap list item by a new list and move the new list next to the last node of previous node.
-                     */
-                }
-                else {
-                    const newSubListElement = { type: listNode.type, children: [] };
-                    core.Transforms.wrapNodes(editor, newSubListElement, { at: listItemPath });
-                    core.Transforms.moveNodes(editor, {
-                        at: listItemPath,
-                        to: [...previousPath, ((_e = previousNode === null || previousNode === void 0 ? void 0 : previousNode.children) !== null && _e !== void 0 ? _e : []).length],
-                    });
-                }
-            }
-        }
-    };
-    const decreaseListItemDepth = (editor, entries) => {
-        var _a, _b, _c;
-        const { list: [listNode, listPath], listItem: [listItemNode, listItemPath], } = entries;
-        const [listParentNode, listParentPath] = core.Editor.parent(editor, listPath);
-        /**
-         * Decreasable if parent of list is list item.
-         */
-        if (!isListItemElement(listParentNode)) {
-            return;
-        }
-        const newListItemPath = core.Path.next(listParentPath);
-        const listItemIndex = listItemPath[listItemPath.length - 1];
-        const nextSiblingListItems = ((_a = listNode === null || listNode === void 0 ? void 0 : listNode.children) !== null && _a !== void 0 ? _a : []).slice(listItemIndex + 1, ((_b = listNode === null || listNode === void 0 ? void 0 : listNode.children) !== null && _b !== void 0 ? _b : []).length);
-        core.Transforms.moveNodes(editor, {
-            at: listItemPath,
-            to: newListItemPath,
-        });
-        /**
-         * After list item moved to parent list, if there are some sibling list items next to list item, move them to a new list in list item.
-         */
-        if (nextSiblingListItems.length) {
-            const newSubListElement = { type: listNode.type, children: [] };
-            const newSubListPath = [...newListItemPath, ((_c = listItemNode === null || listItemNode === void 0 ? void 0 : listItemNode.children) !== null && _c !== void 0 ? _c : []).length];
-            core.Transforms.insertNodes(editor, newSubListElement, { at: newSubListPath });
-            nextSiblingListItems.forEach((_, index) => {
-                core.Transforms.moveNodes(editor, {
-                    /**
-                     * Path of each nextSiblingListItems is the same as listItemPath.
-                     * Since each time list item moved, path of next list item will be unshifted.
-                     */
-                    at: listItemPath,
-                    to: [...newSubListPath, index],
-                });
-            });
-        }
-        /**
-         * Remove the stale sublist if there are no previous sibling list items.
-         */
-        if (listItemIndex <= 0) {
-            core.Transforms.removeNodes(editor, {
-                at: listPath,
-            });
-        }
-    };
-    const decreaseListItemDepthOrUnwrapIfNeed = (editor, entries) => {
-        const { list: [, listPath], } = entries;
-        const [listParentNode] = core.Editor.parent(editor, listPath);
-        if (listParentNode.type !== types.li) {
-            unwrapList(editor);
-        }
-        else {
-            decreaseListItemDepth(editor, entries);
-        }
-    };
-    return {
-        types,
-        isListElement,
-        isListItemElement,
-        isSelectionInList,
-        getAboveListAndItem,
-        unwrapList,
-        toggleList,
-        increaseListItemDepth,
-        decreaseListItemDepth,
-        decreaseListItemDepthOrUnwrapIfNeed,
-        with(editor) {
-            const { deleteBackward, insertBreak } = editor;
-            editor.deleteBackward = (unit) => {
-                const { selection } = editor;
-                if (selection && core.Range.isCollapsed(selection)) {
-                    const entries = getAboveListAndItem(editor);
-                    if (entries && core.isSelectionAtBlockEdge(editor) === 'start') {
-                        decreaseListItemDepthOrUnwrapIfNeed(editor, entries);
-                        return;
-                    }
-                }
-                deleteBackward(unit);
-            };
-            editor.insertBreak = () => {
-                var _a;
-                const entries = getAboveListAndItem(editor);
-                if (entries) {
-                    core.deleteSelectionFragmentIfExpanded(editor);
-                    if (core.isAboveBlockEmpty(editor, { match: isListItemElement })) {
-                        decreaseListItemDepthOrUnwrapIfNeed(editor, entries);
-                    }
-                    else {
-                        core.Transforms.splitNodes(editor, {
-                            at: (_a = editor.selection) === null || _a === void 0 ? void 0 : _a.focus,
-                            match: isListItemElement,
-                            always: true,
-                        });
-                    }
-                }
-                else {
-                    insertBreak();
-                }
-            };
-            return editor;
-        },
-    };
+function createList(options = {}) {
+    const types = Object.assign(Object.assign({}, LIST_TYPES), options.types);
+    const isListElement = (node) => [types.ol, types.ul].includes(node.type);
+    const isListItemElement = (node) => node.type === types.li;
+    const isSelectionInList = (editor, listTypeKey) => core.isNodesTypeIn(editor, [types[listTypeKey]]);
+    const getAboveListAndItem = (editor, options = {}) => {
+        const { at = editor.selection } = options;
+        /**
+         * (ul|ol) > li > p
+         */
+        if (at && core.isNodesTypeIn(editor, [types.li])) {
+            const parentEntry = core.getAboveByTypes(editor, [types.li]) || core.getParent(editor, at);
+            if (parentEntry && isListItemElement(parentEntry[0])) {
+                const [, listItemPath] = parentEntry;
+                const parentOfListItemEntry = core.getParent(editor, listItemPath);
+                if (parentOfListItemEntry && isListElement(parentOfListItemEntry[0])) {
+                    return {
+                        list: parentOfListItemEntry,
+                        listItem: parentEntry,
+                    };
+                }
+            }
+        }
+    };
+    const unwrapList = (editor) => {
+        core.unwrapNodesByTypes(editor, [types.li]);
+        core.unwrapNodesByTypes(editor, [types.ol, types.ul], { split: true });
+    };
+    const toggleList = (editor, listTypeKey, defaultType = core.PARAGRAPH_TYPE) => {
+        if (!editor.selection) {
+            return;
+        }
+        const isActive = isSelectionInList(editor, listTypeKey);
+        unwrapList(editor);
+        core.Transforms.setNodes(editor, {
+            type: defaultType,
+        });
+        if (!isActive) {
+            core.wrapNodesWithUnhangRange(editor, { type: types[listTypeKey], children: [] });
+            const nodeEntries = core.getNodesByTypes(editor, [defaultType]);
+            const listItem = { type: types.li, children: [] };
+            for (const [, path] of nodeEntries) {
+                core.wrapNodesWithUnhangRange(editor, listItem, {
+                    at: path,
+                });
+            }
+        }
+    };
+    const increaseListItemDepth = (editor, entries) => {
+        var _a, _b, _c, _d, _e;
+        const { list: [listNode], listItem: [, listItemPath], } = entries;
+        if (!core.isFirstChild(listItemPath)) {
+            const previousEntry = core.Editor.node(editor, core.Path.previous(listItemPath));
+            if (previousEntry) {
+                const [previousNode, previousPath] = previousEntry;
+                const lastNodeOfPreviousNode = ((_a = previousNode === null || previousNode === void 0 ? void 0 : previousNode.children) !== null && _a !== void 0 ? _a : [])[((_b = previousNode === null || previousNode === void 0 ? void 0 : previousNode.children) !== null && _b !== void 0 ? _b : []).length - 1];
+                /**
+                 * Move list item next to the last node of previous node of list item.
+                 */
+                if (isListElement(lastNodeOfPreviousNode)) {
+                    core.Transforms.moveNodes(editor, {
+                        at: listItemPath,
+                        to: [
+                            ...previousPath,
+                            ((_c = previousNode === null || previousNode === void 0 ? void 0 : previousNode.children) !== null && _c !== void 0 ? _c : []).length - 1,
+                            ((_d = lastNodeOfPreviousNode === null || lastNodeOfPreviousNode === void 0 ? void 0 : lastNodeOfPreviousNode.children) !== null && _d !== void 0 ? _d : []).length,
+                        ],
+                    });
+                    /**
+                     * Wrap list item by a new list and move the new list next to the last node of previous node.
+                     */
+                }
+                else {
+                    const newSubListElement = { type: listNode.type, children: [] };
+                    core.Transforms.wrapNodes(editor, newSubListElement, { at: listItemPath });
+                    core.Transforms.moveNodes(editor, {
+                        at: listItemPath,
+                        to: [...previousPath, ((_e = previousNode === null || previousNode === void 0 ? void 0 : previousNode.children) !== null && _e !== void 0 ? _e : []).length],
+                    });
+                }
+            }
+        }
+    };
+    const decreaseListItemDepth = (editor, entries) => {
+        var _a, _b, _c;
+        const { list: [listNode, listPath], listItem: [listItemNode, listItemPath], } = entries;
+        const [listParentNode, listParentPath] = core.Editor.parent(editor, listPath);
+        /**
+         * Decreasable if parent of list is list item.
+         */
+        if (!isListItemElement(listParentNode)) {
+            return;
+        }
+        const newListItemPath = core.Path.next(listParentPath);
+        const listItemIndex = listItemPath[listItemPath.length - 1];
+        const nextSiblingListItems = ((_a = listNode === null || listNode === void 0 ? void 0 : listNode.children) !== null && _a !== void 0 ? _a : []).slice(listItemIndex + 1, ((_b = listNode === null || listNode === void 0 ? void 0 : listNode.children) !== null && _b !== void 0 ? _b : []).length);
+        core.Transforms.moveNodes(editor, {
+            at: listItemPath,
+            to: newListItemPath,
+        });
+        /**
+         * After list item moved to parent list, if there are some sibling list items next to list item, move them to a new list in list item.
+         */
+        if (nextSiblingListItems.length) {
+            const newSubListElement = { type: listNode.type, children: [] };
+            const newSubListPath = [...newListItemPath, ((_c = listItemNode === null || listItemNode === void 0 ? void 0 : listItemNode.children) !== null && _c !== void 0 ? _c : []).length];
+            core.Transforms.insertNodes(editor, newSubListElement, { at: newSubListPath });
+            nextSiblingListItems.forEach((_, index) => {
+                core.Transforms.moveNodes(editor, {
+                    /**
+                     * Path of each nextSiblingListItems is the same as listItemPath.
+                     * Since each time list item moved, path of next list item will be unshifted.
+                     */
+                    at: listItemPath,
+                    to: [...newSubListPath, index],
+                });
+            });
+        }
+        /**
+         * Remove the stale sublist if there are no previous sibling list items.
+         */
+        if (listItemIndex <= 0) {
+            core.Transforms.removeNodes(editor, {
+                at: listPath,
+            });
+        }
+    };
+    const decreaseListItemDepthOrUnwrapIfNeed = (editor, entries) => {
+        const { list: [, listPath], } = entries;
+        const [listParentNode] = core.Editor.parent(editor, listPath);
+        if (listParentNode.type !== types.li) {
+            unwrapList(editor);
+        }
+        else {
+            decreaseListItemDepth(editor, entries);
+        }
+    };
+    return {
+        types,
+        isListElement,
+        isListItemElement,
+        isSelectionInList,
+        getAboveListAndItem,
+        unwrapList,
+        toggleList,
+        increaseListItemDepth,
+        decreaseListItemDepth,
+        decreaseListItemDepthOrUnwrapIfNeed,
+        with(editor) {
+            const { deleteBackward, insertBreak } = editor;
+            editor.deleteBackward = (unit) => {
+                const { selection } = editor;
+                if (selection && core.Range.isCollapsed(selection)) {
+                    const entries = getAboveListAndItem(editor);
+                    if (entries && core.isSelectionAtBlockEdge(editor) === 'start') {
+                        decreaseListItemDepthOrUnwrapIfNeed(editor, entries);
+                        return;
+                    }
+                }
+                deleteBackward(unit);
+            };
+            editor.insertBreak = () => {
+                var _a;
+                const entries = getAboveListAndItem(editor);
+                if (entries) {
+                    core.deleteSelectionFragmentIfExpanded(editor);
+                    if (core.isAboveBlockEmpty(editor, { match: isListItemElement })) {
+                        decreaseListItemDepthOrUnwrapIfNeed(editor, entries);
+                    }
+                    else {
+                        core.Transforms.splitNodes(editor, {
+                            at: (_a = editor.selection) === null || _a === void 0 ? void 0 : _a.focus,
+                            match: isListItemElement,
+                            always: true,
+                        });
+                    }
+                }
+                else {
+                    insertBreak();
+                }
+            };
+            return editor;
+        },
+    };
 }
 
 exports.LIST_TYPES = LIST_TYPES;

package/list/typings.d.ts

@@ -1,8 +1,8 @@
 import { Editor, QuadratsElement, Location, Node, NodeEntry, Withable, WithElementType } from '@quadrats/core';
-export declare type ListRootTypeKey = 'ol' | 'ul';
-export declare type ListItemTypeKey = 'li';
-export declare type ListTypeKey = ListRootTypeKey | ListItemTypeKey;
-export declare type ListTypes = Record<ListTypeKey, string>;
+export type ListRootTypeKey = 'ol' | 'ul';
+export type ListItemTypeKey = 'li';
+export type ListTypeKey = ListRootTypeKey | ListItemTypeKey;
+export type ListTypes = Record<ListTypeKey, string>;
 export interface ListElement extends QuadratsElement, WithElementType {
 }
 export interface ListAboveListAndItem {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quadrats/common",
-  "version": "0.6.7",
+  "version": "0.7.0",
   "description": "",
   "author": "Rytass",
   "homepage": "https://github.com/Quadrats/quadrats#readme",
@@ -18,8 +18,8 @@
     "url": "https://github.com/Quadrats/quadrats/issues"
   },
   "dependencies": {
-    "@quadrats/core": "^0.6.5",
-    "@quadrats/locales": "^0.6.0",
-    "@quadrats/utils": "^0.6.5"
+    "@quadrats/core": "^0.7.0",
+    "@quadrats/locales": "^0.7.0",
+    "@quadrats/utils": "^0.7.0"
   }
 }

package/read-more/createReadMore.d.ts

@@ -1,4 +1,4 @@
 import { WithElementType } from '@quadrats/core';
 import { ReadMore } from './typings';
-export declare type CreateReadMoreOptions = Partial<WithElementType>;
+export type CreateReadMoreOptions = Partial<WithElementType>;
 export declare function createReadMore(options?: CreateReadMoreOptions): ReadMore;

package/read-more/createReadMore.js

@@ -1,56 +1,56 @@
-import { Element, normalizeVoidElementChildren, normalizeOnlyAtRoot, getNodesByTypes, Path, Transforms, deleteSelectionFragmentIfExpanded, createParagraphElement } from '@quadrats/core';
+import { Element, normalizeVoidElementChildren, normalizeOnlyAtRoot, Path, Transforms, getNodesByTypes, deleteSelectionFragmentIfExpanded, createParagraphElement } from '@quadrats/core';
 import { READ_MORE_TYPE } from './constants.js';
 
-function createReadMore(options = {}) {
-    const { type = READ_MORE_TYPE } = options;
-    const getReadMoresAtRoot = (editor) => getNodesByTypes(editor, [type], {
-        at: [],
-        mode: 'highest',
-    });
-    const createReadMoreElement = () => ({ type, children: [{ text: '' }] });
-    const insertReadMore = (editor) => {
-        deleteSelectionFragmentIfExpanded(editor);
-        const { selection } = editor;
-        if (!selection) {
-            return;
-        }
-        const [alreadyExistReadMore] = getReadMoresAtRoot(editor);
-        if (!alreadyExistReadMore && selection.focus) {
-            const at = [selection.focus.path[0] + 1];
-            Transforms.insertNodes(editor, [createReadMoreElement(), createParagraphElement()], {
-                at,
-            });
-            Transforms.select(editor, Path.next(at));
-        }
-    };
-    return {
-        type,
-        createReadMoreElement,
-        insertReadMore,
-        with(editor) {
-            const { isVoid, normalizeNode } = editor;
-            editor.isVoid = element => element.type === type || isVoid(element);
-            editor.normalizeNode = (entry) => {
-                const [node, path] = entry;
-                if (Element.isElement(node) && node.type === type) {
-                    if (normalizeVoidElementChildren(editor, [node, path]) || normalizeOnlyAtRoot(editor, entry)) {
-                        return;
-                    }
-                    /**
-                     * Only accept single read more element.
-                     */
-                    for (const [, readMorePath] of getReadMoresAtRoot(editor)) {
-                        if (Path.isAfter(path, readMorePath)) {
-                            Transforms.removeNodes(editor, { at: path });
-                            return;
-                        }
-                    }
-                }
-                normalizeNode(entry);
-            };
-            return editor;
-        },
-    };
+function createReadMore(options = {}) {
+    const { type = READ_MORE_TYPE } = options;
+    const getReadMoresAtRoot = (editor) => getNodesByTypes(editor, [type], {
+        at: [],
+        mode: 'highest',
+    });
+    const createReadMoreElement = () => ({ type, children: [{ text: '' }] });
+    const insertReadMore = (editor) => {
+        deleteSelectionFragmentIfExpanded(editor);
+        const { selection } = editor;
+        if (!selection) {
+            return;
+        }
+        const [alreadyExistReadMore] = getReadMoresAtRoot(editor);
+        if (!alreadyExistReadMore && selection.focus) {
+            const at = [selection.focus.path[0] + 1];
+            Transforms.insertNodes(editor, [createReadMoreElement(), createParagraphElement()], {
+                at,
+            });
+            Transforms.select(editor, Path.next(at));
+        }
+    };
+    return {
+        type,
+        createReadMoreElement,
+        insertReadMore,
+        with(editor) {
+            const { isVoid, normalizeNode } = editor;
+            editor.isVoid = element => element.type === type || isVoid(element);
+            editor.normalizeNode = (entry) => {
+                const [node, path] = entry;
+                if (Element.isElement(node) && node.type === type) {
+                    if (normalizeVoidElementChildren(editor, [node, path]) || normalizeOnlyAtRoot(editor, entry)) {
+                        return;
+                    }
+                    /**
+                     * Only accept single read more element.
+                     */
+                    for (const [, readMorePath] of getReadMoresAtRoot(editor)) {
+                        if (Path.isAfter(path, readMorePath)) {
+                            Transforms.removeNodes(editor, { at: path });
+                            return;
+                        }
+                    }
+                }
+                normalizeNode(entry);
+            };
+            return editor;
+        },
+    };
 }
 
 export { createReadMore };

package/read-more/index.cjs.js

@@ -1,61 +1,59 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
 var core = require('@quadrats/core');
 
 const READ_MORE_TYPE = 'read_more';
 
-function createReadMore(options = {}) {
-    const { type = READ_MORE_TYPE } = options;
-    const getReadMoresAtRoot = (editor) => core.getNodesByTypes(editor, [type], {
-        at: [],
-        mode: 'highest',
-    });
-    const createReadMoreElement = () => ({ type, children: [{ text: '' }] });
-    const insertReadMore = (editor) => {
-        core.deleteSelectionFragmentIfExpanded(editor);
-        const { selection } = editor;
-        if (!selection) {
-            return;
-        }
-        const [alreadyExistReadMore] = getReadMoresAtRoot(editor);
-        if (!alreadyExistReadMore && selection.focus) {
-            const at = [selection.focus.path[0] + 1];
-            core.Transforms.insertNodes(editor, [createReadMoreElement(), core.createParagraphElement()], {
-                at,
-            });
-            core.Transforms.select(editor, core.Path.next(at));
-        }
-    };
-    return {
-        type,
-        createReadMoreElement,
-        insertReadMore,
-        with(editor) {
-            const { isVoid, normalizeNode } = editor;
-            editor.isVoid = element => element.type === type || isVoid(element);
-            editor.normalizeNode = (entry) => {
-                const [node, path] = entry;
-                if (core.Element.isElement(node) && node.type === type) {
-                    if (core.normalizeVoidElementChildren(editor, [node, path]) || core.normalizeOnlyAtRoot(editor, entry)) {
-                        return;
-                    }
-                    /**
-                     * Only accept single read more element.
-                     */
-                    for (const [, readMorePath] of getReadMoresAtRoot(editor)) {
-                        if (core.Path.isAfter(path, readMorePath)) {
-                            core.Transforms.removeNodes(editor, { at: path });
-                            return;
-                        }
-                    }
-                }
-                normalizeNode(entry);
-            };
-            return editor;
-        },
-    };
+function createReadMore(options = {}) {
+    const { type = READ_MORE_TYPE } = options;
+    const getReadMoresAtRoot = (editor) => core.getNodesByTypes(editor, [type], {
+        at: [],
+        mode: 'highest',
+    });
+    const createReadMoreElement = () => ({ type, children: [{ text: '' }] });
+    const insertReadMore = (editor) => {
+        core.deleteSelectionFragmentIfExpanded(editor);
+        const { selection } = editor;
+        if (!selection) {
+            return;
+        }
+        const [alreadyExistReadMore] = getReadMoresAtRoot(editor);
+        if (!alreadyExistReadMore && selection.focus) {
+            const at = [selection.focus.path[0] + 1];
+            core.Transforms.insertNodes(editor, [createReadMoreElement(), core.createParagraphElement()], {
+                at,
+            });
+            core.Transforms.select(editor, core.Path.next(at));
+        }
+    };
+    return {
+        type,
+        createReadMoreElement,
+        insertReadMore,
+        with(editor) {
+            const { isVoid, normalizeNode } = editor;
+            editor.isVoid = element => element.type === type || isVoid(element);
+            editor.normalizeNode = (entry) => {
+                const [node, path] = entry;
+                if (core.Element.isElement(node) && node.type === type) {
+                    if (core.normalizeVoidElementChildren(editor, [node, path]) || core.normalizeOnlyAtRoot(editor, entry)) {
+                        return;
+                    }
+                    /**
+                     * Only accept single read more element.
+                     */
+                    for (const [, readMorePath] of getReadMoresAtRoot(editor)) {
+                        if (core.Path.isAfter(path, readMorePath)) {
+                            core.Transforms.removeNodes(editor, { at: path });
+                            return;
+                        }
+                    }
+                }
+                normalizeNode(entry);
+            };
+            return editor;
+        },
+    };
 }
 
 exports.READ_MORE_TYPE = READ_MORE_TYPE;

package/strikethrough/createStrikethrough.d.ts

@@ -1 +1,2 @@
-export declare const createStrikethrough: (variant?: string | undefined) => ({ type, variant }?: import("@quadrats/common/toggle-mark").CreateToggleMarkOptions | undefined) => import("@quadrats/common/toggle-mark").ToggleMark<import("slate").BaseEditor>;
+import { Editor } from '@quadrats/core';
+export declare function createStrikethrough<E extends Editor = Editor>(variant?: string): ({ type, variant }?: import("@quadrats/common/toggle-mark").CreateToggleMarkOptions | undefined) => import("@quadrats/common/toggle-mark").ToggleMark<E>;