@quadrats/common 0.6.7 → 0.7.0

package/heading/createHeading.js

@@ -1,51 +1,51 @@
 import { Element, Transforms, PARAGRAPH_TYPE, normalizeOnlyInlineOrTextInChildren, getNodes } from '@quadrats/core';
 import { HEADING_TYPE, HEADING_LEVELS } from './constants.js';
 
-function createHeading({ type = HEADING_TYPE, enabledLevels = HEADING_LEVELS, } = {}) {
-    const getHeadingNodes = (editor, level, options = {}) => getNodes(editor, Object.assign(Object.assign({}, options), { match: node => node.type === type && node.level === level }));
-    const isSelectionInHeading = (editor, level, options = {}) => {
-        const [match] = getHeadingNodes(editor, level, options);
-        return !!match;
-    };
-    const toggleHeadingNodes = (editor, level, defaultType = PARAGRAPH_TYPE) => {
-        if (enabledLevels.includes(level)) {
-            const isActive = isSelectionInHeading(editor, level);
-            const defaultNode = { type: defaultType };
-            const heading = { type, level, children: [] };
-            const node = isActive ? defaultNode : heading;
-            Transforms.setNodes(editor, node);
-        }
-        else {
-            throw new Error(`Only ${enabledLevels} levels are enabled.`);
-        }
-    };
-    return {
-        type,
-        enabledLevels,
-        getHeadingNodes,
-        isSelectionInHeading,
-        toggleHeadingNodes,
-        with(editor) {
-            const { normalizeNode } = editor;
-            editor.normalizeNode = (entry) => {
-                const [node, path] = entry;
-                if (Element.isElement(node) && node.type === type) {
-                    /**
-                     * Set invalid level elements to default.
-                     */
-                    if (!enabledLevels.includes(node.level)) {
-                        Transforms.setNodes(editor, { type: PARAGRAPH_TYPE }, { at: path });
-                        return;
-                    }
-                    if (normalizeOnlyInlineOrTextInChildren(editor, entry)) {
-                        return;
-                    }
-                }
-                normalizeNode(entry);
-            };
-            return editor;
-        },
-    };
+function createHeading({ type = HEADING_TYPE, enabledLevels = HEADING_LEVELS, } = {}) {
+    const getHeadingNodes = (editor, level, options = {}) => getNodes(editor, Object.assign(Object.assign({}, options), { match: node => node.type === type && node.level === level }));
+    const isSelectionInHeading = (editor, level, options = {}) => {
+        const [match] = getHeadingNodes(editor, level, options);
+        return !!match;
+    };
+    const toggleHeadingNodes = (editor, level, defaultType = PARAGRAPH_TYPE) => {
+        if (enabledLevels.includes(level)) {
+            const isActive = isSelectionInHeading(editor, level);
+            const defaultNode = { type: defaultType };
+            const heading = { type, level, children: [] };
+            const node = isActive ? defaultNode : heading;
+            Transforms.setNodes(editor, node);
+        }
+        else {
+            throw new Error(`Only ${enabledLevels} levels are enabled.`);
+        }
+    };
+    return {
+        type,
+        enabledLevels,
+        getHeadingNodes,
+        isSelectionInHeading,
+        toggleHeadingNodes,
+        with(editor) {
+            const { normalizeNode } = editor;
+            editor.normalizeNode = (entry) => {
+                const [node, path] = entry;
+                if (Element.isElement(node) && node.type === type) {
+                    /**
+                     * Set invalid level elements to default.
+                     */
+                    if (!enabledLevels.includes(node.level)) {
+                        Transforms.setNodes(editor, { type: PARAGRAPH_TYPE }, { at: path });
+                        return;
+                    }
+                    if (normalizeOnlyInlineOrTextInChildren(editor, entry)) {
+                        return;
+                    }
+                }
+                normalizeNode(entry);
+            };
+            return editor;
+        },
+    };
 }
 
 export { createHeading };

package/heading/index.cjs.js

@@ -1,57 +1,55 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
 var core = require('@quadrats/core');
 
-const HEADING_TYPE = 'heading';
+const HEADING_TYPE = 'heading';
 const HEADING_LEVELS = [1, 2, 3, 4, 5, 6];
 
-function createHeading({ type = HEADING_TYPE, enabledLevels = HEADING_LEVELS, } = {}) {
-    const getHeadingNodes = (editor, level, options = {}) => core.getNodes(editor, Object.assign(Object.assign({}, options), { match: node => node.type === type && node.level === level }));
-    const isSelectionInHeading = (editor, level, options = {}) => {
-        const [match] = getHeadingNodes(editor, level, options);
-        return !!match;
-    };
-    const toggleHeadingNodes = (editor, level, defaultType = core.PARAGRAPH_TYPE) => {
-        if (enabledLevels.includes(level)) {
-            const isActive = isSelectionInHeading(editor, level);
-            const defaultNode = { type: defaultType };
-            const heading = { type, level, children: [] };
-            const node = isActive ? defaultNode : heading;
-            core.Transforms.setNodes(editor, node);
-        }
-        else {
-            throw new Error(`Only ${enabledLevels} levels are enabled.`);
-        }
-    };
-    return {
-        type,
-        enabledLevels,
-        getHeadingNodes,
-        isSelectionInHeading,
-        toggleHeadingNodes,
-        with(editor) {
-            const { normalizeNode } = editor;
-            editor.normalizeNode = (entry) => {
-                const [node, path] = entry;
-                if (core.Element.isElement(node) && node.type === type) {
-                    /**
-                     * Set invalid level elements to default.
-                     */
-                    if (!enabledLevels.includes(node.level)) {
-                        core.Transforms.setNodes(editor, { type: core.PARAGRAPH_TYPE }, { at: path });
-                        return;
-                    }
-                    if (core.normalizeOnlyInlineOrTextInChildren(editor, entry)) {
-                        return;
-                    }
-                }
-                normalizeNode(entry);
-            };
-            return editor;
-        },
-    };
+function createHeading({ type = HEADING_TYPE, enabledLevels = HEADING_LEVELS, } = {}) {
+    const getHeadingNodes = (editor, level, options = {}) => core.getNodes(editor, Object.assign(Object.assign({}, options), { match: node => node.type === type && node.level === level }));
+    const isSelectionInHeading = (editor, level, options = {}) => {
+        const [match] = getHeadingNodes(editor, level, options);
+        return !!match;
+    };
+    const toggleHeadingNodes = (editor, level, defaultType = core.PARAGRAPH_TYPE) => {
+        if (enabledLevels.includes(level)) {
+            const isActive = isSelectionInHeading(editor, level);
+            const defaultNode = { type: defaultType };
+            const heading = { type, level, children: [] };
+            const node = isActive ? defaultNode : heading;
+            core.Transforms.setNodes(editor, node);
+        }
+        else {
+            throw new Error(`Only ${enabledLevels} levels are enabled.`);
+        }
+    };
+    return {
+        type,
+        enabledLevels,
+        getHeadingNodes,
+        isSelectionInHeading,
+        toggleHeadingNodes,
+        with(editor) {
+            const { normalizeNode } = editor;
+            editor.normalizeNode = (entry) => {
+                const [node, path] = entry;
+                if (core.Element.isElement(node) && node.type === type) {
+                    /**
+                     * Set invalid level elements to default.
+                     */
+                    if (!enabledLevels.includes(node.level)) {
+                        core.Transforms.setNodes(editor, { type: core.PARAGRAPH_TYPE }, { at: path });
+                        return;
+                    }
+                    if (core.normalizeOnlyInlineOrTextInChildren(editor, entry)) {
+                        return;
+                    }
+                }
+                normalizeNode(entry);
+            };
+            return editor;
+        },
+    };
 }
 
 exports.HEADING_LEVELS = HEADING_LEVELS;

package/heading/typings.d.ts

@@ -1,5 +1,5 @@
 import { Editor, QuadratsElement, GetNodesOptions, Node, NodeEntry, Withable, WithElementType } from '@quadrats/core';
-export declare type HeadingLevel = 1 | 2 | 3 | 4 | 5 | 6;
+export type HeadingLevel = 1 | 2 | 3 | 4 | 5 | 6;
 export interface HeadingElement extends QuadratsElement, WithElementType {
     level: HeadingLevel;
 }

package/highlight/createHighlight.d.ts

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

package/highlight/createHighlight.js

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

package/highlight/index.cjs.js

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

package/image/constants.js

@@ -1,7 +1,7 @@
-const IMAGE_TYPES = {
-    figure: 'image_figure',
-    image: 'image',
-    caption: 'image_caption',
+const IMAGE_TYPES = {
+    figure: 'image_figure',
+    image: 'image',
+    caption: 'image_caption',
 };
 
 export { IMAGE_TYPES };