@quadrats/common 0.1.0 → 0.4.0

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, parentType }?: import("@quadrats/common/toggle-mark").CreateToggleMarkOptions | undefined) => import("@quadrats/common/toggle-mark").ToggleMark;

package/bold/createBold.js

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

package/bold/index.cjs.js

@@ -3,11 +3,13 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var toggleMark = require('@quadrats/common/toggle-mark');
+var core = require('@quadrats/core');
 
 const BOLD_TYPE = 'bold';
 
-const createBold = toggleMark.createToggleMarkCreator({
-    type: BOLD_TYPE,
+const createBold = (variant) => toggleMark.createToggleMarkCreator({
+    type: core.getVariantType(BOLD_TYPE, variant),
+    parentType: BOLD_TYPE,
 });
 
 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/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,79 @@
+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 getAllFootnotes = (editor) => {
+        const resultNodes = getNodes(editor, {
+            at: [],
+            match: (node) => node.type === FOOTNOTE_TYPE,
+        });
+        return Array.from(resultNodes);
+    };
+    const getFootnoteText = (editor) => {
+        var _a, _b, _c;
+        const at = editor.selection;
+        if (!at) {
+            return '';
+        }
+        const nodes = getNodes(editor, { at, match: (node) => node.type === type });
+        return (_c = (_b = (_a = Array.from(nodes)) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b[0]) === 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,
+        getAllFootnotes,
+        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,85 @@
+'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 getAllFootnotes = (editor) => {
+        const resultNodes = core.getNodes(editor, {
+            at: [],
+            match: (node) => node.type === FOOTNOTE_TYPE,
+        });
+        return Array.from(resultNodes);
+    };
+    const getFootnoteText = (editor) => {
+        var _a, _b, _c;
+        const at = editor.selection;
+        if (!at) {
+            return '';
+        }
+        const nodes = core.getNodes(editor, { at, match: (node) => node.type === type });
+        return (_c = (_b = (_a = Array.from(nodes)) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b[0]) === 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,
+        getAllFootnotes,
+        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,24 @@
+import { Editor, Range, Element, WithElementType, UnwrapNodeByTypesOptions, TransformsWrapNodesOptions, Withable, NodeEntry, Node } from '@quadrats/core';
+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 {
+    getAllFootnotes(editor: Editor): NodeEntry<Node>[];
+    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, parentType }?: import("@quadrats/common/toggle-mark").CreateToggleMarkOptions | undefined) => import("@quadrats/common/toggle-mark").ToggleMark;

package/highlight/createHighlight.js

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

package/highlight/index.cjs.js

@@ -3,11 +3,13 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var toggleMark = require('@quadrats/common/toggle-mark');
+var core = require('@quadrats/core');
 
 const HIGHLIGHT_TYPE = 'highlight';
 
-const createHighlight = toggleMark.createToggleMarkCreator({
-    type: HIGHLIGHT_TYPE,
+const createHighlight = (variant) => toggleMark.createToggleMarkCreator({
+    type: core.getVariantType(HIGHLIGHT_TYPE, variant),
+    parentType: HIGHLIGHT_TYPE,
 });
 
 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;

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, parentType }?: import("@quadrats/common/toggle-mark").CreateToggleMarkOptions | undefined) => import("@quadrats/common/toggle-mark").ToggleMark;

package/italic/createItalic.js

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

package/italic/index.cjs.js

@@ -3,11 +3,13 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var toggleMark = require('@quadrats/common/toggle-mark');
+var core = require('@quadrats/core');
 
 const ITALIC_TYPE = 'italic';
 
-const createItalic = toggleMark.createToggleMarkCreator({
-    type: ITALIC_TYPE,
+const createItalic = (variant) => toggleMark.createToggleMarkCreator({
+    type: core.getVariantType(ITALIC_TYPE, variant),
+    parentType: ITALIC_TYPE,
 });
 
 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 { LINK_TYPE } from './constants.js';
 
 function createLink({ type = LINK_TYPE, isUrl: isUrl$1 = isUrl, prevUrlToLinkAfterSpaceEntered = true, wrappableVoidTypes, } = {}) {
     const getFirstPrevTextAsUrlAndRange = (editor, at) => {

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.1.0",
+  "version": "0.4.0",
   "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.1.0",
-    "@quadrats/locales": "^0.1.0",
-    "@quadrats/utils": "^0.1.0"
+    "@quadrats/core": "^0.4.0",
+    "@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, parentType }?: import("@quadrats/common/toggle-mark").CreateToggleMarkOptions | undefined) => import("@quadrats/common/toggle-mark").ToggleMark;

package/strikethrough/createStrikethrough.js

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

package/strikethrough/index.cjs.js

@@ -3,11 +3,13 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var toggleMark = require('@quadrats/common/toggle-mark');
+var core = require('@quadrats/core');
 
 const STRIKETHROUGH_TYPE = 'strikethrough';
 
-const createStrikethrough = toggleMark.createToggleMarkCreator({
-    type: STRIKETHROUGH_TYPE,
+const createStrikethrough = (variant) => toggleMark.createToggleMarkCreator({
+    type: core.getVariantType(STRIKETHROUGH_TYPE, variant),
+    parentType: STRIKETHROUGH_TYPE,
 });
 
 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 & {
+    parentType?: string;
+};
+export declare type CreateToggleMarkOptions = Partial<CreateToggleMarkCreatorOptions> & {
+    parentType?: string;
+};
+export declare function createToggleMarkCreator(defaults: CreateToggleMarkCreatorOptions): ({ type, parentType }?: CreateToggleMarkOptions) => ToggleMark;

package/toggle-mark/createToggleMarkCreator.js

@@ -1,7 +1,7 @@
-import { getMark } from '@quadrats/core';
+import { getMark, marksGroupBy } from '@quadrats/core';
 
 function createToggleMarkCreator(defaults) {
-    return ({ type = defaults.type } = {}) => {
+    return ({ type = defaults.type, parentType = defaults.parentType } = {}) => {
         const isToggleMarkActive = (editor) => {
             const mark = getMark(editor, type);
             return mark === true;
@@ -12,6 +12,15 @@ function createToggleMarkCreator(defaults) {
                 editor.removeMark(type);
             }
             else {
+                if (parentType) {
+                    marksGroupBy(editor, (_mark) => {
+                        if (_mark.match(parentType)) {
+                            editor.removeMark(_mark);
+                            return true;
+                        }
+                        return false;
+                    });
+                }
                 editor.addMark(type, true);
             }
         };

package/toggle-mark/index.cjs.js

@@ -5,7 +5,7 @@ Object.defineProperty(exports, '__esModule', { value: true });
 var core = require('@quadrats/core');
 
 function createToggleMarkCreator(defaults) {
-    return ({ type = defaults.type } = {}) => {
+    return ({ type = defaults.type, parentType = defaults.parentType } = {}) => {
         const isToggleMarkActive = (editor) => {
             const mark = core.getMark(editor, type);
             return mark === true;
@@ -16,6 +16,15 @@ function createToggleMarkCreator(defaults) {
                 editor.removeMark(type);
             }
             else {
+                if (parentType) {
+                    core.marksGroupBy(editor, (_mark) => {
+                        if (_mark.match(parentType)) {
+                            editor.removeMark(_mark);
+                            return true;
+                        }
+                        return false;
+                    });
+                }
                 editor.addMark(type, true);
             }
         };

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, parentType }?: import("@quadrats/common/toggle-mark").CreateToggleMarkOptions | undefined) => import("@quadrats/common/toggle-mark").ToggleMark;

package/underline/createUnderline.js

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

package/underline/index.cjs.js

@@ -3,11 +3,13 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var toggleMark = require('@quadrats/common/toggle-mark');
+var core = require('@quadrats/core');
 
 const UNDERLINE_TYPE = 'underline';
 
-const createUnderline = toggleMark.createToggleMarkCreator({
-    type: UNDERLINE_TYPE,
+const createUnderline = (variant) => toggleMark.createToggleMarkCreator({
+    type: core.getVariantType(UNDERLINE_TYPE, variant),
+    parentType: UNDERLINE_TYPE,
 });
 
 exports.UNDERLINE_TYPE = UNDERLINE_TYPE;