@quadrats/common 0.6.7 → 0.7.0

package/image/createImage.js

@@ -1,201 +1,201 @@
 import { isImageUrl } from '@quadrats/utils';
-import { getAboveByTypes, Editor, Transforms, createParagraphElement, Element, isNodesTypeIn, normalizeVoidElementChildren, normalizeOnlyInlineOrTextInChildren, Range } from '@quadrats/core';
+import { Editor, Transforms, createParagraphElement, Element, normalizeVoidElementChildren, normalizeOnlyInlineOrTextInChildren, getAboveByTypes, isNodesTypeIn, Range } from '@quadrats/core';
 import { IMAGE_TYPES } from './constants.js';
 
-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: isImageUrl$1 = isImageUrl, } = options;
-    const types = Object.assign(Object.assign({}, IMAGE_TYPES), typesOptions);
-    const sizeSteps = unresolvedSizeSteps && resolveSizeSteps(unresolvedSizeSteps);
-    const getAboveImageFigure = (editor, options) => getAboveByTypes(editor, [types.figure], options);
-    const getAboveImageCaption = (editor, options) => getAboveByTypes(editor, [types.caption], options);
-    const isNodesInImage = (editor, options) => isNodesTypeIn(editor, [types.image], options);
-    const isSelectionInImage = editor => isNodesInImage(editor);
-    const isSelectionInImageCaption = editor => isNodesTypeIn(editor, [types.caption]);
-    const isCollapsedOnImage = editor => !!editor.selection && Range.isCollapsed(editor.selection) && isSelectionInImage(editor);
-    const previousNodeIsCaption = (editor) => {
-        const previous = Editor.previous(editor);
-        if (!previous)
-            return false;
-        const [, previousLocation] = previous;
-        const previousWrapper = 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);
-        Transforms.insertNodes(editor, [imageElement, 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 });
-                Transforms.setNodes(editor, resizedElement, {
-                    at: figurePath,
-                });
-            }
-        }
-    };
-    return {
-        types,
-        hostingResolvers,
-        sizeSteps,
-        isImageUrl: isImageUrl$1,
-        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 && Range.isCollapsed(selection)) {
-                    const [, captionPath] = getAboveImageCaption(editor) || [];
-                    if ((captionPath && Editor[isEdgeMethodName](editor, selection.focus, captionPath))) {
-                        return;
-                    }
-                    // Remove image element when backwards from external
-                    if (!captionPath && previousNodeIsCaption(editor)) {
-                        const previous = Editor.previous(editor);
-                        if (!previous)
-                            return false;
-                        const [, previousLocation] = previous;
-                        const previousWrapper = Editor.parent(editor, previousLocation);
-                        if (!previousWrapper)
-                            return false;
-                        const [previousWrapperNode, wrapperLocation] = previousWrapper;
-                        if (previousWrapperNode.type === types.caption) {
-                            const imageContainer = Editor.parent(editor, wrapperLocation);
-                            if (imageContainer) {
-                                const [imageElement, imageLocation] = imageContainer;
-                                if (imageElement.type === types.figure) {
-                                    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 = Editor.parent(editor, captionLocation);
-                    if (imageEntry) {
-                        const [imageElement, imagePosition] = imageEntry;
-                        if (imageElement.type === types.figure) {
-                            Transforms.insertNodes(editor, createParagraphElement(), { at: Editor.after(editor, imagePosition) });
-                            Transforms.move(editor);
-                        }
-                    }
-                    return;
-                }
-                insertBreak();
-            };
-            editor.isVoid = element => element.type === types.image || isVoid(element);
-            editor.normalizeNode = (entry) => {
-                const [node, path] = entry;
-                if (Element.isElement(node)) {
-                    if (node.type === types.figure) {
-                        if (!isNodesInImage(editor, { at: path })) {
-                            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) {
-                                Transforms.removeNodes(editor, { at: figurePath });
-                                return;
-                            }
-                        }
-                        if (normalizeVoidElementChildren(editor, [node, path])) {
-                            return;
-                        }
-                    }
-                    else if (node.type === types.caption) {
-                        if (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: isImageUrl$1 = isImageUrl, } = options;
+    const types = Object.assign(Object.assign({}, IMAGE_TYPES), typesOptions);
+    const sizeSteps = unresolvedSizeSteps && resolveSizeSteps(unresolvedSizeSteps);
+    const getAboveImageFigure = (editor, options) => getAboveByTypes(editor, [types.figure], options);
+    const getAboveImageCaption = (editor, options) => getAboveByTypes(editor, [types.caption], options);
+    const isNodesInImage = (editor, options) => isNodesTypeIn(editor, [types.image], options);
+    const isSelectionInImage = editor => isNodesInImage(editor);
+    const isSelectionInImageCaption = editor => isNodesTypeIn(editor, [types.caption]);
+    const isCollapsedOnImage = editor => !!editor.selection && Range.isCollapsed(editor.selection) && isSelectionInImage(editor);
+    const previousNodeIsCaption = (editor) => {
+        const previous = Editor.previous(editor);
+        if (!previous)
+            return false;
+        const [, previousLocation] = previous;
+        const previousWrapper = 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);
+        Transforms.insertNodes(editor, [imageElement, 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 });
+                Transforms.setNodes(editor, resizedElement, {
+                    at: figurePath,
+                });
+            }
+        }
+    };
+    return {
+        types,
+        hostingResolvers,
+        sizeSteps,
+        isImageUrl: isImageUrl$1,
+        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 && Range.isCollapsed(selection)) {
+                    const [, captionPath] = getAboveImageCaption(editor) || [];
+                    if ((captionPath && Editor[isEdgeMethodName](editor, selection.focus, captionPath))) {
+                        return;
+                    }
+                    // Remove image element when backwards from external
+                    if (!captionPath && previousNodeIsCaption(editor)) {
+                        const previous = Editor.previous(editor);
+                        if (!previous)
+                            return false;
+                        const [, previousLocation] = previous;
+                        const previousWrapper = Editor.parent(editor, previousLocation);
+                        if (!previousWrapper)
+                            return false;
+                        const [previousWrapperNode, wrapperLocation] = previousWrapper;
+                        if (previousWrapperNode.type === types.caption) {
+                            const imageContainer = Editor.parent(editor, wrapperLocation);
+                            if (imageContainer) {
+                                const [imageElement, imageLocation] = imageContainer;
+                                if (imageElement.type === types.figure) {
+                                    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 = Editor.parent(editor, captionLocation);
+                    if (imageEntry) {
+                        const [imageElement, imagePosition] = imageEntry;
+                        if (imageElement.type === types.figure) {
+                            Transforms.insertNodes(editor, createParagraphElement(), { at: Editor.after(editor, imagePosition) });
+                            Transforms.move(editor);
+                        }
+                    }
+                    return;
+                }
+                insertBreak();
+            };
+            editor.isVoid = element => element.type === types.image || isVoid(element);
+            editor.normalizeNode = (entry) => {
+                const [node, path] = entry;
+                if (Element.isElement(node)) {
+                    if (node.type === types.figure) {
+                        if (!isNodesInImage(editor, { at: path })) {
+                            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) {
+                                Transforms.removeNodes(editor, { at: figurePath });
+                                return;
+                            }
+                        }
+                        if (normalizeVoidElementChildren(editor, [node, path])) {
+                            return;
+                        }
+                    }
+                    else if (node.type === types.caption) {
+                        if (normalizeOnlyInlineOrTextInChildren(editor, entry)) {
+                            return;
+                        }
+                    }
+                }
+                normalizeNode(entry);
+            };
+            return editor;
+        },
+    };
 }
 
 export { createImage };

package/image/getImageElementCommonProps.js

@@ -1,11 +1,11 @@
 import { isHostingNotRequired } from './isHostingNotRequired.js';
 
-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,
+    };
 }
 
 export { getImageElementCommonProps };

package/image/getImageFigureElementCommonProps.js

@@ -1,8 +1,8 @@
-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,
+    };
 }
 
 export { getImageFigureElementCommonProps };