@quadrats/common 0.6.7 → 0.7.0

package/image/index.cjs.js

@@ -1,229 +1,227 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
 var utils = require('@quadrats/utils');
 var core = require('@quadrats/core');
 
-const IMAGE_TYPES = {
-    figure: 'image_figure',
-    image: 'image',
-    caption: 'image_caption',
+const IMAGE_TYPES = {
+    figure: 'image_figure',
+    image: 'image',
+    caption: 'image_caption',
 };
 
-function isHostingNotRequired(src) {
-    return /^https?:\/\/.*/.test(src) || src.startsWith('data:image');
+function isHostingNotRequired(src) {
+    return /^https?:\/\/.*/.test(src) || src.startsWith('data:image');
 }
 
-function getImageFigureElementCommonProps(element) {
-    const { width } = element;
-    return {
-        style: typeof width === 'number' ? { width: `${width}%` } : undefined,
-    };
+function getImageFigureElementCommonProps(element) {
+    const { width } = element;
+    return {
+        style: typeof width === 'number' ? { width: `${width}%` } : undefined,
+    };
 }
 
-function getImageElementCommonProps(element, hostingResolvers) {
-    const { src, hosting } = element;
-    const resolver = !isHostingNotRequired(src) && hosting && hostingResolvers ? hostingResolvers[hosting] : undefined;
-    return {
-        src: resolver ? resolver(src) : src,
-    };
+function getImageElementCommonProps(element, hostingResolvers) {
+    const { src, hosting } = element;
+    const resolver = !isHostingNotRequired(src) && hosting && hostingResolvers ? hostingResolvers[hosting] : undefined;
+    return {
+        src: resolver ? resolver(src) : src,
+    };
 }
 
-function resolveSizeSteps(steps) {
-    let sortedSteps = steps.filter(step => step > 0 && step < 100).sort();
-    if (!sortedSteps.includes(100)) {
-        sortedSteps = [...sortedSteps, 100];
-    }
-    return sortedSteps;
-}
-function createImage(options = {}) {
-    const { types: typesOptions, hostingResolvers, sizeSteps: unresolvedSizeSteps, isImageUrl = utils.isImageUrl, } = options;
-    const types = Object.assign(Object.assign({}, IMAGE_TYPES), typesOptions);
-    const sizeSteps = unresolvedSizeSteps && resolveSizeSteps(unresolvedSizeSteps);
-    const getAboveImageFigure = (editor, options) => core.getAboveByTypes(editor, [types.figure], options);
-    const getAboveImageCaption = (editor, options) => core.getAboveByTypes(editor, [types.caption], options);
-    const isNodesInImage = (editor, options) => core.isNodesTypeIn(editor, [types.image], options);
-    const isSelectionInImage = editor => isNodesInImage(editor);
-    const isSelectionInImageCaption = editor => core.isNodesTypeIn(editor, [types.caption]);
-    const isCollapsedOnImage = editor => !!editor.selection && core.Range.isCollapsed(editor.selection) && isSelectionInImage(editor);
-    const previousNodeIsCaption = (editor) => {
-        const previous = core.Editor.previous(editor);
-        if (!previous)
-            return false;
-        const [, previousLocation] = previous;
-        const previousWrapper = core.Editor.parent(editor, previousLocation);
-        if (!previousWrapper)
-            return false;
-        const [previousWrapperNode] = previousWrapper;
-        return previousWrapperNode.type === types.caption;
-    };
-    const createImageElement = (src, hosting) => {
-        const imageElement = {
-            type: types.image,
-            src,
-            hosting,
-            children: [{ text: '' }],
-        };
-        const captionElement = {
-            type: types.caption,
-            children: [{ text: '' }],
-        };
-        return {
-            type: types.figure,
-            width: 100,
-            children: [imageElement, captionElement],
-        };
-    };
-    const insertImage = (editor, src, options = {}) => {
-        const { hosting, at } = options;
-        const imageElement = createImageElement(src, hosting);
-        core.Transforms.insertNodes(editor, [imageElement, core.createParagraphElement()], { at });
-    };
-    const adjustWidthPercentage = (percentage) => {
-        if (percentage < 0) {
-            percentage = 0;
-        }
-        else if (percentage > 100) {
-            percentage = 100;
-        }
-        if (!sizeSteps) {
-            return percentage;
-        }
-        const lowerIndex = sizeSteps.findIndex(step => step >= percentage) - 1;
-        const upperIndex = lowerIndex + 1;
-        if (lowerIndex < 0) {
-            return sizeSteps[0];
-        }
-        const lower = sizeSteps[lowerIndex];
-        if (upperIndex === sizeSteps.length) {
-            return lower;
-        }
-        const upper = sizeSteps[upperIndex];
-        return Math.abs(percentage - lower) <= Math.abs(upper - percentage) ? lower : upper;
-    };
-    const resizeImage = (editor, [, path], width) => {
-        const [figure, figurePath] = getAboveImageFigure(editor, { at: path }) || [];
-        if (figure) {
-            width = adjustWidthPercentage(width);
-            if (figure.width !== width) {
-                const resizedElement = Object.assign(Object.assign({}, figure), { width });
-                core.Transforms.setNodes(editor, resizedElement, {
-                    at: figurePath,
-                });
-            }
-        }
-    };
-    return {
-        types,
-        hostingResolvers,
-        sizeSteps,
-        isImageUrl,
-        getAboveImageFigure,
-        getAboveImageCaption,
-        isSelectionInImage,
-        isSelectionInImageCaption,
-        isCollapsedOnImage,
-        createImageElement,
-        insertImage,
-        resizeImage,
-        with(editor) {
-            const { deleteBackward, deleteForward, insertBreak, isVoid, normalizeNode, } = editor;
-            const deleteCollapsed = (origin, isEdgeMethodName) => {
-                const { selection } = editor;
-                /**
-                 * Avoid from delete fragment outside caption while collapsed in caption.
-                 */
-                if (selection && core.Range.isCollapsed(selection)) {
-                    const [, captionPath] = getAboveImageCaption(editor) || [];
-                    if ((captionPath && core.Editor[isEdgeMethodName](editor, selection.focus, captionPath))) {
-                        return;
-                    }
-                    // Remove image element when backwards from external
-                    if (!captionPath && previousNodeIsCaption(editor)) {
-                        const previous = core.Editor.previous(editor);
-                        if (!previous)
-                            return false;
-                        const [, previousLocation] = previous;
-                        const previousWrapper = core.Editor.parent(editor, previousLocation);
-                        if (!previousWrapper)
-                            return false;
-                        const [previousWrapperNode, wrapperLocation] = previousWrapper;
-                        if (previousWrapperNode.type === types.caption) {
-                            const imageContainer = core.Editor.parent(editor, wrapperLocation);
-                            if (imageContainer) {
-                                const [imageElement, imageLocation] = imageContainer;
-                                if (imageElement.type === types.figure) {
-                                    core.Transforms.removeNodes(editor, { at: imageLocation });
-                                }
-                            }
-                        }
-                        return;
-                    }
-                }
-                origin();
-            };
-            editor.deleteBackward = (unit) => {
-                deleteCollapsed(() => deleteBackward(unit), 'isStart');
-            };
-            editor.deleteForward = (unit) => {
-                deleteCollapsed(() => deleteForward(unit), 'isEnd');
-            };
-            editor.insertBreak = () => {
-                const captionEntry = getAboveImageCaption(editor);
-                /**
-                 * Avoid from splitting children of caption.
-                 */
-                if (captionEntry) {
-                    const [, captionLocation] = captionEntry;
-                    const imageEntry = core.Editor.parent(editor, captionLocation);
-                    if (imageEntry) {
-                        const [imageElement, imagePosition] = imageEntry;
-                        if (imageElement.type === types.figure) {
-                            core.Transforms.insertNodes(editor, core.createParagraphElement(), { at: core.Editor.after(editor, imagePosition) });
-                            core.Transforms.move(editor);
-                        }
-                    }
-                    return;
-                }
-                insertBreak();
-            };
-            editor.isVoid = element => element.type === types.image || isVoid(element);
-            editor.normalizeNode = (entry) => {
-                const [node, path] = entry;
-                if (core.Element.isElement(node)) {
-                    if (node.type === types.figure) {
-                        if (!isNodesInImage(editor, { at: path })) {
-                            core.Transforms.removeNodes(editor, { at: path });
-                            return;
-                        }
-                    }
-                    else if (node.type === types.image) {
-                        const { src, width, hosting } = node;
-                        if (typeof src !== 'string'
-                            || !(width == null || typeof width === 'number')
-                            || !(hosting == null || typeof hosting === 'string')) {
-                            const [, figurePath] = getAboveImageFigure(editor, { at: path }) || [];
-                            if (figurePath) {
-                                core.Transforms.removeNodes(editor, { at: figurePath });
-                                return;
-                            }
-                        }
-                        if (core.normalizeVoidElementChildren(editor, [node, path])) {
-                            return;
-                        }
-                    }
-                    else if (node.type === types.caption) {
-                        if (core.normalizeOnlyInlineOrTextInChildren(editor, entry)) {
-                            return;
-                        }
-                    }
-                }
-                normalizeNode(entry);
-            };
-            return editor;
-        },
-    };
+function resolveSizeSteps(steps) {
+    let sortedSteps = steps.filter(step => step > 0 && step < 100).sort();
+    if (!sortedSteps.includes(100)) {
+        sortedSteps = [...sortedSteps, 100];
+    }
+    return sortedSteps;
+}
+function createImage(options = {}) {
+    const { types: typesOptions, hostingResolvers, sizeSteps: unresolvedSizeSteps, isImageUrl = utils.isImageUrl, } = options;
+    const types = Object.assign(Object.assign({}, IMAGE_TYPES), typesOptions);
+    const sizeSteps = unresolvedSizeSteps && resolveSizeSteps(unresolvedSizeSteps);
+    const getAboveImageFigure = (editor, options) => core.getAboveByTypes(editor, [types.figure], options);
+    const getAboveImageCaption = (editor, options) => core.getAboveByTypes(editor, [types.caption], options);
+    const isNodesInImage = (editor, options) => core.isNodesTypeIn(editor, [types.image], options);
+    const isSelectionInImage = editor => isNodesInImage(editor);
+    const isSelectionInImageCaption = editor => core.isNodesTypeIn(editor, [types.caption]);
+    const isCollapsedOnImage = editor => !!editor.selection && core.Range.isCollapsed(editor.selection) && isSelectionInImage(editor);
+    const previousNodeIsCaption = (editor) => {
+        const previous = core.Editor.previous(editor);
+        if (!previous)
+            return false;
+        const [, previousLocation] = previous;
+        const previousWrapper = core.Editor.parent(editor, previousLocation);
+        if (!previousWrapper)
+            return false;
+        const [previousWrapperNode] = previousWrapper;
+        return previousWrapperNode.type === types.caption;
+    };
+    const createImageElement = (src, hosting) => {
+        const imageElement = {
+            type: types.image,
+            src,
+            hosting,
+            children: [{ text: '' }],
+        };
+        const captionElement = {
+            type: types.caption,
+            children: [{ text: '' }],
+        };
+        return {
+            type: types.figure,
+            width: 100,
+            children: [imageElement, captionElement],
+        };
+    };
+    const insertImage = (editor, src, options = {}) => {
+        const { hosting, at } = options;
+        const imageElement = createImageElement(src, hosting);
+        core.Transforms.insertNodes(editor, [imageElement, core.createParagraphElement()], { at });
+    };
+    const adjustWidthPercentage = (percentage) => {
+        if (percentage < 0) {
+            percentage = 0;
+        }
+        else if (percentage > 100) {
+            percentage = 100;
+        }
+        if (!sizeSteps) {
+            return percentage;
+        }
+        const lowerIndex = sizeSteps.findIndex(step => step >= percentage) - 1;
+        const upperIndex = lowerIndex + 1;
+        if (lowerIndex < 0) {
+            return sizeSteps[0];
+        }
+        const lower = sizeSteps[lowerIndex];
+        if (upperIndex === sizeSteps.length) {
+            return lower;
+        }
+        const upper = sizeSteps[upperIndex];
+        return Math.abs(percentage - lower) <= Math.abs(upper - percentage) ? lower : upper;
+    };
+    const resizeImage = (editor, [, path], width) => {
+        const [figure, figurePath] = getAboveImageFigure(editor, { at: path }) || [];
+        if (figure) {
+            width = adjustWidthPercentage(width);
+            if (figure.width !== width) {
+                const resizedElement = Object.assign(Object.assign({}, figure), { width });
+                core.Transforms.setNodes(editor, resizedElement, {
+                    at: figurePath,
+                });
+            }
+        }
+    };
+    return {
+        types,
+        hostingResolvers,
+        sizeSteps,
+        isImageUrl,
+        getAboveImageFigure,
+        getAboveImageCaption,
+        isSelectionInImage,
+        isSelectionInImageCaption,
+        isCollapsedOnImage,
+        createImageElement,
+        insertImage,
+        resizeImage,
+        with(editor) {
+            const { deleteBackward, deleteForward, insertBreak, isVoid, normalizeNode, } = editor;
+            const deleteCollapsed = (origin, isEdgeMethodName) => {
+                const { selection } = editor;
+                /**
+                 * Avoid from delete fragment outside caption while collapsed in caption.
+                 */
+                if (selection && core.Range.isCollapsed(selection)) {
+                    const [, captionPath] = getAboveImageCaption(editor) || [];
+                    if ((captionPath && core.Editor[isEdgeMethodName](editor, selection.focus, captionPath))) {
+                        return;
+                    }
+                    // Remove image element when backwards from external
+                    if (!captionPath && previousNodeIsCaption(editor)) {
+                        const previous = core.Editor.previous(editor);
+                        if (!previous)
+                            return false;
+                        const [, previousLocation] = previous;
+                        const previousWrapper = core.Editor.parent(editor, previousLocation);
+                        if (!previousWrapper)
+                            return false;
+                        const [previousWrapperNode, wrapperLocation] = previousWrapper;
+                        if (previousWrapperNode.type === types.caption) {
+                            const imageContainer = core.Editor.parent(editor, wrapperLocation);
+                            if (imageContainer) {
+                                const [imageElement, imageLocation] = imageContainer;
+                                if (imageElement.type === types.figure) {
+                                    core.Transforms.removeNodes(editor, { at: imageLocation });
+                                }
+                            }
+                        }
+                        return;
+                    }
+                }
+                origin();
+            };
+            editor.deleteBackward = (unit) => {
+                deleteCollapsed(() => deleteBackward(unit), 'isStart');
+            };
+            editor.deleteForward = (unit) => {
+                deleteCollapsed(() => deleteForward(unit), 'isEnd');
+            };
+            editor.insertBreak = () => {
+                const captionEntry = getAboveImageCaption(editor);
+                /**
+                 * Avoid from splitting children of caption.
+                 */
+                if (captionEntry) {
+                    const [, captionLocation] = captionEntry;
+                    const imageEntry = core.Editor.parent(editor, captionLocation);
+                    if (imageEntry) {
+                        const [imageElement, imagePosition] = imageEntry;
+                        if (imageElement.type === types.figure) {
+                            core.Transforms.insertNodes(editor, core.createParagraphElement(), { at: core.Editor.after(editor, imagePosition) });
+                            core.Transforms.move(editor);
+                        }
+                    }
+                    return;
+                }
+                insertBreak();
+            };
+            editor.isVoid = element => element.type === types.image || isVoid(element);
+            editor.normalizeNode = (entry) => {
+                const [node, path] = entry;
+                if (core.Element.isElement(node)) {
+                    if (node.type === types.figure) {
+                        if (!isNodesInImage(editor, { at: path })) {
+                            core.Transforms.removeNodes(editor, { at: path });
+                            return;
+                        }
+                    }
+                    else if (node.type === types.image) {
+                        const { src, width, hosting } = node;
+                        if (typeof src !== 'string'
+                            || !(width == null || typeof width === 'number')
+                            || !(hosting == null || typeof hosting === 'string')) {
+                            const [, figurePath] = getAboveImageFigure(editor, { at: path }) || [];
+                            if (figurePath) {
+                                core.Transforms.removeNodes(editor, { at: figurePath });
+                                return;
+                            }
+                        }
+                        if (core.normalizeVoidElementChildren(editor, [node, path])) {
+                            return;
+                        }
+                    }
+                    else if (node.type === types.caption) {
+                        if (core.normalizeOnlyInlineOrTextInChildren(editor, entry)) {
+                            return;
+                        }
+                    }
+                }
+                normalizeNode(entry);
+            };
+            return editor;
+        },
+    };
 }
 
 exports.IMAGE_TYPES = IMAGE_TYPES;

package/image/isHostingNotRequired.js

@@ -1,5 +1,5 @@
-function isHostingNotRequired(src) {
-    return /^https?:\/\/.*/.test(src) || src.startsWith('data:image');
+function isHostingNotRequired(src) {
+    return /^https?:\/\/.*/.test(src) || src.startsWith('data:image');
 }
 
 export { isHostingNotRequired };

package/image/typings.d.ts

@@ -1,8 +1,8 @@
 import { Editor, QuadratsElement, GetAboveByTypesOptions, Location, NodeEntry, Text, Withable, WithElementType } from '@quadrats/core';
-export declare type ImageFigureTypeKey = 'figure';
-export declare type ImageTypeKey = 'image';
-export declare type ImageCaptionTypeKey = 'caption';
-export declare type ImageTypes = Record<ImageFigureTypeKey | ImageTypeKey | ImageCaptionTypeKey, string>;
+export type ImageFigureTypeKey = 'figure';
+export type ImageTypeKey = 'image';
+export type ImageCaptionTypeKey = 'caption';
+export type ImageTypes = Record<ImageFigureTypeKey | ImageTypeKey | ImageCaptionTypeKey, string>;
 export interface ImageFigureElement extends QuadratsElement, WithElementType {
     width?: number;
 }
@@ -30,13 +30,13 @@ export interface ImageCaptionElement extends QuadratsElement, WithElementType {
  *   foo: src => `https://foo.storage/${src}`
  * };
  */
-export declare type ImageHostingResolvers<Hosting extends string> = Record<Hosting, (url: string) => string>;
+export type ImageHostingResolvers<Hosting extends string> = Record<Hosting, (url: string) => string>;
 /**
  * Only sizes included in steps are valid image size.
  */
-export declare type ImageSizeSteps = ReadonlyArray<number>;
-export declare type ImageGetAboveImageFigureOptions = GetAboveByTypesOptions;
-export declare type ImageGetAboveImageCaptionOptions = GetAboveByTypesOptions;
+export type ImageSizeSteps = ReadonlyArray<number>;
+export type ImageGetAboveImageFigureOptions = GetAboveByTypesOptions;
+export type ImageGetAboveImageCaptionOptions = GetAboveByTypesOptions;
 export interface Image<Hosting extends string, T extends Editor = Editor> extends Withable {
     /**
      * An object which keys are `figure`, `image`, 'caption` and values are the corresponding element types.

package/input-block/createInputBlock.js

@@ -1,43 +1,43 @@
 import { Editor, Path, Transforms } from '@quadrats/core';
 import { INPUT_BLOCK_TYPE } from './constants.js';
 
-function createInputBlock(options = {}) {
-    const { type = INPUT_BLOCK_TYPE } = options;
-    const start = (editor, inputConfig) => {
-        const inputBlock = Object.assign(Object.assign({}, inputConfig), { type, children: [{ text: '' }] });
-        Editor.insertNode(editor, inputBlock);
-    };
-    /**
-     * Set selection to end of previous path.
-     */
-    const remove = (editor, [, path], focus) => {
-        const previousPath = Path.previous(path);
-        const previousEndPath = Editor.end(editor, previousPath);
-        Transforms.select(editor, previousEndPath);
-        focus();
-        Transforms.removeNodes(editor, { at: path });
-    };
-    const confirm = (element, value, remove) => {
-        remove();
-        element.confirm(value);
-    };
-    return {
-        type,
-        start,
-        remove,
-        confirm,
-        with(editor) {
-            const { isVoid } = editor;
-            editor.isVoid = (element) => {
-                // invalidate unfinished input_block from storage
-                if (element.type === type
-                    && typeof element.getPlaceholder !== 'function')
-                    return false;
-                return element.type === type || isVoid(element);
-            };
-            return editor;
-        },
-    };
+function createInputBlock(options = {}) {
+    const { type = INPUT_BLOCK_TYPE } = options;
+    const start = (editor, inputConfig) => {
+        const inputBlock = Object.assign(Object.assign({}, inputConfig), { type, children: [{ text: '' }] });
+        Editor.insertNode(editor, inputBlock);
+    };
+    /**
+     * Set selection to end of previous path.
+     */
+    const remove = (editor, [, path], focus) => {
+        const previousPath = Path.previous(path);
+        const previousEndPath = Editor.end(editor, previousPath);
+        Transforms.select(editor, previousEndPath);
+        focus();
+        Transforms.removeNodes(editor, { at: path });
+    };
+    const confirm = (element, value, remove) => {
+        remove();
+        element.confirm(value);
+    };
+    return {
+        type,
+        start,
+        remove,
+        confirm,
+        with(editor) {
+            const { isVoid } = editor;
+            editor.isVoid = (element) => {
+                // invalidate unfinished input_block from storage
+                if (element.type === type
+                    && typeof element.getPlaceholder !== 'function')
+                    return false;
+                return element.type === type || isVoid(element);
+            };
+            return editor;
+        },
+    };
 }
 
 export { createInputBlock };

package/input-block/index.cjs.js

@@ -1,48 +1,46 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
 var core = require('@quadrats/core');
 
 const INPUT_BLOCK_TYPE = 'input_block';
 
-function createInputBlock(options = {}) {
-    const { type = INPUT_BLOCK_TYPE } = options;
-    const start = (editor, inputConfig) => {
-        const inputBlock = Object.assign(Object.assign({}, inputConfig), { type, children: [{ text: '' }] });
-        core.Editor.insertNode(editor, inputBlock);
-    };
-    /**
-     * Set selection to end of previous path.
-     */
-    const remove = (editor, [, path], focus) => {
-        const previousPath = core.Path.previous(path);
-        const previousEndPath = core.Editor.end(editor, previousPath);
-        core.Transforms.select(editor, previousEndPath);
-        focus();
-        core.Transforms.removeNodes(editor, { at: path });
-    };
-    const confirm = (element, value, remove) => {
-        remove();
-        element.confirm(value);
-    };
-    return {
-        type,
-        start,
-        remove,
-        confirm,
-        with(editor) {
-            const { isVoid } = editor;
-            editor.isVoid = (element) => {
-                // invalidate unfinished input_block from storage
-                if (element.type === type
-                    && typeof element.getPlaceholder !== 'function')
-                    return false;
-                return element.type === type || isVoid(element);
-            };
-            return editor;
-        },
-    };
+function createInputBlock(options = {}) {
+    const { type = INPUT_BLOCK_TYPE } = options;
+    const start = (editor, inputConfig) => {
+        const inputBlock = Object.assign(Object.assign({}, inputConfig), { type, children: [{ text: '' }] });
+        core.Editor.insertNode(editor, inputBlock);
+    };
+    /**
+     * Set selection to end of previous path.
+     */
+    const remove = (editor, [, path], focus) => {
+        const previousPath = core.Path.previous(path);
+        const previousEndPath = core.Editor.end(editor, previousPath);
+        core.Transforms.select(editor, previousEndPath);
+        focus();
+        core.Transforms.removeNodes(editor, { at: path });
+    };
+    const confirm = (element, value, remove) => {
+        remove();
+        element.confirm(value);
+    };
+    return {
+        type,
+        start,
+        remove,
+        confirm,
+        with(editor) {
+            const { isVoid } = editor;
+            editor.isVoid = (element) => {
+                // invalidate unfinished input_block from storage
+                if (element.type === type
+                    && typeof element.getPlaceholder !== 'function')
+                    return false;
+                return element.type === type || isVoid(element);
+            };
+            return editor;
+        },
+    };
 }
 
 exports.INPUT_BLOCK_TYPE = INPUT_BLOCK_TYPE;

package/input-widget/typings.d.ts

@@ -13,4 +13,4 @@ export interface InputWidgetConfig {
     confirm(value: string): void;
     defaultValue?: string;
 }
-export declare type SetInputWidgetConfig = (value: InputWidgetConfig | null) => void;
+export type SetInputWidgetConfig = (value: InputWidgetConfig | null) => void;