@quadrats/common 0.6.7 → 0.7.0

package/italic/createItalic.d.ts

@@ -1 +1,2 @@
-export declare const createItalic: (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 createItalic<E extends Editor = Editor>(variant?: string): ({ type, variant }?: import("@quadrats/common/toggle-mark").CreateToggleMarkOptions | undefined) => import("@quadrats/common/toggle-mark").ToggleMark<E>;

package/italic/createItalic.js

@@ -1,9 +1,11 @@
 import { createToggleMarkCreator } from '@quadrats/common/toggle-mark';
 import { ITALIC_TYPE } from './constants.js';
 
-const createItalic = (variant) => createToggleMarkCreator({
-    type: ITALIC_TYPE,
-    variant,
-});
+function createItalic(variant) {
+    return createToggleMarkCreator({
+        type: ITALIC_TYPE,
+        variant,
+    });
+}
 
 export { createItalic };

package/italic/index.cjs.js

@@ -1,15 +1,15 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
 var toggleMark = require('@quadrats/common/toggle-mark');
 
 const ITALIC_TYPE = 'italic';
 
-const createItalic = (variant) => toggleMark.createToggleMarkCreator({
-    type: ITALIC_TYPE,
-    variant,
-});
+function createItalic(variant) {
+    return toggleMark.createToggleMarkCreator({
+        type: ITALIC_TYPE,
+        variant,
+    });
+}
 
 exports.ITALIC_TYPE = ITALIC_TYPE;
 exports.createItalic = createItalic;

package/link/createLink.js

@@ -1,153 +1,153 @@
 import { isUrl } from '@quadrats/utils';
-import { Range, unwrapNodesByTypes, Editor, Element, Transforms, Text, getRangeBeforeFromAboveBlockStart, getRangeBefore, isNodesTypeIn, wrapNodesWithUnhangRange, getAboveByTypes } from '@quadrats/core';
+import { Range, Editor, Element, Transforms, Text, getRangeBeforeFromAboveBlockStart, getRangeBefore, isNodesTypeIn, unwrapNodesByTypes, wrapNodesWithUnhangRange, getAboveByTypes } from '@quadrats/core';
 import { LINK_TYPE } from './constants.js';
 
-function createLink({ type = LINK_TYPE, isUrl: isUrl$1 = isUrl, prevUrlToLinkAfterSpaceEntered = true, wrappableVoidTypes, } = {}) {
-    const getFirstPrevTextAsUrlAndRange = (editor, at) => {
-        /**
-         * First, find all text under the same lowest above block and before entered space.
-         */
-        const rangeBeforeFromAboveBlockStart = getRangeBeforeFromAboveBlockStart(editor, at);
-        if (rangeBeforeFromAboveBlockStart) {
-            const textFromAboveBlockStart = Editor.string(editor, rangeBeforeFromAboveBlockStart);
-            if (isUrl$1(textFromAboveBlockStart)) {
-                return {
-                    at: rangeBeforeFromAboveBlockStart,
-                    url: textFromAboveBlockStart,
-                };
-            }
-        }
-        /**
-         * Last, find the first previous word as url.
-         */
-        const beforeWordRange = getRangeBefore(editor, at, {
-            acrossPaths: true,
-            afterMatch: true,
-            match: ' ',
-        });
-        if (beforeWordRange) {
-            const beforeWordText = Editor.string(editor, beforeWordRange);
-            if (isUrl$1(beforeWordText)) {
-                return {
-                    at: beforeWordRange,
-                    url: beforeWordText,
-                };
-            }
-        }
-    };
-    const isSelectionInLink = editor => isNodesTypeIn(editor, [type]);
-    const insertLink = (editor, url, options = {}) => {
-        const { text = url } = options;
-        const link = {
-            type,
-            url: url.trim(),
-            children: [{ text }],
-        };
-        Transforms.insertNodes(editor, link, options);
-    };
-    const unwrapLink = (editor, options = {}) => unwrapNodesByTypes(editor, [type], options);
-    const wrapLink = (editor, url, options = {}) => {
-        const link = { type, url: url.trim(), children: [] };
-        wrapNodesWithUnhangRange(editor, link, Object.assign(Object.assign({}, options), { split: true }));
-    };
-    const upsertLink = (editor, url, options = {}) => {
-        const { at = editor.selection } = options;
-        if (!at) {
-            return;
-        }
-        if (Range.isCollapsed(at)) {
-            if (wrappableVoidTypes) {
-                const [node, path] = Editor.node(editor, at.focus.path);
-                if (Text.isText(node) && !node.text) {
-                    const [wrappableVoid, wrappableVoidPath] = getAboveByTypes(editor, wrappableVoidTypes, {
-                        at: path,
-                    }) || [];
-                    if (wrappableVoid) {
-                        unwrapLink(editor, { at: wrappableVoidPath });
-                        wrapLink(editor, url, { at: wrappableVoidPath });
-                    }
-                    else {
-                        insertLink(editor, url, { at });
-                        Transforms.move(editor, { distance: url.length });
-                    }
-                    return;
-                }
-            }
-            insertLink(editor, url, { at });
-        }
-        else {
-            unwrapLink(editor, { at });
-            wrapLink(editor, url, { at });
-        }
-    };
-    return {
-        type,
-        isUrl: isUrl$1,
-        getFirstPrevTextAsUrlAndRange,
-        isSelectionInLink,
-        insertLink,
-        unwrapLink,
-        wrapLink,
-        upsertLink,
-        with(editor) {
-            const { insertText, isInline, normalizeNode } = editor;
-            if (prevUrlToLinkAfterSpaceEntered) {
-                editor.insertText = (text) => {
-                    var _a;
-                    const { selection } = editor;
-                    if (text === ' ' && selection && Range.isCollapsed(selection)) {
-                        const shouldTransformedData = getFirstPrevTextAsUrlAndRange(editor, selection);
-                        if (shouldTransformedData) {
-                            const { at, url } = shouldTransformedData;
-                            unwrapLink(editor, { at });
-                            wrapLink(editor, url, {
-                                at: Object.assign(Object.assign({}, at), { 
-                                    /**
-                                     * Get a new selection here.
-                                     */
-                                    focus: ((_a = editor.selection) === null || _a === void 0 ? void 0 : _a.focus) || at.focus }),
-                            });
-                        }
-                    }
-                    insertText(text);
-                };
-            }
-            editor.isInline = (element) => {
-                if (element.type !== type) {
-                    return isInline(element);
-                }
-                if (!wrappableVoidTypes) {
-                    return true;
-                }
-                return !element.children.some(child => Editor.isBlock(editor, child)
-                    && Editor.isVoid(editor, child)
-                    && wrappableVoidTypes.includes(child.type));
-            };
-            editor.normalizeNode = (entry) => {
-                const [node, path] = entry;
-                if (Element.isElement(node) && node.type === type) {
-                    /**
-                     * Remove invalid url.
-                     */
-                    if (!isUrl$1(node.url)) {
-                        Transforms.unwrapNodes(editor, { at: path });
-                        return;
-                    }
-                    /**
-                     * Remove empty content.
-                     */
-                    if (Text.isTextList(node.children)) {
-                        if (node.children.every(textNode => !textNode.text)) {
-                            Transforms.unwrapNodes(editor, { at: path });
-                            return;
-                        }
-                    }
-                }
-                normalizeNode(entry);
-            };
-            return editor;
-        },
-    };
+function createLink({ type = LINK_TYPE, isUrl: isUrl$1 = isUrl, prevUrlToLinkAfterSpaceEntered = true, wrappableVoidTypes, } = {}) {
+    const getFirstPrevTextAsUrlAndRange = (editor, at) => {
+        /**
+         * First, find all text under the same lowest above block and before entered space.
+         */
+        const rangeBeforeFromAboveBlockStart = getRangeBeforeFromAboveBlockStart(editor, at);
+        if (rangeBeforeFromAboveBlockStart) {
+            const textFromAboveBlockStart = Editor.string(editor, rangeBeforeFromAboveBlockStart);
+            if (isUrl$1(textFromAboveBlockStart)) {
+                return {
+                    at: rangeBeforeFromAboveBlockStart,
+                    url: textFromAboveBlockStart,
+                };
+            }
+        }
+        /**
+         * Last, find the first previous word as url.
+         */
+        const beforeWordRange = getRangeBefore(editor, at, {
+            acrossPaths: true,
+            afterMatch: true,
+            match: ' ',
+        });
+        if (beforeWordRange) {
+            const beforeWordText = Editor.string(editor, beforeWordRange);
+            if (isUrl$1(beforeWordText)) {
+                return {
+                    at: beforeWordRange,
+                    url: beforeWordText,
+                };
+            }
+        }
+    };
+    const isSelectionInLink = editor => isNodesTypeIn(editor, [type]);
+    const insertLink = (editor, url, options = {}) => {
+        const { text = url } = options;
+        const link = {
+            type,
+            url: url.trim(),
+            children: [{ text }],
+        };
+        Transforms.insertNodes(editor, link, options);
+    };
+    const unwrapLink = (editor, options = {}) => unwrapNodesByTypes(editor, [type], options);
+    const wrapLink = (editor, url, options = {}) => {
+        const link = { type, url: url.trim(), children: [] };
+        wrapNodesWithUnhangRange(editor, link, Object.assign(Object.assign({}, options), { split: true }));
+    };
+    const upsertLink = (editor, url, options = {}) => {
+        const { at = editor.selection } = options;
+        if (!at) {
+            return;
+        }
+        if (Range.isCollapsed(at)) {
+            if (wrappableVoidTypes) {
+                const [node, path] = Editor.node(editor, at.focus.path);
+                if (Text.isText(node) && !node.text) {
+                    const [wrappableVoid, wrappableVoidPath] = getAboveByTypes(editor, wrappableVoidTypes, {
+                        at: path,
+                    }) || [];
+                    if (wrappableVoid) {
+                        unwrapLink(editor, { at: wrappableVoidPath });
+                        wrapLink(editor, url, { at: wrappableVoidPath });
+                    }
+                    else {
+                        insertLink(editor, url, { at });
+                        Transforms.move(editor, { distance: url.length });
+                    }
+                    return;
+                }
+            }
+            insertLink(editor, url, { at });
+        }
+        else {
+            unwrapLink(editor, { at });
+            wrapLink(editor, url, { at });
+        }
+    };
+    return {
+        type,
+        isUrl: isUrl$1,
+        getFirstPrevTextAsUrlAndRange,
+        isSelectionInLink,
+        insertLink,
+        unwrapLink,
+        wrapLink,
+        upsertLink,
+        with(editor) {
+            const { insertText, isInline, normalizeNode } = editor;
+            if (prevUrlToLinkAfterSpaceEntered) {
+                editor.insertText = (text) => {
+                    var _a;
+                    const { selection } = editor;
+                    if (text === ' ' && selection && Range.isCollapsed(selection)) {
+                        const shouldTransformedData = getFirstPrevTextAsUrlAndRange(editor, selection);
+                        if (shouldTransformedData) {
+                            const { at, url } = shouldTransformedData;
+                            unwrapLink(editor, { at });
+                            wrapLink(editor, url, {
+                                at: Object.assign(Object.assign({}, at), { 
+                                    /**
+                                     * Get a new selection here.
+                                     */
+                                    focus: ((_a = editor.selection) === null || _a === void 0 ? void 0 : _a.focus) || at.focus }),
+                            });
+                        }
+                    }
+                    insertText(text);
+                };
+            }
+            editor.isInline = (element) => {
+                if (element.type !== type) {
+                    return isInline(element);
+                }
+                if (!wrappableVoidTypes) {
+                    return true;
+                }
+                return !element.children.some(child => Editor.isBlock(editor, child)
+                    && Editor.isVoid(editor, child)
+                    && wrappableVoidTypes.includes(child.type));
+            };
+            editor.normalizeNode = (entry) => {
+                const [node, path] = entry;
+                if (Element.isElement(node) && node.type === type) {
+                    /**
+                     * Remove invalid url.
+                     */
+                    if (!isUrl$1(node.url)) {
+                        Transforms.unwrapNodes(editor, { at: path });
+                        return;
+                    }
+                    /**
+                     * Remove empty content.
+                     */
+                    if (Text.isTextList(node.children)) {
+                        if (node.children.every(textNode => !textNode.text)) {
+                            Transforms.unwrapNodes(editor, { at: path });
+                            return;
+                        }
+                    }
+                }
+                normalizeNode(entry);
+            };
+            return editor;
+        },
+    };
 }
 
 export { createLink };

package/link/index.cjs.js

@@ -1,158 +1,156 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
 var utils = require('@quadrats/utils');
 var core = require('@quadrats/core');
 
 const LINK_TYPE = 'link';
 
-function createLink({ type = LINK_TYPE, isUrl = utils.isUrl, prevUrlToLinkAfterSpaceEntered = true, wrappableVoidTypes, } = {}) {
-    const getFirstPrevTextAsUrlAndRange = (editor, at) => {
-        /**
-         * First, find all text under the same lowest above block and before entered space.
-         */
-        const rangeBeforeFromAboveBlockStart = core.getRangeBeforeFromAboveBlockStart(editor, at);
-        if (rangeBeforeFromAboveBlockStart) {
-            const textFromAboveBlockStart = core.Editor.string(editor, rangeBeforeFromAboveBlockStart);
-            if (isUrl(textFromAboveBlockStart)) {
-                return {
-                    at: rangeBeforeFromAboveBlockStart,
-                    url: textFromAboveBlockStart,
-                };
-            }
-        }
-        /**
-         * Last, find the first previous word as url.
-         */
-        const beforeWordRange = core.getRangeBefore(editor, at, {
-            acrossPaths: true,
-            afterMatch: true,
-            match: ' ',
-        });
-        if (beforeWordRange) {
-            const beforeWordText = core.Editor.string(editor, beforeWordRange);
-            if (isUrl(beforeWordText)) {
-                return {
-                    at: beforeWordRange,
-                    url: beforeWordText,
-                };
-            }
-        }
-    };
-    const isSelectionInLink = editor => core.isNodesTypeIn(editor, [type]);
-    const insertLink = (editor, url, options = {}) => {
-        const { text = url } = options;
-        const link = {
-            type,
-            url: url.trim(),
-            children: [{ text }],
-        };
-        core.Transforms.insertNodes(editor, link, options);
-    };
-    const unwrapLink = (editor, options = {}) => core.unwrapNodesByTypes(editor, [type], options);
-    const wrapLink = (editor, url, options = {}) => {
-        const link = { type, url: url.trim(), children: [] };
-        core.wrapNodesWithUnhangRange(editor, link, Object.assign(Object.assign({}, options), { split: true }));
-    };
-    const upsertLink = (editor, url, options = {}) => {
-        const { at = editor.selection } = options;
-        if (!at) {
-            return;
-        }
-        if (core.Range.isCollapsed(at)) {
-            if (wrappableVoidTypes) {
-                const [node, path] = core.Editor.node(editor, at.focus.path);
-                if (core.Text.isText(node) && !node.text) {
-                    const [wrappableVoid, wrappableVoidPath] = core.getAboveByTypes(editor, wrappableVoidTypes, {
-                        at: path,
-                    }) || [];
-                    if (wrappableVoid) {
-                        unwrapLink(editor, { at: wrappableVoidPath });
-                        wrapLink(editor, url, { at: wrappableVoidPath });
-                    }
-                    else {
-                        insertLink(editor, url, { at });
-                        core.Transforms.move(editor, { distance: url.length });
-                    }
-                    return;
-                }
-            }
-            insertLink(editor, url, { at });
-        }
-        else {
-            unwrapLink(editor, { at });
-            wrapLink(editor, url, { at });
-        }
-    };
-    return {
-        type,
-        isUrl,
-        getFirstPrevTextAsUrlAndRange,
-        isSelectionInLink,
-        insertLink,
-        unwrapLink,
-        wrapLink,
-        upsertLink,
-        with(editor) {
-            const { insertText, isInline, normalizeNode } = editor;
-            if (prevUrlToLinkAfterSpaceEntered) {
-                editor.insertText = (text) => {
-                    var _a;
-                    const { selection } = editor;
-                    if (text === ' ' && selection && core.Range.isCollapsed(selection)) {
-                        const shouldTransformedData = getFirstPrevTextAsUrlAndRange(editor, selection);
-                        if (shouldTransformedData) {
-                            const { at, url } = shouldTransformedData;
-                            unwrapLink(editor, { at });
-                            wrapLink(editor, url, {
-                                at: Object.assign(Object.assign({}, at), { 
-                                    /**
-                                     * Get a new selection here.
-                                     */
-                                    focus: ((_a = editor.selection) === null || _a === void 0 ? void 0 : _a.focus) || at.focus }),
-                            });
-                        }
-                    }
-                    insertText(text);
-                };
-            }
-            editor.isInline = (element) => {
-                if (element.type !== type) {
-                    return isInline(element);
-                }
-                if (!wrappableVoidTypes) {
-                    return true;
-                }
-                return !element.children.some(child => core.Editor.isBlock(editor, child)
-                    && core.Editor.isVoid(editor, child)
-                    && wrappableVoidTypes.includes(child.type));
-            };
-            editor.normalizeNode = (entry) => {
-                const [node, path] = entry;
-                if (core.Element.isElement(node) && node.type === type) {
-                    /**
-                     * Remove invalid url.
-                     */
-                    if (!isUrl(node.url)) {
-                        core.Transforms.unwrapNodes(editor, { at: path });
-                        return;
-                    }
-                    /**
-                     * Remove empty content.
-                     */
-                    if (core.Text.isTextList(node.children)) {
-                        if (node.children.every(textNode => !textNode.text)) {
-                            core.Transforms.unwrapNodes(editor, { at: path });
-                            return;
-                        }
-                    }
-                }
-                normalizeNode(entry);
-            };
-            return editor;
-        },
-    };
+function createLink({ type = LINK_TYPE, isUrl = utils.isUrl, prevUrlToLinkAfterSpaceEntered = true, wrappableVoidTypes, } = {}) {
+    const getFirstPrevTextAsUrlAndRange = (editor, at) => {
+        /**
+         * First, find all text under the same lowest above block and before entered space.
+         */
+        const rangeBeforeFromAboveBlockStart = core.getRangeBeforeFromAboveBlockStart(editor, at);
+        if (rangeBeforeFromAboveBlockStart) {
+            const textFromAboveBlockStart = core.Editor.string(editor, rangeBeforeFromAboveBlockStart);
+            if (isUrl(textFromAboveBlockStart)) {
+                return {
+                    at: rangeBeforeFromAboveBlockStart,
+                    url: textFromAboveBlockStart,
+                };
+            }
+        }
+        /**
+         * Last, find the first previous word as url.
+         */
+        const beforeWordRange = core.getRangeBefore(editor, at, {
+            acrossPaths: true,
+            afterMatch: true,
+            match: ' ',
+        });
+        if (beforeWordRange) {
+            const beforeWordText = core.Editor.string(editor, beforeWordRange);
+            if (isUrl(beforeWordText)) {
+                return {
+                    at: beforeWordRange,
+                    url: beforeWordText,
+                };
+            }
+        }
+    };
+    const isSelectionInLink = editor => core.isNodesTypeIn(editor, [type]);
+    const insertLink = (editor, url, options = {}) => {
+        const { text = url } = options;
+        const link = {
+            type,
+            url: url.trim(),
+            children: [{ text }],
+        };
+        core.Transforms.insertNodes(editor, link, options);
+    };
+    const unwrapLink = (editor, options = {}) => core.unwrapNodesByTypes(editor, [type], options);
+    const wrapLink = (editor, url, options = {}) => {
+        const link = { type, url: url.trim(), children: [] };
+        core.wrapNodesWithUnhangRange(editor, link, Object.assign(Object.assign({}, options), { split: true }));
+    };
+    const upsertLink = (editor, url, options = {}) => {
+        const { at = editor.selection } = options;
+        if (!at) {
+            return;
+        }
+        if (core.Range.isCollapsed(at)) {
+            if (wrappableVoidTypes) {
+                const [node, path] = core.Editor.node(editor, at.focus.path);
+                if (core.Text.isText(node) && !node.text) {
+                    const [wrappableVoid, wrappableVoidPath] = core.getAboveByTypes(editor, wrappableVoidTypes, {
+                        at: path,
+                    }) || [];
+                    if (wrappableVoid) {
+                        unwrapLink(editor, { at: wrappableVoidPath });
+                        wrapLink(editor, url, { at: wrappableVoidPath });
+                    }
+                    else {
+                        insertLink(editor, url, { at });
+                        core.Transforms.move(editor, { distance: url.length });
+                    }
+                    return;
+                }
+            }
+            insertLink(editor, url, { at });
+        }
+        else {
+            unwrapLink(editor, { at });
+            wrapLink(editor, url, { at });
+        }
+    };
+    return {
+        type,
+        isUrl,
+        getFirstPrevTextAsUrlAndRange,
+        isSelectionInLink,
+        insertLink,
+        unwrapLink,
+        wrapLink,
+        upsertLink,
+        with(editor) {
+            const { insertText, isInline, normalizeNode } = editor;
+            if (prevUrlToLinkAfterSpaceEntered) {
+                editor.insertText = (text) => {
+                    var _a;
+                    const { selection } = editor;
+                    if (text === ' ' && selection && core.Range.isCollapsed(selection)) {
+                        const shouldTransformedData = getFirstPrevTextAsUrlAndRange(editor, selection);
+                        if (shouldTransformedData) {
+                            const { at, url } = shouldTransformedData;
+                            unwrapLink(editor, { at });
+                            wrapLink(editor, url, {
+                                at: Object.assign(Object.assign({}, at), { 
+                                    /**
+                                     * Get a new selection here.
+                                     */
+                                    focus: ((_a = editor.selection) === null || _a === void 0 ? void 0 : _a.focus) || at.focus }),
+                            });
+                        }
+                    }
+                    insertText(text);
+                };
+            }
+            editor.isInline = (element) => {
+                if (element.type !== type) {
+                    return isInline(element);
+                }
+                if (!wrappableVoidTypes) {
+                    return true;
+                }
+                return !element.children.some(child => core.Editor.isBlock(editor, child)
+                    && core.Editor.isVoid(editor, child)
+                    && wrappableVoidTypes.includes(child.type));
+            };
+            editor.normalizeNode = (entry) => {
+                const [node, path] = entry;
+                if (core.Element.isElement(node) && node.type === type) {
+                    /**
+                     * Remove invalid url.
+                     */
+                    if (!isUrl(node.url)) {
+                        core.Transforms.unwrapNodes(editor, { at: path });
+                        return;
+                    }
+                    /**
+                     * Remove empty content.
+                     */
+                    if (core.Text.isTextList(node.children)) {
+                        if (node.children.every(textNode => !textNode.text)) {
+                            core.Transforms.unwrapNodes(editor, { at: path });
+                            return;
+                        }
+                    }
+                }
+                normalizeNode(entry);
+            };
+            return editor;
+        },
+    };
 }
 
 exports.LINK_TYPE = LINK_TYPE;

package/link/typings.d.ts

@@ -5,8 +5,8 @@ export interface LinkElement extends QuadratsElement, WithElementType {
 export interface LinkInsertLinkOptions extends TransformsInsertNodesOptions {
     text?: string;
 }
-export declare type LinkUnwrapLinkOptions = UnwrapNodeByTypesOptions;
-export declare type LinkWrapLinkOptions = Omit<TransformsWrapNodesOptions, 'split'>;
+export type LinkUnwrapLinkOptions = UnwrapNodeByTypesOptions;
+export type LinkWrapLinkOptions = Omit<TransformsWrapNodesOptions, 'split'>;
 export interface LinkUpsertLinkOptions {
     at?: Range;
 }