@quadrats/common 0.1.0 → 0.5.1

package/blockquote/createBlockquote.js

@@ -1,11 +1,11 @@
-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 {
         type,
-        isSelectionInBlockquote: (editor) => isNodesTypeIn(editor, [type]),
-        toggleBlockquote: (editor) => toggleNodesType(editor, type),
+        isSelectionInBlockquote: editor => isNodesTypeIn(editor, [type]),
+        toggleBlockquote: editor => toggleNodesType(editor, type),
         with(editor) {
             const { normalizeNode } = editor;
             editor.normalizeNode = (entry) => {

package/blockquote/index.cjs.js

@@ -9,8 +9,8 @@ const BLOCKQUOTE_TYPE = 'blockquote';
 function createBlockquote({ type = BLOCKQUOTE_TYPE } = {}) {
     return {
         type,
-        isSelectionInBlockquote: (editor) => core.isNodesTypeIn(editor, [type]),
-        toggleBlockquote: (editor) => core.toggleNodesType(editor, type),
+        isSelectionInBlockquote: editor => core.isNodesTypeIn(editor, [type]),
+        toggleBlockquote: editor => core.toggleNodesType(editor, type),
         with(editor) {
             const { normalizeNode } = editor;
             editor.normalizeNode = (entry) => {

package/blockquote/typings.d.ts

@@ -1,5 +1,5 @@
-import { Editor, Element, Withable, WithElementType } from '@quadrats/core';
-export interface BlockquoteElement extends Element, WithElementType {
+import { Editor, QuadratsElement, Withable, WithElementType } from '@quadrats/core';
+export interface BlockquoteElement extends QuadratsElement, WithElementType {
 }
 export interface Blockquote extends WithElementType, Withable {
     isSelectionInBlockquote(editor: Editor): boolean;

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;
@@ -14,7 +14,7 @@ function createDivider(options = {}) {
         insertDivider,
         with(editor) {
             const { isVoid, normalizeNode } = editor;
-            editor.isVoid = (element) => element.type === type || isVoid(element);
+            editor.isVoid = element => element.type === type || isVoid(element);
             editor.normalizeNode = (entry) => {
                 const [node, path] = entry;
                 /**

package/divider/index.cjs.js

@@ -19,7 +19,7 @@ function createDivider(options = {}) {
         insertDivider,
         with(editor) {
             const { isVoid, normalizeNode } = editor;
-            editor.isVoid = (element) => element.type === type || isVoid(element);
+            editor.isVoid = element => element.type === type || isVoid(element);
             editor.normalizeNode = (entry) => {
                 const [node, path] = entry;
                 /**

package/divider/typings.d.ts

@@ -1,5 +1,5 @@
-import { Editor, Element, Text, Withable, WithElementType } from '@quadrats/core';
-export interface DividerElement extends Element, WithElementType {
+import { Editor, QuadratsElement, Text, Withable, WithElementType } from '@quadrats/core';
+export interface DividerElement extends QuadratsElement, WithElementType {
     children: [Text];
 }
 export interface Divider extends WithElementType, Withable {

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;
@@ -11,7 +11,8 @@ function createEmbed(options) {
             const embedElement = Object.assign(Object.assign({}, data), { type, provider, children: [{ text: '' }] });
             Transforms.insertNodes(editor, [
                 embedElement,
-                typeof defaultNode === 'string' ? { type: defaultNode, children: [{ text: '' }] } : defaultNode,
+                typeof defaultNode === 'string'
+                    ? { type: defaultNode, children: [{ text: '' }] } : defaultNode,
             ]);
             Transforms.move(editor);
         }
@@ -22,11 +23,12 @@ function createEmbed(options) {
         insertEmbed,
         with(editor) {
             const { isVoid, normalizeNode } = editor;
-            editor.isVoid = (element) => element.type === type || isVoid(element);
+            editor.isVoid = element => element.type === type || isVoid(element);
             editor.normalizeNode = (entry) => {
                 const [node, path] = entry;
                 if (Element.isElement(node) && node.type === type) {
-                    const strategy = node.provider ? strategies[node.provider] : undefined;
+                    const strategy = node.provider
+                        ? strategies[node.provider] : undefined;
                     if (!strategy || !strategy.isElementDataValid(node)) {
                         Transforms.removeNodes(editor, { at: path });
                         return;

package/embed/index.cjs.js

@@ -33,7 +33,8 @@ function createEmbed(options) {
             const embedElement = Object.assign(Object.assign({}, data), { type, provider, children: [{ text: '' }] });
             core.Transforms.insertNodes(editor, [
                 embedElement,
-                typeof defaultNode === 'string' ? { type: defaultNode, children: [{ text: '' }] } : defaultNode,
+                typeof defaultNode === 'string'
+                    ? { type: defaultNode, children: [{ text: '' }] } : defaultNode,
             ]);
             core.Transforms.move(editor);
         }
@@ -44,11 +45,12 @@ function createEmbed(options) {
         insertEmbed,
         with(editor) {
             const { isVoid, normalizeNode } = editor;
-            editor.isVoid = (element) => element.type === type || isVoid(element);
+            editor.isVoid = element => element.type === type || isVoid(element);
             editor.normalizeNode = (entry) => {
                 const [node, path] = entry;
                 if (core.Element.isElement(node) && node.type === type) {
-                    const strategy = node.provider ? strategies[node.provider] : undefined;
+                    const strategy = node.provider
+                        ? strategies[node.provider] : undefined;
                     if (!strategy || !strategy.isElementDataValid(node)) {
                         core.Transforms.removeNodes(editor, { at: path });
                         return;

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/typings.d.ts

@@ -1,5 +1,5 @@
-import { Editor, Element, Node, Text, Withable, WithElementType } from '@quadrats/core';
-export interface EmbedElement extends Element, WithElementType {
+import { Editor, QuadratsElement, Node, Text, Withable, WithElementType } from '@quadrats/core';
+export interface EmbedElement extends QuadratsElement, WithElementType {
     /**
      * The embed provider.
      *

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 { 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;
@@ -25,10 +25,8 @@ function createFileUploader(options = {}) {
                     if (xhr.status < 400) {
                         const path = getPath();
                         if (path) {
-                            HistoryEditor.withoutSaving(editor, () => {
-                                Transforms.removeNodes(editor, { at: path });
-                                Transforms.insertNodes(editor, createElementByResponse(xhr.response), { at: path });
-                            });
+                            Transforms.removeNodes(editor, { at: path });
+                            Transforms.insertNodes(editor, createElementByResponse(xhr.response), { at: path });
                         }
                     }
                     else {
@@ -65,10 +63,8 @@ function createFileUploader(options = {}) {
             yield prev;
             return createFileUploaderElement(editor, file, options).then((fileUploaderElement) => {
                 if (fileUploaderElement) {
-                    HistoryEditor.withoutSaving(editor, () => {
-                        Transforms.insertNodes(editor, [fileUploaderElement, createParagraphElement()], options);
-                        Transforms.move(editor);
-                    });
+                    Transforms.insertNodes(editor, [fileUploaderElement, createParagraphElement()], options);
+                    Transforms.move(editor);
                 }
             });
         }), Promise.resolve());

package/file-uploader/index.cjs.js

@@ -79,10 +79,8 @@ function createFileUploader(options = {}) {
                     if (xhr.status < 400) {
                         const path = getPath();
                         if (path) {
-                            core.HistoryEditor.withoutSaving(editor, () => {
-                                core.Transforms.removeNodes(editor, { at: path });
-                                core.Transforms.insertNodes(editor, createElementByResponse(xhr.response), { at: path });
-                            });
+                            core.Transforms.removeNodes(editor, { at: path });
+                            core.Transforms.insertNodes(editor, createElementByResponse(xhr.response), { at: path });
                         }
                     }
                     else {
@@ -119,10 +117,8 @@ function createFileUploader(options = {}) {
             yield prev;
             return createFileUploaderElement(editor, file, options).then((fileUploaderElement) => {
                 if (fileUploaderElement) {
-                    core.HistoryEditor.withoutSaving(editor, () => {
-                        core.Transforms.insertNodes(editor, [fileUploaderElement, core.createParagraphElement()], options);
-                        core.Transforms.move(editor);
-                    });
+                    core.Transforms.insertNodes(editor, [fileUploaderElement, core.createParagraphElement()], options);
+                    core.Transforms.move(editor);
                 }
             });
         }), Promise.resolve());

package/file-uploader/typings.d.ts

@@ -1,20 +1,20 @@
-import { Editor, Element, HistoryEditor, Path, TransformsInsertNodesOptions, Withable } from '@quadrats/core';
+import { Editor, QuadratsElement, Path, TransformsInsertNodesOptions, Withable } from '@quadrats/core';
 import { GetFilesFromInputOptions } from './getFilesFromInput';
 export interface XHRUploadHeaders {
     [name: string]: string;
 }
-export interface FileUploaderElement extends Element {
+export interface FileUploaderElement extends QuadratsElement {
     type: string;
     register: (getPath: () => Path | undefined, onProgress: (percentage: number) => void) => VoidFunction;
 }
 /**
  * For creating temorary element while uploading.
  */
-export declare type FileUploaderCreateElementByDataURL = (dataURL: string) => Element;
+export declare type FileUploaderCreateElementByDataURL = (dataURL: string) => QuadratsElement;
 /**
  * For create element after uploaded.
  */
-export declare type FileUploaderCreateElementByResponse = (response: any) => Element;
+export declare type FileUploaderCreateElementByResponse = (response: any) => QuadratsElement;
 export declare type FileUploaderGetBody = (file: File) => BodyInit;
 export declare type FileUploaderGetHeaders = (file: File) => XHRUploadHeaders | Promise<XHRUploadHeaders>;
 export declare type FileUploaderGetUrl = (file: File) => string;
@@ -32,6 +32,6 @@ export interface FileUploaderCreateFileUploaderElementOptions {
 export declare type FileUploaderUploadOptions = FileUploaderCreateFileUploaderElementOptions & GetFilesFromInputOptions & TransformsInsertNodesOptions;
 export interface FileUploader extends Withable {
     type: string;
-    createFileUploaderElement(editor: Editor & HistoryEditor, file: File, options: FileUploaderCreateFileUploaderElementOptions): Promise<FileUploaderElement | undefined>;
-    upload(editor: Editor & HistoryEditor, options: FileUploaderUploadOptions): Promise<void>;
+    createFileUploaderElement(editor: Editor, file: File, options: FileUploaderCreateFileUploaderElementOptions): Promise<FileUploaderElement | undefined>;
+    upload(editor: Editor, options: FileUploaderUploadOptions): Promise<void>;
 }

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, QuadratsElement, WithElementType, UnwrapNodeByTypesOptions, TransformsWrapNodesOptions, Withable } from '@quadrats/core';
+export interface FootnoteData {
+    footnote: string;
+    index: number;
+    wrapperText: string;
+}
+export interface FootnoteElement extends QuadratsElement, 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,8 +1,8 @@
-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 }));
+    const getHeadingNodes = (editor, level, options = {}) => getNodes(editor, Object.assign(Object.assign({}, options), { match: node => node.type === type && node.level === level }));
     const isSelectionInHeading = (editor, level, options = {}) => {
         const [match] = getHeadingNodes(editor, level, options);
         return !!match;

package/heading/index.cjs.js

@@ -8,7 +8,7 @@ const HEADING_TYPE = 'heading';
 const HEADING_LEVELS = [1, 2, 3, 4, 5, 6];
 
 function createHeading({ type = HEADING_TYPE, enabledLevels = HEADING_LEVELS, } = {}) {
-    const getHeadingNodes = (editor, level, options = {}) => core.getNodes(editor, Object.assign(Object.assign({}, options), { match: (node) => node.type === type && node.level === level }));
+    const getHeadingNodes = (editor, level, options = {}) => core.getNodes(editor, Object.assign(Object.assign({}, options), { match: node => node.type === type && node.level === level }));
     const isSelectionInHeading = (editor, level, options = {}) => {
         const [match] = getHeadingNodes(editor, level, options);
         return !!match;

package/heading/typings.d.ts

@@ -1,6 +1,6 @@
-import { Editor, Element, GetNodesOptions, Node, NodeEntry, Withable, WithElementType } from '@quadrats/core';
+import { Editor, QuadratsElement, GetNodesOptions, Node, NodeEntry, Withable, WithElementType } from '@quadrats/core';
 export declare type HeadingLevel = 1 | 2 | 3 | 4 | 5 | 6;
-export interface HeadingElement extends Element, WithElementType {
+export interface HeadingElement extends QuadratsElement, WithElementType {
     level: HeadingLevel;
 }
 export interface WithEnabledHeadingLevels<L extends HeadingLevel> {