@quadrats/common 0.0.2 → 0.4.5

package/blockquote/createBlockquote.js

@@ -1,5 +1,5 @@
-import { BLOCKQUOTE_TYPE } from './constants.js';
 import { isNodesTypeIn, toggleNodesType, Element, normalizeOnlyInlineOrTextInChildren } from '@quadrats/core';
+import { BLOCKQUOTE_TYPE } from './constants.js';
 
 function createBlockquote({ type = BLOCKQUOTE_TYPE } = {}) {
     return {

package/bold/createBold.d.ts

@@ -1 +1 @@
-export declare const createBold: ({ type }?: Partial<import("@quadrats/core").WithMarkType> | undefined) => import("@quadrats/common/toggle-mark").ToggleMark;
+export declare const createBold: (variant?: string | undefined) => ({ type, variant }?: import("@quadrats/common/toggle-mark").CreateToggleMarkOptions | undefined) => import("@quadrats/common/toggle-mark").ToggleMark;

package/bold/createBold.js

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

package/bold/index.cjs.js

@@ -6,8 +6,9 @@ var toggleMark = require('@quadrats/common/toggle-mark');
 
 const BOLD_TYPE = 'bold';
 
-const createBold = toggleMark.createToggleMarkCreator({
+const createBold = (variant) => toggleMark.createToggleMarkCreator({
     type: BOLD_TYPE,
+    variant,
 });
 
 exports.BOLD_TYPE = BOLD_TYPE;

package/divider/createDivider.js

@@ -1,5 +1,5 @@
-import { DIVIDER_TYPE } from './constants.js';
 import { Element, normalizeVoidElementChildren, Transforms, createParagraphElement } from '@quadrats/core';
+import { DIVIDER_TYPE } from './constants.js';
 
 function createDivider(options = {}) {
     const { type = DIVIDER_TYPE } = options;

package/embed/createEmbed.js

@@ -1,6 +1,6 @@
+import { Element, Transforms, normalizeVoidElementChildren, PARAGRAPH_TYPE } from '@quadrats/core';
 import { EMBED_TYPE } from './constants.js';
 import { serializeEmbedCode } from './serializeEmbedCode.js';
-import { Element, Transforms, normalizeVoidElementChildren, PARAGRAPH_TYPE } from '@quadrats/core';
 
 function createEmbed(options) {
     const { type = EMBED_TYPE, strategies } = options;

package/embed/strategies/podcast-apple/index.cjs.js

@@ -0,0 +1,22 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+// eslint-disable-next-line @typescript-eslint/no-redeclare
+const PodcastAppleEmbedStrategy = {
+    serialize: (embedCode) => {
+        var _a, _b;
+        const result = (_b = (_a = /^https:\/\/embed.podcasts.apple.com\/[\w-]*\/podcast\/[\S]*\/id([\d]*)/i.exec(embedCode)) !== null && _a !== void 0 ? _a : /^https:\/\/embed.podcasts.apple.com\/[\w-]*\/podcast\/id([\d]*)/i.exec(embedCode)) !== null && _b !== void 0 ? _b : /^https:\/\/podcasts.apple.com\/[\w-]*\/podcast\/[\S]*\/id([\d]*)/i.exec(embedCode);
+        if (result) {
+            const [, contextId] = result;
+            return {
+                embedType: 'podcast-apple',
+                contextId,
+            };
+        }
+    },
+    deserialize: (data) => `https://embed.podcasts.apple.com/us/podcast/id${data.contextId}`,
+    isElementDataValid: (data) => typeof data.contextId === 'string' && !!(data.contextId),
+};
+
+exports.PodcastAppleEmbedStrategy = PodcastAppleEmbedStrategy;

package/embed/strategies/podcast-apple/index.d.ts

@@ -0,0 +1,9 @@
+import { EmbedElement, EmbedStrategy } from '@quadrats/common/embed';
+export declare type PodcastAppleEmbedType = 'podcast-apple';
+export declare type PodcastAppleEmbedElementData = {
+    embedType: PodcastAppleEmbedType;
+    contextId: string;
+};
+export declare type PodcastAppleEmbedElement = EmbedElement & PodcastAppleEmbedElementData;
+export declare type PodcastAppleEmbedStrategy = EmbedStrategy<PodcastAppleEmbedElementData, string>;
+export declare const PodcastAppleEmbedStrategy: PodcastAppleEmbedStrategy;

package/embed/strategies/podcast-apple/index.js

@@ -0,0 +1,18 @@
+// eslint-disable-next-line @typescript-eslint/no-redeclare
+const PodcastAppleEmbedStrategy = {
+    serialize: (embedCode) => {
+        var _a, _b;
+        const result = (_b = (_a = /^https:\/\/embed.podcasts.apple.com\/[\w-]*\/podcast\/[\S]*\/id([\d]*)/i.exec(embedCode)) !== null && _a !== void 0 ? _a : /^https:\/\/embed.podcasts.apple.com\/[\w-]*\/podcast\/id([\d]*)/i.exec(embedCode)) !== null && _b !== void 0 ? _b : /^https:\/\/podcasts.apple.com\/[\w-]*\/podcast\/[\S]*\/id([\d]*)/i.exec(embedCode);
+        if (result) {
+            const [, contextId] = result;
+            return {
+                embedType: 'podcast-apple',
+                contextId,
+            };
+        }
+    },
+    deserialize: (data) => `https://embed.podcasts.apple.com/us/podcast/id${data.contextId}`,
+    isElementDataValid: (data) => typeof data.contextId === 'string' && !!(data.contextId),
+};
+
+export { PodcastAppleEmbedStrategy };

package/embed/strategies/podcast-apple/package.json

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

package/embed/strategies/spotify/index.cjs.js

@@ -0,0 +1,21 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+// eslint-disable-next-line @typescript-eslint/no-redeclare
+const SpotifyEmbedStrategy = {
+    serialize: (embedCode) => {
+        const result = /^https:\/\/open.spotify.com\/([\S]*)/i.exec(embedCode);
+        if (result) {
+            const [, contextId] = result;
+            return {
+                embedType: 'spotify',
+                contextId,
+            };
+        }
+    },
+    deserialize: (data) => `https://open.spotify.com/embed/${data.contextId}?utm_source=generator`,
+    isElementDataValid: (data) => typeof data.contextId === 'string' && !!(data.contextId),
+};
+
+exports.SpotifyEmbedStrategy = SpotifyEmbedStrategy;

package/embed/strategies/spotify/index.d.ts

@@ -0,0 +1,9 @@
+import { EmbedElement, EmbedStrategy } from '@quadrats/common/embed';
+export declare type SpotifyEmbedType = 'spotify';
+export declare type SpotifyEmbedElementData = {
+    embedType: SpotifyEmbedType;
+    contextId: string;
+};
+export declare type SpotifyEmbedElement = EmbedElement & SpotifyEmbedElementData;
+export declare type SpotifyEmbedStrategy = EmbedStrategy<SpotifyEmbedElementData, string>;
+export declare const SpotifyEmbedStrategy: SpotifyEmbedStrategy;

package/embed/strategies/spotify/index.js

@@ -0,0 +1,17 @@
+// eslint-disable-next-line @typescript-eslint/no-redeclare
+const SpotifyEmbedStrategy = {
+    serialize: (embedCode) => {
+        const result = /^https:\/\/open.spotify.com\/([\S]*)/i.exec(embedCode);
+        if (result) {
+            const [, contextId] = result;
+            return {
+                embedType: 'spotify',
+                contextId,
+            };
+        }
+    },
+    deserialize: (data) => `https://open.spotify.com/embed/${data.contextId}?utm_source=generator`,
+    isElementDataValid: (data) => typeof data.contextId === 'string' && !!(data.contextId),
+};
+
+export { SpotifyEmbedStrategy };

package/embed/strategies/spotify/package.json

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

package/embed/strategies/twitter/index.cjs.js

@@ -3,13 +3,12 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 function getTwitterTweetDataFromUrl(url) {
-    const result = /^https:\/\/twitter.com\/([\w]*)\/status\/([\w-]*)/i.exec(url);
+    const result = /^https:\/\/twitter.com\/[\w]*\/status\/([\w-]*)/i.exec(url);
     if (result) {
-        const [, account, hash] = result;
+        const [, tweetId] = result;
         return {
             embedType: 'tweet',
-            account,
-            hash,
+            tweetId,
         };
     }
 }
@@ -31,15 +30,16 @@ const TwitterEmbedStrategy = {
         const getter = embedCode.startsWith('<blockquote') ? getTwitterTweetDataFromBlockquote : getTwitterTweetDataFromUrl;
         return getter(embedCode);
     },
-    deserialize: ({ embedType, account, hash }) => {
-        if (embedType === 'tweet') {
-            return `https://www.twitter.com/${account}/status/${hash}`;
+    deserialize: (data) => {
+        if (data.embedType === 'tweet') {
+            return data.tweetId;
         }
         return '';
     },
-    isElementDataValid: ({ embedType, account, hash }) => {
-        if (embedType === 'tweet') {
-            return typeof account === 'string' && typeof hash === 'string';
+    isElementDataValid: (data) => {
+        if (data.embedType === 'tweet') {
+            const { tweetId } = data;
+            return typeof tweetId === 'string' && !!tweetId;
         }
         return true;
     },

package/embed/strategies/twitter/index.d.ts

@@ -2,8 +2,7 @@ import { EmbedElement, EmbedStrategy } from '@quadrats/common/embed';
 export declare type TwitterEmbedType = 'tweet';
 export declare type TwitterEmbedElementData = {
     embedType: TwitterEmbedType;
-    account: string;
-    hash?: string;
+    tweetId: string;
 };
 export declare type TwitterEmbedElement = EmbedElement & TwitterEmbedElementData;
 export declare type TwitterEmbedStrategy = EmbedStrategy<TwitterEmbedElementData, string>;

package/embed/strategies/twitter/index.js

@@ -1,11 +1,10 @@
 function getTwitterTweetDataFromUrl(url) {
-    const result = /^https:\/\/twitter.com\/([\w]*)\/status\/([\w-]*)/i.exec(url);
+    const result = /^https:\/\/twitter.com\/[\w]*\/status\/([\w-]*)/i.exec(url);
     if (result) {
-        const [, account, hash] = result;
+        const [, tweetId] = result;
         return {
             embedType: 'tweet',
-            account,
-            hash,
+            tweetId,
         };
     }
 }
@@ -27,15 +26,16 @@ const TwitterEmbedStrategy = {
         const getter = embedCode.startsWith('<blockquote') ? getTwitterTweetDataFromBlockquote : getTwitterTweetDataFromUrl;
         return getter(embedCode);
     },
-    deserialize: ({ embedType, account, hash }) => {
-        if (embedType === 'tweet') {
-            return `https://www.twitter.com/${account}/status/${hash}`;
+    deserialize: (data) => {
+        if (data.embedType === 'tweet') {
+            return data.tweetId;
         }
         return '';
     },
-    isElementDataValid: ({ embedType, account, hash }) => {
-        if (embedType === 'tweet') {
-            return typeof account === 'string' && typeof hash === 'string';
+    isElementDataValid: (data) => {
+        if (data.embedType === 'tweet') {
+            const { tweetId } = data;
+            return typeof tweetId === 'string' && !!tweetId;
         }
         return true;
     },

package/file-uploader/createFileUploader.js

@@ -1,8 +1,8 @@
-import { FILE_UPLOADER_TYPE } from './constants.js';
-import { getFilesFromInput } from './getFilesFromInput.js';
 import { __awaiter } from './_virtual/_tslib.js';
 import { readFileAsDataURL } from '@quadrats/utils';
 import { HistoryEditor, Transforms, createParagraphElement } from '@quadrats/core';
+import { FILE_UPLOADER_TYPE } from './constants.js';
+import { getFilesFromInput } from './getFilesFromInput.js';
 
 function createFileUploader(options = {}) {
     const { type = FILE_UPLOADER_TYPE } = options;

package/footnote/constants.d.ts

@@ -0,0 +1 @@
+export declare const FOOTNOTE_TYPE = "footnote";

package/footnote/constants.js

@@ -0,0 +1,3 @@
+const FOOTNOTE_TYPE = 'footnote';
+
+export { FOOTNOTE_TYPE };

package/footnote/createFootnote.d.ts

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

package/footnote/createFootnote.js

@@ -0,0 +1,71 @@
+import { isNodesTypeIn, getNodes, Transforms, unwrapNodesByTypes, wrapNodesWithUnhangRange } from '@quadrats/core';
+import { FOOTNOTE_TYPE } from './constants.js';
+
+/* eslint-disable max-len */
+function createFootnote({ type = FOOTNOTE_TYPE, } = {}) {
+    const isSelectionInFootnote = (editor) => isNodesTypeIn(editor, [type]);
+    const getFootnoteText = (editor) => {
+        var _a, _b, _c;
+        const at = editor.selection;
+        if (!at) {
+            return '';
+        }
+        const firstNode = (_b = (_a = Array.from(getNodes(editor, { at, match: (node) => node.type === type }))) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b[0];
+        return (_c = firstNode) === null || _c === void 0 ? void 0 : _c.footnote;
+    };
+    const updateFootnoteIndex = (editor, options = { startAt: 1 }) => {
+        var _a;
+        let footnoteCount = (_a = options === null || options === void 0 ? void 0 : options.startAt) !== null && _a !== void 0 ? _a : 1;
+        for (const [, path] of getNodes(editor, { at: [], match: (node) => node.type === FOOTNOTE_TYPE })) {
+            Transforms.setNodes(editor, { index: footnoteCount }, { at: path });
+            footnoteCount += 1;
+        }
+    };
+    const unwrapFootnote = (editor, options = {}) => {
+        unwrapNodesByTypes(editor, [type], options);
+    };
+    const wrapFootnote = (editor, footnoteText, options = {}) => {
+        var _a;
+        const footnote = {
+            type,
+            footnote: footnoteText,
+            index: (_a = options === null || options === void 0 ? void 0 : options.index) !== null && _a !== void 0 ? _a : 0,
+            children: [],
+        };
+        wrapNodesWithUnhangRange(editor, footnote, Object.assign(Object.assign({}, options), { split: true }));
+    };
+    const upsertFootnoteAndUpdateIndex = (editor, footnoteText, options = {}) => {
+        const { at = editor.selection } = options;
+        if (!at) {
+            return;
+        }
+        if (footnoteText !== '') {
+            if (isSelectionInFootnote(editor)) {
+                Transforms.setNodes(editor, { footnote: footnoteText }, { at, match: (node) => node.type === type });
+            }
+            else {
+                wrapFootnote(editor, footnoteText, options);
+            }
+        }
+        else {
+            unwrapFootnote(editor, { at });
+        }
+        updateFootnoteIndex(editor);
+    };
+    return {
+        type,
+        getFootnoteText,
+        isSelectionInFootnote,
+        updateFootnoteIndex,
+        unwrapFootnote,
+        wrapFootnote,
+        upsertFootnoteAndUpdateIndex,
+        with(editor) {
+            const { isInline } = editor;
+            editor.isInline = (element) => element.type === type || isInline(element);
+            return editor;
+        },
+    };
+}
+
+export { createFootnote };

package/footnote/index.cjs.js

@@ -0,0 +1,77 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var core = require('@quadrats/core');
+
+const FOOTNOTE_TYPE = 'footnote';
+
+/* eslint-disable max-len */
+function createFootnote({ type = FOOTNOTE_TYPE, } = {}) {
+    const isSelectionInFootnote = (editor) => core.isNodesTypeIn(editor, [type]);
+    const getFootnoteText = (editor) => {
+        var _a, _b, _c;
+        const at = editor.selection;
+        if (!at) {
+            return '';
+        }
+        const firstNode = (_b = (_a = Array.from(core.getNodes(editor, { at, match: (node) => node.type === type }))) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b[0];
+        return (_c = firstNode) === null || _c === void 0 ? void 0 : _c.footnote;
+    };
+    const updateFootnoteIndex = (editor, options = { startAt: 1 }) => {
+        var _a;
+        let footnoteCount = (_a = options === null || options === void 0 ? void 0 : options.startAt) !== null && _a !== void 0 ? _a : 1;
+        for (const [, path] of core.getNodes(editor, { at: [], match: (node) => node.type === FOOTNOTE_TYPE })) {
+            core.Transforms.setNodes(editor, { index: footnoteCount }, { at: path });
+            footnoteCount += 1;
+        }
+    };
+    const unwrapFootnote = (editor, options = {}) => {
+        core.unwrapNodesByTypes(editor, [type], options);
+    };
+    const wrapFootnote = (editor, footnoteText, options = {}) => {
+        var _a;
+        const footnote = {
+            type,
+            footnote: footnoteText,
+            index: (_a = options === null || options === void 0 ? void 0 : options.index) !== null && _a !== void 0 ? _a : 0,
+            children: [],
+        };
+        core.wrapNodesWithUnhangRange(editor, footnote, Object.assign(Object.assign({}, options), { split: true }));
+    };
+    const upsertFootnoteAndUpdateIndex = (editor, footnoteText, options = {}) => {
+        const { at = editor.selection } = options;
+        if (!at) {
+            return;
+        }
+        if (footnoteText !== '') {
+            if (isSelectionInFootnote(editor)) {
+                core.Transforms.setNodes(editor, { footnote: footnoteText }, { at, match: (node) => node.type === type });
+            }
+            else {
+                wrapFootnote(editor, footnoteText, options);
+            }
+        }
+        else {
+            unwrapFootnote(editor, { at });
+        }
+        updateFootnoteIndex(editor);
+    };
+    return {
+        type,
+        getFootnoteText,
+        isSelectionInFootnote,
+        updateFootnoteIndex,
+        unwrapFootnote,
+        wrapFootnote,
+        upsertFootnoteAndUpdateIndex,
+        with(editor) {
+            const { isInline } = editor;
+            editor.isInline = (element) => element.type === type || isInline(element);
+            return editor;
+        },
+    };
+}
+
+exports.FOOTNOTE_TYPE = FOOTNOTE_TYPE;
+exports.createFootnote = createFootnote;

package/footnote/index.d.ts

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

package/footnote/index.js

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

package/footnote/package.json

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

package/footnote/typings.d.ts

@@ -0,0 +1,28 @@
+import { Editor, Range, Element, WithElementType, UnwrapNodeByTypesOptions, TransformsWrapNodesOptions, Withable } from '@quadrats/core';
+export interface FootnoteData {
+    footnote: string;
+    index: number;
+    wrapperText: string;
+}
+export interface FootnoteElement extends Element, WithElementType {
+    footnote: string;
+    index?: number;
+}
+export interface FootnoteUpdateFootnoteIndexOptions {
+    startAt?: number;
+}
+export declare type FootnoteUnwrapFootnoteOptions = UnwrapNodeByTypesOptions;
+export interface FootnoteWrapFootnoteOptions extends Omit<TransformsWrapNodesOptions, 'split'> {
+    index?: number;
+}
+export interface FootnoteUpsertFootnoteOptions {
+    at?: Range;
+}
+export interface Footnote extends WithElementType, Withable {
+    getFootnoteText(editor: Editor): string;
+    isSelectionInFootnote(editor: Editor): boolean;
+    unwrapFootnote(editor: Editor, options?: FootnoteUnwrapFootnoteOptions): void;
+    updateFootnoteIndex(editor: Editor, options?: FootnoteUpdateFootnoteIndexOptions): void;
+    upsertFootnoteAndUpdateIndex(editor: Editor, footnote: string, options?: FootnoteUpsertFootnoteOptions): void;
+    wrapFootnote(editor: Editor, footnote: string, options?: FootnoteWrapFootnoteOptions): void;
+}

package/heading/createHeading.js

@@ -1,5 +1,5 @@
-import { HEADING_TYPE, HEADING_LEVELS } from './constants.js';
 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 }));

package/highlight/createHighlight.d.ts

@@ -1 +1 @@
-export declare const createHighlight: ({ type }?: Partial<import("@quadrats/core").WithMarkType> | undefined) => import("@quadrats/common/toggle-mark").ToggleMark;
+export declare const createHighlight: (variant?: string | undefined) => ({ type, variant }?: import("@quadrats/common/toggle-mark").CreateToggleMarkOptions | undefined) => import("@quadrats/common/toggle-mark").ToggleMark;

package/highlight/createHighlight.js

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

package/highlight/index.cjs.js

@@ -6,8 +6,9 @@ var toggleMark = require('@quadrats/common/toggle-mark');
 
 const HIGHLIGHT_TYPE = 'highlight';
 
-const createHighlight = toggleMark.createToggleMarkCreator({
+const createHighlight = (variant) => toggleMark.createToggleMarkCreator({
     type: HIGHLIGHT_TYPE,
+    variant,
 });
 
 exports.HIGHLIGHT_TYPE = HIGHLIGHT_TYPE;

package/image/createImage.js

@@ -1,6 +1,6 @@
-import { IMAGE_TYPES } from './constants.js';
 import { isImageUrl } from '@quadrats/utils';
 import { getAboveByTypes, Element, isNodesTypeIn, Transforms, normalizeVoidElementChildren, normalizeOnlyInlineOrTextInChildren, Range, createParagraphElement, Editor } from '@quadrats/core';
+import { IMAGE_TYPES } from './constants.js';
 
 function resolveSizeSteps(steps) {
     let sortedSteps = steps.filter((step) => step > 0 && step < 100).sort();

package/input-block/createInputBlock.js

@@ -1,5 +1,5 @@
-import { INPUT_BLOCK_TYPE } from './constants.js';
 import { Editor, Path, Transforms } from '@quadrats/core';
+import { INPUT_BLOCK_TYPE } from './constants.js';
 
 function createInputBlock(options = {}) {
     const { type = INPUT_BLOCK_TYPE } = options;
@@ -28,7 +28,12 @@ function createInputBlock(options = {}) {
         confirm,
         with(editor) {
             const { isVoid } = editor;
-            editor.isVoid = (element) => element.type === type || isVoid(element);
+            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;
         },
     };

package/input-block/index.cjs.js

@@ -33,7 +33,12 @@ function createInputBlock(options = {}) {
         confirm,
         with(editor) {
             const { isVoid } = editor;
-            editor.isVoid = (element) => element.type === type || isVoid(element);
+            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;
         },
     };

package/input-widget/typings.d.ts

@@ -11,5 +11,6 @@ export interface InputWidgetConfig {
      * Invoked after user confirming the input widget.
      */
     confirm(value: string): void;
+    defaultValue?: string;
 }
 export declare type SetInputWidgetConfig = (value: InputWidgetConfig | null) => void;

package/italic/createItalic.d.ts

@@ -1 +1 @@
-export declare const createItalic: ({ type }?: Partial<import("@quadrats/core").WithMarkType> | undefined) => import("@quadrats/common/toggle-mark").ToggleMark;
+export declare const createItalic: (variant?: string | undefined) => ({ type, variant }?: import("@quadrats/common/toggle-mark").CreateToggleMarkOptions | undefined) => import("@quadrats/common/toggle-mark").ToggleMark;

package/italic/createItalic.js

@@ -1,8 +1,9 @@
-import { ITALIC_TYPE } from './constants.js';
 import { createToggleMarkCreator } from '@quadrats/common/toggle-mark';
+import { ITALIC_TYPE } from './constants.js';
 
-const createItalic = createToggleMarkCreator({
+const createItalic = (variant) => createToggleMarkCreator({
     type: ITALIC_TYPE,
+    variant,
 });
 
 export { createItalic };

package/italic/index.cjs.js

@@ -6,8 +6,9 @@ var toggleMark = require('@quadrats/common/toggle-mark');
 
 const ITALIC_TYPE = 'italic';
 
-const createItalic = toggleMark.createToggleMarkCreator({
+const createItalic = (variant) => toggleMark.createToggleMarkCreator({
     type: ITALIC_TYPE,
+    variant,
 });
 
 exports.ITALIC_TYPE = ITALIC_TYPE;

package/link/createLink.js

@@ -1,6 +1,6 @@
-import { LINK_TYPE } from './constants.js';
 import { isUrl } from '@quadrats/utils';
-import { Range, unwrapNodesByTypes, Editor, Element, Transforms, getRangeBeforeFromAboveBlockStart, getRangeBefore, isNodesTypeIn, wrapNodesWithUnhangRange, Text, getAboveByTypes } from '@quadrats/core';
+import { Range, unwrapNodesByTypes, Editor, Element, Transforms, Text, getRangeBeforeFromAboveBlockStart, getRangeBefore, isNodesTypeIn, wrapNodesWithUnhangRange, getAboveByTypes } from '@quadrats/core';
+import { LINK_TYPE } from './constants.js';
 
 function createLink({ type = LINK_TYPE, isUrl: isUrl$1 = isUrl, prevUrlToLinkAfterSpaceEntered = true, wrappableVoidTypes, } = {}) {
     const getFirstPrevTextAsUrlAndRange = (editor, at) => {
@@ -66,6 +66,9 @@ function createLink({ type = LINK_TYPE, isUrl: isUrl$1 = isUrl, prevUrlToLinkAft
                         unwrapLink(editor, { at: wrappableVoidPath });
                         wrapLink(editor, url, { at: wrappableVoidPath });
                     }
+                    else {
+                        insertLink(editor, url, { at });
+                    }
                     return;
                 }
             }
@@ -129,6 +132,15 @@ function createLink({ type = LINK_TYPE, isUrl: isUrl$1 = isUrl, prevUrlToLinkAft
                         Transforms.unwrapNodes(editor, { at: path });
                         return;
                     }
+                    /**
+                     * Remove empty content.
+                     */
+                    if (Text.isTextList(node.children)) {
+                        if (node.children.every((textNode) => !textNode.text)) {
+                            Transforms.unwrapNodes(editor, { at: path });
+                            return;
+                        }
+                    }
                 }
                 normalizeNode(entry);
             };

package/link/index.cjs.js

@@ -71,6 +71,9 @@ function createLink({ type = LINK_TYPE, isUrl = utils.isUrl, prevUrlToLinkAfterS
                         unwrapLink(editor, { at: wrappableVoidPath });
                         wrapLink(editor, url, { at: wrappableVoidPath });
                     }
+                    else {
+                        insertLink(editor, url, { at });
+                    }
                     return;
                 }
             }
@@ -134,6 +137,15 @@ function createLink({ type = LINK_TYPE, isUrl = utils.isUrl, prevUrlToLinkAfterS
                         core.Transforms.unwrapNodes(editor, { at: path });
                         return;
                     }
+                    /**
+                     * Remove empty content.
+                     */
+                    if (core.Text.isTextList(node.children)) {
+                        if (node.children.every((textNode) => !textNode.text)) {
+                            core.Transforms.unwrapNodes(editor, { at: path });
+                            return;
+                        }
+                    }
                 }
                 normalizeNode(entry);
             };

package/list/createList.js

@@ -1,5 +1,5 @@
-import { LIST_TYPES } from './constants.js';
 import { Range, isSelectionAtBlockEdge, deleteSelectionFragmentIfExpanded, isAboveBlockEmpty, Transforms, isNodesTypeIn, getAboveByTypes, getParent, unwrapNodesByTypes, PARAGRAPH_TYPE, wrapNodesWithUnhangRange, getNodesByTypes, isFirstChild, Editor, Path } from '@quadrats/core';
+import { LIST_TYPES } from './constants.js';
 
 function createList(options = {}) {
     const types = Object.assign(Object.assign({}, LIST_TYPES), options.types);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quadrats/common",
-  "version": "0.0.2",
+  "version": "0.4.5",
   "description": "",
   "author": "Rytass",
   "homepage": "https://github.com/Quadrats/quadrats#readme",
@@ -18,8 +18,8 @@
     "url": "https://github.com/Quadrats/quadrats/issues"
   },
   "dependencies": {
-    "@quadrats/core": "^0.0.2",
-    "@quadrats/locales": "^0.0.2",
-    "@quadrats/utils": "^0.0.2"
+    "@quadrats/core": "^0.4.5",
+    "@quadrats/locales": "^0.4.0",
+    "@quadrats/utils": "^0.4.0"
   }
 }

package/read-more/createReadMore.js

@@ -1,5 +1,5 @@
-import { READ_MORE_TYPE } from './constants.js';
 import { Element, normalizeVoidElementChildren, normalizeOnlyAtRoot, getNodesByTypes, Path, Transforms, deleteSelectionFragmentIfExpanded, createParagraphElement } from '@quadrats/core';
+import { READ_MORE_TYPE } from './constants.js';
 
 function createReadMore(options = {}) {
     const { type = READ_MORE_TYPE } = options;

package/strikethrough/createStrikethrough.d.ts

@@ -1 +1 @@
-export declare const createStrikethrough: ({ type }?: Partial<import("@quadrats/core").WithMarkType> | undefined) => import("@quadrats/common/toggle-mark").ToggleMark;
+export declare const createStrikethrough: (variant?: string | undefined) => ({ type, variant }?: import("@quadrats/common/toggle-mark").CreateToggleMarkOptions | undefined) => import("@quadrats/common/toggle-mark").ToggleMark;

package/strikethrough/createStrikethrough.js

@@ -1,8 +1,9 @@
-import { STRIKETHROUGH_TYPE } from './constants.js';
 import { createToggleMarkCreator } from '@quadrats/common/toggle-mark';
+import { STRIKETHROUGH_TYPE } from './constants.js';
 
-const createStrikethrough = createToggleMarkCreator({
+const createStrikethrough = (variant) => createToggleMarkCreator({
     type: STRIKETHROUGH_TYPE,
+    variant,
 });
 
 export { createStrikethrough };

package/strikethrough/index.cjs.js

@@ -6,8 +6,9 @@ var toggleMark = require('@quadrats/common/toggle-mark');
 
 const STRIKETHROUGH_TYPE = 'strikethrough';
 
-const createStrikethrough = toggleMark.createToggleMarkCreator({
+const createStrikethrough = (variant) => toggleMark.createToggleMarkCreator({
     type: STRIKETHROUGH_TYPE,
+    variant,
 });
 
 exports.STRIKETHROUGH_TYPE = STRIKETHROUGH_TYPE;

package/toggle-mark/createToggleMarkCreator.d.ts

@@ -1,5 +1,9 @@
 import { WithMarkType } from '@quadrats/core';
 import { ToggleMark } from './typings';
-export declare type CreateToggleMarkCreatorOptions = WithMarkType;
-export declare type CreateToggleMarkOptions = Partial<CreateToggleMarkCreatorOptions>;
-export declare function createToggleMarkCreator(defaults: CreateToggleMarkCreatorOptions): ({ type }?: CreateToggleMarkOptions) => ToggleMark;
+export declare type CreateToggleMarkCreatorOptions = WithMarkType & {
+    variant?: string;
+};
+export declare type CreateToggleMarkOptions = Partial<CreateToggleMarkCreatorOptions> & {
+    variant?: string;
+};
+export declare function createToggleMarkCreator(defaults: CreateToggleMarkCreatorOptions): ({ type, variant }?: CreateToggleMarkOptions) => ToggleMark;

package/toggle-mark/createToggleMarkCreator.js

@@ -1,18 +1,33 @@
 import { getMark } from '@quadrats/core';
 
 function createToggleMarkCreator(defaults) {
-    return ({ type = defaults.type } = {}) => {
+    return ({ type = defaults.type, variant = defaults.variant } = {}) => {
         const isToggleMarkActive = (editor) => {
             const mark = getMark(editor, type);
-            return mark === true;
+            if (mark !== true)
+                return false;
+            const nowVariant = getMark(editor, `${type}Variant`) || '';
+            if (variant) {
+                return nowVariant === variant;
+            }
+            return !nowVariant;
         };
         const toggleMark = (editor) => {
             const isActive = isToggleMarkActive(editor);
             if (isActive) {
                 editor.removeMark(type);
+                if (variant) {
+                    editor.removeMark(`${type}Variant`);
+                }
             }
             else {
                 editor.addMark(type, true);
+                if (variant) {
+                    editor.addMark(`${type}Variant`, variant);
+                }
+                else {
+                    editor.removeMark(`${type}Variant`);
+                }
             }
         };
         return {

package/toggle-mark/index.cjs.js

@@ -5,18 +5,33 @@ Object.defineProperty(exports, '__esModule', { value: true });
 var core = require('@quadrats/core');
 
 function createToggleMarkCreator(defaults) {
-    return ({ type = defaults.type } = {}) => {
+    return ({ type = defaults.type, variant = defaults.variant } = {}) => {
         const isToggleMarkActive = (editor) => {
             const mark = core.getMark(editor, type);
-            return mark === true;
+            if (mark !== true)
+                return false;
+            const nowVariant = core.getMark(editor, `${type}Variant`) || '';
+            if (variant) {
+                return nowVariant === variant;
+            }
+            return !nowVariant;
         };
         const toggleMark = (editor) => {
             const isActive = isToggleMarkActive(editor);
             if (isActive) {
                 editor.removeMark(type);
+                if (variant) {
+                    editor.removeMark(`${type}Variant`);
+                }
             }
             else {
                 editor.addMark(type, true);
+                if (variant) {
+                    editor.addMark(`${type}Variant`, variant);
+                }
+                else {
+                    editor.removeMark(`${type}Variant`);
+                }
             }
         };
         return {

package/underline/createUnderline.d.ts

@@ -1 +1 @@
-export declare const createUnderline: ({ type }?: Partial<import("@quadrats/core").WithMarkType> | undefined) => import("@quadrats/common/toggle-mark").ToggleMark;
+export declare const createUnderline: (variant?: string | undefined) => ({ type, variant }?: import("@quadrats/common/toggle-mark").CreateToggleMarkOptions | undefined) => import("@quadrats/common/toggle-mark").ToggleMark;

package/underline/createUnderline.js

@@ -1,8 +1,9 @@
-import { UNDERLINE_TYPE } from './constants.js';
 import { createToggleMarkCreator } from '@quadrats/common/toggle-mark';
+import { UNDERLINE_TYPE } from './constants.js';
 
-const createUnderline = createToggleMarkCreator({
+const createUnderline = (variant) => createToggleMarkCreator({
     type: UNDERLINE_TYPE,
+    variant,
 });
 
 export { createUnderline };

package/underline/index.cjs.js

@@ -6,8 +6,9 @@ var toggleMark = require('@quadrats/common/toggle-mark');
 
 const UNDERLINE_TYPE = 'underline';
 
-const createUnderline = toggleMark.createToggleMarkCreator({
+const createUnderline = (variant) => toggleMark.createToggleMarkCreator({
     type: UNDERLINE_TYPE,
+    variant,
 });
 
 exports.UNDERLINE_TYPE = UNDERLINE_TYPE;