@quadrats/common 0.7.3 → 1.0.0

package/accordion/constants.d.ts

@@ -0,0 +1,5 @@
+import { AccordionTypes } from './typings';
+export declare const ACCORDION_TYPE = "accordion";
+export declare const ACCORDION_TITLE_TYPE = "accordion-title";
+export declare const ACCORDION_CONTENT_TYPE = "accordion-content";
+export declare const ACCORDION_TYPES: AccordionTypes;

package/accordion/constants.js

@@ -0,0 +1,10 @@
+const ACCORDION_TYPE = 'accordion';
+const ACCORDION_TITLE_TYPE = 'accordion-title';
+const ACCORDION_CONTENT_TYPE = 'accordion-content';
+const ACCORDION_TYPES = {
+    accordion: ACCORDION_TYPE,
+    accordion_title: ACCORDION_TITLE_TYPE,
+    accordion_content: ACCORDION_CONTENT_TYPE,
+};
+
+export { ACCORDION_CONTENT_TYPE, ACCORDION_TITLE_TYPE, ACCORDION_TYPE, ACCORDION_TYPES };

package/accordion/createAccordion.d.ts

@@ -0,0 +1,6 @@
+import { Editor } from '@quadrats/core';
+import { Accordion, AccordionTypes } from './typings';
+export interface CreateAccordionOptions {
+    types?: Partial<AccordionTypes>;
+}
+export declare function createAccordion(options?: CreateAccordionOptions): Accordion<Editor>;

package/accordion/createAccordion.js

@@ -0,0 +1,62 @@
+import { isNodesTypeIn, Element, Node, Transforms, Text, Editor } from '@quadrats/core';
+import { ACCORDION_TYPES } from './constants.js';
+
+function createAccordion(options = {}) {
+    const { types: typesOptions } = options;
+    const types = Object.assign(Object.assign({}, ACCORDION_TYPES), typesOptions);
+    const createAccordionElement = () => ({
+        type: types.accordion,
+        children: [
+            { type: types.accordion_title, children: [{ text: '' }] },
+            { type: types.accordion_content, children: [{ text: '' }] },
+        ],
+    });
+    const isSelectionInAccordionTitle = editor => isNodesTypeIn(editor, [types.accordion_title]);
+    const isSelectionInAccordionContent = editor => isNodesTypeIn(editor, [types.accordion_content]);
+    const insertAccordion = (editor) => {
+        Transforms.insertNodes(editor, createAccordionElement());
+    };
+    return {
+        types,
+        createAccordionElement,
+        isSelectionInAccordionTitle,
+        isSelectionInAccordionContent,
+        insertAccordion,
+        with(editor) {
+            editor.normalizeNode = (entry) => {
+                const [node, path] = entry;
+                if (Element.isElement(node)) {
+                    const type = node.type;
+                    if (type === types.accordion) {
+                        for (const [child, childPath] of Node.children(editor, path)) {
+                            if (Element.isElement(child) && child.type === types.accordion) {
+                                Transforms.removeNodes(editor, { at: childPath });
+                                return;
+                            }
+                        }
+                        if (!isNodesTypeIn(editor, [types.accordion_content], { at: path })) {
+                            Transforms.removeNodes(editor, { at: path });
+                            return;
+                        }
+                    }
+                    else if (type === types.accordion_title || type === types.accordion_content) {
+                        if (node.children.length !== 1 || !Text.isText(node.children[0])) {
+                            const mergedText = node.children.map(child => Node.string(child)).join('');
+                            const mergedElement = {
+                                type,
+                                children: [{ text: mergedText }],
+                            };
+                            Transforms.removeNodes(editor, { at: path });
+                            Transforms.insertNodes(editor, mergedElement, { at: path });
+                            Transforms.select(editor, Editor.end(editor, path));
+                            return;
+                        }
+                    }
+                }
+            };
+            return editor;
+        },
+    };
+}
+
+export { createAccordion };

package/accordion/index.cjs.js

@@ -0,0 +1,76 @@
+'use strict';
+
+var core = require('@quadrats/core');
+
+const ACCORDION_TYPE = 'accordion';
+const ACCORDION_TITLE_TYPE = 'accordion-title';
+const ACCORDION_CONTENT_TYPE = 'accordion-content';
+const ACCORDION_TYPES = {
+    accordion: ACCORDION_TYPE,
+    accordion_title: ACCORDION_TITLE_TYPE,
+    accordion_content: ACCORDION_CONTENT_TYPE,
+};
+
+function createAccordion(options = {}) {
+    const { types: typesOptions } = options;
+    const types = Object.assign(Object.assign({}, ACCORDION_TYPES), typesOptions);
+    const createAccordionElement = () => ({
+        type: types.accordion,
+        children: [
+            { type: types.accordion_title, children: [{ text: '' }] },
+            { type: types.accordion_content, children: [{ text: '' }] },
+        ],
+    });
+    const isSelectionInAccordionTitle = editor => core.isNodesTypeIn(editor, [types.accordion_title]);
+    const isSelectionInAccordionContent = editor => core.isNodesTypeIn(editor, [types.accordion_content]);
+    const insertAccordion = (editor) => {
+        core.Transforms.insertNodes(editor, createAccordionElement());
+    };
+    return {
+        types,
+        createAccordionElement,
+        isSelectionInAccordionTitle,
+        isSelectionInAccordionContent,
+        insertAccordion,
+        with(editor) {
+            editor.normalizeNode = (entry) => {
+                const [node, path] = entry;
+                if (core.Element.isElement(node)) {
+                    const type = node.type;
+                    if (type === types.accordion) {
+                        for (const [child, childPath] of core.Node.children(editor, path)) {
+                            if (core.Element.isElement(child) && child.type === types.accordion) {
+                                core.Transforms.removeNodes(editor, { at: childPath });
+                                return;
+                            }
+                        }
+                        if (!core.isNodesTypeIn(editor, [types.accordion_content], { at: path })) {
+                            core.Transforms.removeNodes(editor, { at: path });
+                            return;
+                        }
+                    }
+                    else if (type === types.accordion_title || type === types.accordion_content) {
+                        if (node.children.length !== 1 || !core.Text.isText(node.children[0])) {
+                            const mergedText = node.children.map(child => core.Node.string(child)).join('');
+                            const mergedElement = {
+                                type,
+                                children: [{ text: mergedText }],
+                            };
+                            core.Transforms.removeNodes(editor, { at: path });
+                            core.Transforms.insertNodes(editor, mergedElement, { at: path });
+                            core.Transforms.select(editor, core.Editor.end(editor, path));
+                            return;
+                        }
+                    }
+                }
+            };
+            return editor;
+        },
+    };
+}
+
+exports.ACCORDION_CONTENT_TYPE = ACCORDION_CONTENT_TYPE;
+exports.ACCORDION_TITLE_TYPE = ACCORDION_TITLE_TYPE;
+exports.ACCORDION_TYPE = ACCORDION_TYPE;
+exports.ACCORDION_TYPES = ACCORDION_TYPES;
+exports.createAccordion = createAccordion;

package/accordion/index.d.ts

@@ -0,0 +1,3 @@
+export * from './typings';
+export * from './constants';
+export { CreateAccordionOptions, createAccordion } from './createAccordion';

package/accordion/index.js

@@ -0,0 +1,2 @@
+export { ACCORDION_CONTENT_TYPE, ACCORDION_TITLE_TYPE, ACCORDION_TYPE, ACCORDION_TYPES } from './constants.js';
+export { createAccordion } from './createAccordion.js';

package/accordion/package.json

@@ -0,0 +1,7 @@
+{
+  "name": "@quadrats/common/accordion",
+  "sideEffects": false,
+  "main": "./index.cjs.js",
+  "module": "./index.js",
+  "typings": "./index.d.ts"
+}

package/accordion/typings.d.ts

@@ -0,0 +1,18 @@
+import { Editor, QuadratsElement, Text, Withable, WithElementType } from '@quadrats/core';
+export type AccordionTypeKey = 'accordion';
+export type AccordionTitleTypeKey = 'accordion_title';
+export type AccordionContentTypeKey = 'accordion_content';
+export type AccordionTypes = Record<AccordionTypeKey | AccordionTitleTypeKey | AccordionContentTypeKey, string>;
+export interface AccordionElement extends QuadratsElement, WithElementType {
+    children: {
+        type: string;
+        children: [Text];
+    }[];
+}
+export interface Accordion<T extends Editor = Editor> extends Withable {
+    types: AccordionTypes;
+    createAccordionElement(): AccordionElement;
+    isSelectionInAccordionTitle(editor: T): boolean;
+    isSelectionInAccordionContent(editor: T): boolean;
+    insertAccordion(editor: T): void;
+}

package/align/constants.d.ts

@@ -0,0 +1 @@
+export declare const ALIGN_TYPE = "align";

package/align/constants.js

@@ -0,0 +1,3 @@
+const ALIGN_TYPE = 'align';
+
+export { ALIGN_TYPE };

package/align/createAlign.d.ts

@@ -0,0 +1,9 @@
+import { Editor } from '@quadrats/core';
+import { AlignValue } from './typings';
+export interface Align<E extends Editor = Editor> {
+    type: string;
+    isAlignActive: (editor: E, value: AlignValue) => boolean;
+    setAlign: (editor: E, value: AlignValue) => void;
+    removeAlign: (editor: E) => void;
+}
+export declare function createAlign(): Align;

package/align/createAlign.js

@@ -0,0 +1,41 @@
+import { Transforms, Element, PARAGRAPH_TYPE, Editor } from '@quadrats/core';
+import { HEADING_TYPE } from '@quadrats/common/heading';
+import { ALIGN_TYPE } from './constants.js';
+
+const ALIGNABLE_TYPES = [PARAGRAPH_TYPE, HEADING_TYPE];
+function createAlign() {
+    const type = ALIGN_TYPE;
+    return {
+        type,
+        isAlignActive: (editor, value) => {
+            const { selection } = editor;
+            if (!selection)
+                return false;
+            const [match] = Editor.nodes(editor, {
+                match: (n) => !!(Element.isElement(n) &&
+                    n.type &&
+                    ALIGNABLE_TYPES.includes(n.type)),
+            });
+            if (!match)
+                return false;
+            const [node] = match;
+            return node[type] === value;
+        },
+        setAlign: (editor, value) => {
+            Transforms.setNodes(editor, { [type]: value }, {
+                match: (n) => !!(Element.isElement(n) &&
+                    n.type &&
+                    ALIGNABLE_TYPES.includes(n.type)),
+            });
+        },
+        removeAlign: (editor) => {
+            Transforms.unsetNodes(editor, [type], {
+                match: (n) => !!(Element.isElement(n) &&
+                    n.type &&
+                    ALIGNABLE_TYPES.includes(n.type)),
+            });
+        },
+    };
+}
+
+export { createAlign };

package/align/index.cjs.js

@@ -0,0 +1,45 @@
+'use strict';
+
+var core = require('@quadrats/core');
+var heading = require('@quadrats/common/heading');
+
+const ALIGN_TYPE = 'align';
+
+const ALIGNABLE_TYPES = [core.PARAGRAPH_TYPE, heading.HEADING_TYPE];
+function createAlign() {
+    const type = ALIGN_TYPE;
+    return {
+        type,
+        isAlignActive: (editor, value) => {
+            const { selection } = editor;
+            if (!selection)
+                return false;
+            const [match] = core.Editor.nodes(editor, {
+                match: (n) => !!(core.Element.isElement(n) &&
+                    n.type &&
+                    ALIGNABLE_TYPES.includes(n.type)),
+            });
+            if (!match)
+                return false;
+            const [node] = match;
+            return node[type] === value;
+        },
+        setAlign: (editor, value) => {
+            core.Transforms.setNodes(editor, { [type]: value }, {
+                match: (n) => !!(core.Element.isElement(n) &&
+                    n.type &&
+                    ALIGNABLE_TYPES.includes(n.type)),
+            });
+        },
+        removeAlign: (editor) => {
+            core.Transforms.unsetNodes(editor, [type], {
+                match: (n) => !!(core.Element.isElement(n) &&
+                    n.type &&
+                    ALIGNABLE_TYPES.includes(n.type)),
+            });
+        },
+    };
+}
+
+exports.ALIGN_TYPE = ALIGN_TYPE;
+exports.createAlign = createAlign;

package/align/index.d.ts

@@ -0,0 +1,3 @@
+export * from './typings';
+export * from './constants';
+export { createAlign, Align } from './createAlign';

package/align/index.js

@@ -0,0 +1,2 @@
+export { ALIGN_TYPE } from './constants.js';
+export { createAlign } from './createAlign.js';

package/align/package.json

@@ -0,0 +1,7 @@
+{
+  "name": "@quadrats/common/align",
+  "sideEffects": false,
+  "main": "./index.cjs.js",
+  "module": "./index.js",
+  "typings": "./index.d.ts"
+}

package/align/typings.d.ts

@@ -0,0 +1 @@
+export type AlignValue = 'left' | 'center' | 'right';

package/blockquote/createBlockquote.js

@@ -1,4 +1,4 @@
-import { unwrapNodesByTypes, wrapNodesWithUnhangRange, isNodesTypeIn } from '@quadrats/core';
+import { isNodesTypeIn, wrapNodesWithUnhangRange, unwrapNodesByTypes } from '@quadrats/core';
 import { BLOCKQUOTE_TYPE } from './constants.js';
 
 function createBlockquote({ type = BLOCKQUOTE_TYPE } = {}) {

package/bold/createBold.d.ts

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

package/card/constants.d.ts

@@ -0,0 +1,6 @@
+import { CardTypes } from './typings';
+export declare const CARD_TYPE = "card";
+export declare const CARD_IMAGE_TYPE = "card_image";
+export declare const CARD_CONTENTS_TYPE = "card_contents";
+export declare const CARD_PLACEHOLDER_TYPE = "card_placeholder";
+export declare const CARD_TYPES: CardTypes;

package/card/constants.js

@@ -0,0 +1,11 @@
+const CARD_TYPE = 'card';
+const CARD_IMAGE_TYPE = 'card_image';
+const CARD_CONTENTS_TYPE = 'card_contents';
+const CARD_PLACEHOLDER_TYPE = 'card_placeholder';
+const CARD_TYPES = {
+    card: CARD_TYPE,
+    card_image: CARD_IMAGE_TYPE,
+    card_contents: CARD_CONTENTS_TYPE,
+};
+
+export { CARD_CONTENTS_TYPE, CARD_IMAGE_TYPE, CARD_PLACEHOLDER_TYPE, CARD_TYPE, CARD_TYPES };

package/card/createCard.d.ts

@@ -0,0 +1,15 @@
+import { Editor } from '@quadrats/core';
+import { ImageAccept, FileUploaderGetBody, FileUploaderGetHeaders, FileUploaderGetUrl, FileUploaderImplement } from '@quadrats/common/file-uploader';
+import { Card, CardTypes } from './typings';
+export interface CreateCardOptions {
+    types?: Partial<CardTypes>;
+    accept?: ImageAccept[];
+    ratio?: [number, number];
+    limitSize?: number;
+    confirmModal?: boolean;
+    getBody: FileUploaderGetBody;
+    getHeaders?: FileUploaderGetHeaders;
+    getUrl: FileUploaderGetUrl;
+    uploader?: FileUploaderImplement;
+}
+export declare function createCard(options: CreateCardOptions): Card<Editor>;

package/card/createCard.js

@@ -0,0 +1,147 @@
+import { Element, Node, Transforms, Editor, createParagraphElement } from '@quadrats/core';
+import { CARD_TYPES, CARD_PLACEHOLDER_TYPE } from './constants.js';
+
+function createCard(options) {
+    const { types: typesOptions, accept: acceptOptions, ratio, limitSize: limitSizeOptions, confirmModal = true, getBody, getHeaders, getUrl, uploader, } = options;
+    const types = Object.assign(Object.assign({}, CARD_TYPES), typesOptions);
+    const limitSize = limitSizeOptions || 5;
+    const accept = acceptOptions || ['image/jpeg', 'image/jpg', 'image/png'];
+    const insertCardPlaceholder = (editor) => {
+        const cardPlaceholderElement = {
+            type: CARD_PLACEHOLDER_TYPE,
+            ratio,
+            children: [{ text: '' }],
+        };
+        Editor.withoutNormalizing(editor, () => {
+            Transforms.insertNodes(editor, cardPlaceholderElement);
+        });
+    };
+    const removeCardPlaceholder = (editor) => {
+        Transforms.removeNodes(editor, {
+            match: (node) => Element.isElement(node) && node.type === CARD_PLACEHOLDER_TYPE,
+        });
+    };
+    const createCardElement = (cardValues) => {
+        var _a;
+        const cardImageElement = {
+            type: types.card_image,
+            src: ((_a = cardValues.imageItem) === null || _a === void 0 ? void 0 : _a.url) || '',
+            ratio,
+            children: [{ text: '' }],
+        };
+        const cardContentsElement = {
+            type: types.card_contents,
+            children: [{ text: '' }],
+            alignment: cardValues.alignment,
+            title: cardValues.title,
+            description: cardValues.description,
+            remark: cardValues.remark,
+            haveLink: cardValues.haveLink,
+            linkText: cardValues.linkText,
+            linkUrl: cardValues.linkUrl,
+        };
+        return Object.assign(Object.assign({ type: types.card, confirmModal }, cardValues), { children: [cardImageElement, cardContentsElement] });
+    };
+    const insertCard = ({ editor, cardValues }) => {
+        Transforms.insertNodes(editor, [createCardElement(cardValues), createParagraphElement()]);
+    };
+    const updateCardElement = ({ editor, cardValues, path }) => {
+        var _a;
+        Transforms.setNodes(editor, cardValues, { at: path });
+        const imageEntries = Editor.nodes(editor, {
+            at: path,
+            match: (node) => Element.isElement(node) && node.type === types.card_image,
+            mode: 'all',
+        });
+        const imageNode = imageEntries.next().value;
+        const contentsEntries = Editor.nodes(editor, {
+            at: path,
+            match: (node) => Element.isElement(node) && node.type === types.card_contents,
+            mode: 'all',
+        });
+        const contentsNode = contentsEntries.next().value;
+        if (imageNode) {
+            const [, imagePath] = imageNode;
+            Transforms.setNodes(editor, { src: ((_a = cardValues.imageItem) === null || _a === void 0 ? void 0 : _a.url) || '' }, { at: imagePath });
+        }
+        if (contentsNode) {
+            const [, contentsPath] = contentsNode;
+            Transforms.setNodes(editor, {
+                alignment: cardValues.alignment,
+                title: cardValues.title,
+                description: cardValues.description,
+                remark: cardValues.remark,
+                haveLink: cardValues.haveLink,
+                linkText: cardValues.linkText,
+                linkUrl: cardValues.linkUrl,
+            }, {
+                at: contentsPath,
+            });
+        }
+    };
+    const updateCardAlignment = ({ editor, alignment, path }) => {
+        Transforms.setNodes(editor, { alignment }, { at: path });
+        const contentsEntries = Editor.nodes(editor, {
+            at: path,
+            match: (node) => Element.isElement(node) && node.type === types.card_contents,
+            mode: 'all',
+        });
+        const contentsNode = contentsEntries.next().value;
+        if (contentsNode) {
+            const [, contentsPath] = contentsNode;
+            Transforms.setNodes(editor, {
+                alignment,
+            }, {
+                at: contentsPath,
+            });
+        }
+    };
+    return {
+        types,
+        createCardElement,
+        insertCard,
+        updateCardElement,
+        updateCardAlignment,
+        accept,
+        ratio,
+        limitSize,
+        confirmModal,
+        insertCardPlaceholder,
+        removeCardPlaceholder,
+        getBody,
+        getHeaders,
+        getUrl,
+        uploader,
+        with(editor) {
+            const { normalizeNode } = editor;
+            editor.normalizeNode = (entry) => {
+                const [node, path] = entry;
+                if (Element.isElement(node)) {
+                    const type = node.type;
+                    if (type === types.card) {
+                        for (const [child, childPath] of Node.children(editor, path)) {
+                            if (Element.isElement(child) &&
+                                child.type !== types.card_contents &&
+                                child.type !== types.card_image) {
+                                Transforms.removeNodes(editor, { at: childPath });
+                                return;
+                            }
+                        }
+                    }
+                    else if (type === types.card_contents || type === types.card_image) {
+                        for (const [child, childPath] of Node.children(editor, path)) {
+                            if (Element.isElement(child)) {
+                                Transforms.removeNodes(editor, { at: childPath });
+                                return;
+                            }
+                        }
+                    }
+                }
+                normalizeNode(entry);
+            };
+            return editor;
+        },
+    };
+}
+
+export { createCard };

package/card/getFilesFromInput.d.ts

@@ -0,0 +1,4 @@
+import { ImageAccept } from '@quadrats/common/file-uploader';
+export declare function getFilesFromInput(options: {
+    accept: ImageAccept[];
+}): Promise<File[] | undefined>;