@quadrats/common 0.6.6 → 0.7.0

package/blockquote/createBlockquote.d.ts

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

package/blockquote/createBlockquote.js

@@ -1,38 +1,38 @@
-import { isNodesTypeIn, unwrapNodesByTypes, wrapNodesWithUnhangRange } from '@quadrats/core';
+import { unwrapNodesByTypes, wrapNodesWithUnhangRange, isNodesTypeIn } from '@quadrats/core';
 import { BLOCKQUOTE_TYPE } from './constants.js';
 
-function createBlockquote({ type = BLOCKQUOTE_TYPE } = {}) {
-    const unwrapBlockquote = (editor) => {
-        unwrapNodesByTypes(editor, [type]);
-    };
-    const wrapBlockquote = (editor) => {
-        const element = {
-            type,
-            children: [],
-        };
-        wrapNodesWithUnhangRange(editor, element, { split: true });
-    };
-    const isSelectionInBlockquote = editor => (isNodesTypeIn(editor, [type], { mode: 'highest' }));
-    return {
-        type,
-        unwrapBlockquote,
-        wrapBlockquote,
-        isSelectionInBlockquote,
-        toggleBlockquote: (editor) => {
-            const actived = isSelectionInBlockquote(editor);
-            if (editor.selection) {
-                if (actived) {
-                    unwrapBlockquote(editor);
-                }
-                else {
-                    wrapBlockquote(editor);
-                }
-            }
-        },
-        with(editor) {
-            return editor;
-        },
-    };
+function createBlockquote({ type = BLOCKQUOTE_TYPE } = {}) {
+    const unwrapBlockquote = (editor) => {
+        unwrapNodesByTypes(editor, [type]);
+    };
+    const wrapBlockquote = (editor) => {
+        const element = {
+            type,
+            children: [],
+        };
+        wrapNodesWithUnhangRange(editor, element, { split: true });
+    };
+    const isSelectionInBlockquote = editor => (isNodesTypeIn(editor, [type], { mode: 'highest' }));
+    return {
+        type,
+        unwrapBlockquote,
+        wrapBlockquote,
+        isSelectionInBlockquote,
+        toggleBlockquote: (editor) => {
+            const actived = isSelectionInBlockquote(editor);
+            if (editor.selection) {
+                if (actived) {
+                    unwrapBlockquote(editor);
+                }
+                else {
+                    wrapBlockquote(editor);
+                }
+            }
+        },
+        with(editor) {
+            return editor;
+        },
+    };
 }
 
 export { createBlockquote };

package/blockquote/index.cjs.js

@@ -1,43 +1,41 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
 var core = require('@quadrats/core');
 
 const BLOCKQUOTE_TYPE = 'blockquote';
 
-function createBlockquote({ type = BLOCKQUOTE_TYPE } = {}) {
-    const unwrapBlockquote = (editor) => {
-        core.unwrapNodesByTypes(editor, [type]);
-    };
-    const wrapBlockquote = (editor) => {
-        const element = {
-            type,
-            children: [],
-        };
-        core.wrapNodesWithUnhangRange(editor, element, { split: true });
-    };
-    const isSelectionInBlockquote = editor => (core.isNodesTypeIn(editor, [type], { mode: 'highest' }));
-    return {
-        type,
-        unwrapBlockquote,
-        wrapBlockquote,
-        isSelectionInBlockquote,
-        toggleBlockquote: (editor) => {
-            const actived = isSelectionInBlockquote(editor);
-            if (editor.selection) {
-                if (actived) {
-                    unwrapBlockquote(editor);
-                }
-                else {
-                    wrapBlockquote(editor);
-                }
-            }
-        },
-        with(editor) {
-            return editor;
-        },
-    };
+function createBlockquote({ type = BLOCKQUOTE_TYPE } = {}) {
+    const unwrapBlockquote = (editor) => {
+        core.unwrapNodesByTypes(editor, [type]);
+    };
+    const wrapBlockquote = (editor) => {
+        const element = {
+            type,
+            children: [],
+        };
+        core.wrapNodesWithUnhangRange(editor, element, { split: true });
+    };
+    const isSelectionInBlockquote = editor => (core.isNodesTypeIn(editor, [type], { mode: 'highest' }));
+    return {
+        type,
+        unwrapBlockquote,
+        wrapBlockquote,
+        isSelectionInBlockquote,
+        toggleBlockquote: (editor) => {
+            const actived = isSelectionInBlockquote(editor);
+            if (editor.selection) {
+                if (actived) {
+                    unwrapBlockquote(editor);
+                }
+                else {
+                    wrapBlockquote(editor);
+                }
+            }
+        },
+        with(editor) {
+            return editor;
+        },
+    };
 }
 
 exports.BLOCKQUOTE_TYPE = BLOCKQUOTE_TYPE;

package/bold/createBold.d.ts

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

package/bold/createBold.js

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

package/bold/index.cjs.js

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

package/divider/createDivider.d.ts

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

package/divider/createDivider.js

@@ -1,35 +1,35 @@
 import { Element, normalizeVoidElementChildren, Transforms, createParagraphElement } from '@quadrats/core';
 import { DIVIDER_TYPE } from './constants.js';
 
-function createDivider(options = {}) {
-    const { type = DIVIDER_TYPE } = options;
-    const createDividerElement = () => ({ type, children: [{ text: '' }] });
-    const insertDivider = (editor) => {
-        Transforms.insertNodes(editor, [createDividerElement(), createParagraphElement()]);
-        Transforms.move(editor);
-    };
-    return {
-        type,
-        createDividerElement,
-        insertDivider,
-        with(editor) {
-            const { isVoid, normalizeNode } = editor;
-            editor.isVoid = element => element.type === type || isVoid(element);
-            editor.normalizeNode = (entry) => {
-                const [node, path] = entry;
-                /**
-                 * Only accept single empty text inside void element.
-                 */
-                if (Element.isElement(node) && node.type === type) {
-                    if (normalizeVoidElementChildren(editor, [node, path])) {
-                        return;
-                    }
-                }
-                normalizeNode(entry);
-            };
-            return editor;
-        },
-    };
+function createDivider(options = {}) {
+    const { type = DIVIDER_TYPE } = options;
+    const createDividerElement = () => ({ type, children: [{ text: '' }] });
+    const insertDivider = (editor) => {
+        Transforms.insertNodes(editor, [createDividerElement(), createParagraphElement()]);
+        Transforms.move(editor);
+    };
+    return {
+        type,
+        createDividerElement,
+        insertDivider,
+        with(editor) {
+            const { isVoid, normalizeNode } = editor;
+            editor.isVoid = element => element.type === type || isVoid(element);
+            editor.normalizeNode = (entry) => {
+                const [node, path] = entry;
+                /**
+                 * Only accept single empty text inside void element.
+                 */
+                if (Element.isElement(node) && node.type === type) {
+                    if (normalizeVoidElementChildren(editor, [node, path])) {
+                        return;
+                    }
+                }
+                normalizeNode(entry);
+            };
+            return editor;
+        },
+    };
 }
 
 export { createDivider };

package/divider/index.cjs.js

@@ -1,40 +1,38 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
 var core = require('@quadrats/core');
 
 const DIVIDER_TYPE = 'hr';
 
-function createDivider(options = {}) {
-    const { type = DIVIDER_TYPE } = options;
-    const createDividerElement = () => ({ type, children: [{ text: '' }] });
-    const insertDivider = (editor) => {
-        core.Transforms.insertNodes(editor, [createDividerElement(), core.createParagraphElement()]);
-        core.Transforms.move(editor);
-    };
-    return {
-        type,
-        createDividerElement,
-        insertDivider,
-        with(editor) {
-            const { isVoid, normalizeNode } = editor;
-            editor.isVoid = element => element.type === type || isVoid(element);
-            editor.normalizeNode = (entry) => {
-                const [node, path] = entry;
-                /**
-                 * Only accept single empty text inside void element.
-                 */
-                if (core.Element.isElement(node) && node.type === type) {
-                    if (core.normalizeVoidElementChildren(editor, [node, path])) {
-                        return;
-                    }
-                }
-                normalizeNode(entry);
-            };
-            return editor;
-        },
-    };
+function createDivider(options = {}) {
+    const { type = DIVIDER_TYPE } = options;
+    const createDividerElement = () => ({ type, children: [{ text: '' }] });
+    const insertDivider = (editor) => {
+        core.Transforms.insertNodes(editor, [createDividerElement(), core.createParagraphElement()]);
+        core.Transforms.move(editor);
+    };
+    return {
+        type,
+        createDividerElement,
+        insertDivider,
+        with(editor) {
+            const { isVoid, normalizeNode } = editor;
+            editor.isVoid = element => element.type === type || isVoid(element);
+            editor.normalizeNode = (entry) => {
+                const [node, path] = entry;
+                /**
+                 * Only accept single empty text inside void element.
+                 */
+                if (core.Element.isElement(node) && node.type === type) {
+                    if (core.normalizeVoidElementChildren(editor, [node, path])) {
+                        return;
+                    }
+                }
+                normalizeNode(entry);
+            };
+            return editor;
+        },
+    };
 }
 
 exports.DIVIDER_TYPE = DIVIDER_TYPE;

package/embed/createEmbed.js

@@ -2,46 +2,46 @@ import { Element, Transforms, normalizeVoidElementChildren, PARAGRAPH_TYPE } fro
 import { EMBED_TYPE } from './constants.js';
 import { serializeEmbedCode } from './serializeEmbedCode.js';
 
-function createEmbed(options) {
-    const { type = EMBED_TYPE, strategies } = options;
-    const insertEmbed = (editor, providers, embedCode, defaultNode = PARAGRAPH_TYPE) => {
-        const result = serializeEmbedCode(embedCode, strategies, providers);
-        if (result) {
-            const [provider, data] = result;
-            const embedElement = Object.assign(Object.assign({}, data), { type, provider, children: [{ text: '' }] });
-            Transforms.insertNodes(editor, [
-                embedElement,
-                typeof defaultNode === 'string'
-                    ? { type: defaultNode, children: [{ text: '' }] } : defaultNode,
-            ]);
-            Transforms.move(editor);
-        }
-    };
-    return {
-        type,
-        strategies,
-        insertEmbed,
-        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) {
-                    const strategy = node.provider
-                        ? strategies[node.provider] : undefined;
-                    if (!strategy || !strategy.isElementDataValid(node)) {
-                        Transforms.removeNodes(editor, { at: path });
-                        return;
-                    }
-                    if (normalizeVoidElementChildren(editor, [node, path])) {
-                        return;
-                    }
-                }
-                normalizeNode(entry);
-            };
-            return editor;
-        },
-    };
+function createEmbed(options) {
+    const { type = EMBED_TYPE, strategies } = options;
+    const insertEmbed = (editor, providers, embedCode, defaultNode = PARAGRAPH_TYPE) => {
+        const result = serializeEmbedCode(embedCode, strategies, providers);
+        if (result) {
+            const [provider, data] = result;
+            const embedElement = Object.assign(Object.assign({}, data), { type, provider, children: [{ text: '' }] });
+            Transforms.insertNodes(editor, [
+                embedElement,
+                typeof defaultNode === 'string'
+                    ? { type: defaultNode, children: [{ text: '' }] } : defaultNode,
+            ]);
+            Transforms.move(editor);
+        }
+    };
+    return {
+        type,
+        strategies,
+        insertEmbed,
+        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) {
+                    const strategy = node.provider
+                        ? strategies[node.provider] : undefined;
+                    if (!strategy || !strategy.isElementDataValid(node)) {
+                        Transforms.removeNodes(editor, { at: path });
+                        return;
+                    }
+                    if (normalizeVoidElementChildren(editor, [node, path])) {
+                        return;
+                    }
+                }
+                normalizeNode(entry);
+            };
+            return editor;
+        },
+    };
 }
 
 export { createEmbed };

package/embed/deserializeEmbedElementToData.js

@@ -1,9 +1,9 @@
-function deserializeEmbedElementToData(element, strategies) {
-    const { provider } = element;
-    const strategy = provider ? strategies[provider] : undefined;
-    if (strategy) {
-        return [provider, strategy.deserialize(element)];
-    }
+function deserializeEmbedElementToData(element, strategies) {
+    const { provider } = element;
+    const strategy = provider ? strategies[provider] : undefined;
+    if (strategy) {
+        return [provider, strategy.deserialize(element)];
+    }
 }
 
 export { deserializeEmbedElementToData };

package/embed/index.cjs.js

@@ -1,69 +1,67 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
 var core = require('@quadrats/core');
 
 const EMBED_TYPE = 'embed';
 
-function serializeEmbedCode(embedCode, strategies, providers) {
-    for (const provider of providers) {
-        const strategy = strategies[provider];
-        const data = strategy.serialize(embedCode);
-        if (data) {
-            return [provider, data];
-        }
-    }
+function serializeEmbedCode(embedCode, strategies, providers) {
+    for (const provider of providers) {
+        const strategy = strategies[provider];
+        const data = strategy.serialize(embedCode);
+        if (data) {
+            return [provider, data];
+        }
+    }
 }
 
-function deserializeEmbedElementToData(element, strategies) {
-    const { provider } = element;
-    const strategy = provider ? strategies[provider] : undefined;
-    if (strategy) {
-        return [provider, strategy.deserialize(element)];
-    }
+function deserializeEmbedElementToData(element, strategies) {
+    const { provider } = element;
+    const strategy = provider ? strategies[provider] : undefined;
+    if (strategy) {
+        return [provider, strategy.deserialize(element)];
+    }
 }
 
-function createEmbed(options) {
-    const { type = EMBED_TYPE, strategies } = options;
-    const insertEmbed = (editor, providers, embedCode, defaultNode = core.PARAGRAPH_TYPE) => {
-        const result = serializeEmbedCode(embedCode, strategies, providers);
-        if (result) {
-            const [provider, data] = result;
-            const embedElement = Object.assign(Object.assign({}, data), { type, provider, children: [{ text: '' }] });
-            core.Transforms.insertNodes(editor, [
-                embedElement,
-                typeof defaultNode === 'string'
-                    ? { type: defaultNode, children: [{ text: '' }] } : defaultNode,
-            ]);
-            core.Transforms.move(editor);
-        }
-    };
-    return {
-        type,
-        strategies,
-        insertEmbed,
-        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) {
-                    const strategy = node.provider
-                        ? strategies[node.provider] : undefined;
-                    if (!strategy || !strategy.isElementDataValid(node)) {
-                        core.Transforms.removeNodes(editor, { at: path });
-                        return;
-                    }
-                    if (core.normalizeVoidElementChildren(editor, [node, path])) {
-                        return;
-                    }
-                }
-                normalizeNode(entry);
-            };
-            return editor;
-        },
-    };
+function createEmbed(options) {
+    const { type = EMBED_TYPE, strategies } = options;
+    const insertEmbed = (editor, providers, embedCode, defaultNode = core.PARAGRAPH_TYPE) => {
+        const result = serializeEmbedCode(embedCode, strategies, providers);
+        if (result) {
+            const [provider, data] = result;
+            const embedElement = Object.assign(Object.assign({}, data), { type, provider, children: [{ text: '' }] });
+            core.Transforms.insertNodes(editor, [
+                embedElement,
+                typeof defaultNode === 'string'
+                    ? { type: defaultNode, children: [{ text: '' }] } : defaultNode,
+            ]);
+            core.Transforms.move(editor);
+        }
+    };
+    return {
+        type,
+        strategies,
+        insertEmbed,
+        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) {
+                    const strategy = node.provider
+                        ? strategies[node.provider] : undefined;
+                    if (!strategy || !strategy.isElementDataValid(node)) {
+                        core.Transforms.removeNodes(editor, { at: path });
+                        return;
+                    }
+                    if (core.normalizeVoidElementChildren(editor, [node, path])) {
+                        return;
+                    }
+                }
+                normalizeNode(entry);
+            };
+            return editor;
+        },
+    };
 }
 
 exports.EMBED_TYPE = EMBED_TYPE;

package/embed/serializeEmbedCode.js

@@ -1,11 +1,11 @@
-function serializeEmbedCode(embedCode, strategies, providers) {
-    for (const provider of providers) {
-        const strategy = strategies[provider];
-        const data = strategy.serialize(embedCode);
-        if (data) {
-            return [provider, data];
-        }
-    }
+function serializeEmbedCode(embedCode, strategies, providers) {
+    for (const provider of providers) {
+        const strategy = strategies[provider];
+        const data = strategy.serialize(embedCode);
+        if (data) {
+            return [provider, data];
+        }
+    }
 }
 
 export { serializeEmbedCode };