@squiz/formatted-text-editor 0.0.0-rbv2-20240530041851

package/lib/Extensions/FetchUrlExtension/FetchUrlExtension.js

@@ -0,0 +1,63 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FetchUrlExtension = void 0;
+const core_1 = require("@remirror/core");
+const Extensions_1 = require("../Extensions");
+let FetchUrlExtension = class FetchUrlExtension extends core_1.PlainExtension {
+    get name() {
+        return 'fetchUrl';
+    }
+    // Implement the `onView` lifecycle method to scan for `[fetch]` and replace attributes
+    onView(view) {
+        const { state } = view;
+        const { tr } = state;
+        const promises = [];
+        state.doc.descendants((node, pos) => {
+            if (node.type.name === Extensions_1.NodeName.AssetImage && node.attrs.src === '') {
+                promises.push(this.fetchAndReplace(node.attrs, (url) => {
+                    const newNode = state.schema.nodes[Extensions_1.NodeName.AssetImage].create({ ...node.attrs, src: url });
+                    tr.replaceWith(pos, pos + node.nodeSize, newNode);
+                }));
+            }
+            const assetLinkMark = this.findAssetLinkMark(node.marks);
+            if (node.type.name === 'text' && assetLinkMark) {
+                promises.push(this.fetchAndReplace(assetLinkMark.attrs, (url) => {
+                    const updatedMark = assetLinkMark.type.create({ ...assetLinkMark.attrs, href: url });
+                    tr.addMark(pos, pos + node.nodeSize, updatedMark);
+                }));
+            }
+        });
+        if (promises.length) {
+            Promise.all(promises).then(() => {
+                view.dispatch(tr);
+            });
+        }
+    }
+    findAssetLinkMark(marks) {
+        return marks.find((mark) => mark.type.name === Extensions_1.MarkName.AssetLink && mark.attrs.href === '');
+    }
+    fetchAndReplace(nodeAttrs, onFetched) {
+        return this.options
+            .fetchUrl(nodeAttrs)
+            .then((url) => {
+            onFetched(url);
+        })
+            .catch((error) => {
+            console.error('Error fetching URL:', error);
+        });
+    }
+};
+FetchUrlExtension = __decorate([
+    (0, core_1.extension)({
+        defaultOptions: {
+            fetchUrl: () => Promise.resolve(''),
+        },
+    })
+], FetchUrlExtension);
+exports.FetchUrlExtension = FetchUrlExtension;

package/lib/Extensions/ImageExtension/AssetImageExtension.d.ts

@@ -0,0 +1,17 @@
+import { ApplySchemaAttributes, NodeExtension, NodeExtensionSpec, NodeSpecOverride, CommandFunction } from '@remirror/core';
+import { NodeName } from '../Extensions';
+export type AssetImageOptions = {
+    matrixDomain?: string;
+};
+export type AssetImageAttributes = {
+    matrixAssetId: string;
+    matrixIdentifier: string;
+    matrixDomain: string;
+    url: string;
+};
+export declare class AssetImageExtension extends NodeExtension<AssetImageOptions> {
+    get name(): NodeName.AssetImage;
+    createTags(): ("inline" | "media")[];
+    createNodeSpec(extra: ApplySchemaAttributes, override: NodeSpecOverride): NodeExtensionSpec;
+    insertAssetImage(attrs: AssetImageAttributes): CommandFunction;
+}

package/lib/Extensions/ImageExtension/AssetImageExtension.js

@@ -0,0 +1,91 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssetImageExtension = void 0;
+const core_1 = require("@remirror/core");
+const remirror_1 = require("remirror");
+const Extensions_1 = require("../Extensions");
+let AssetImageExtension = class AssetImageExtension extends core_1.NodeExtension {
+    get name() {
+        return Extensions_1.NodeName.AssetImage;
+    }
+    createTags() {
+        return [core_1.ExtensionTag.InlineNode, core_1.ExtensionTag.Media];
+    }
+    createNodeSpec(extra, override) {
+        return {
+            inline: true,
+            draggable: true,
+            selectable: true,
+            ...override,
+            attrs: {
+                ...extra.defaults(),
+                matrixAssetId: {},
+                matrixIdentifier: {},
+                matrixDomain: { default: this.options.matrixDomain },
+                src: { default: '' },
+            },
+            parseDOM: [
+                {
+                    tag: 'img[data-matrix-asset-id]',
+                    getAttrs: (node) => {
+                        if (!(0, core_1.isElementDomNode)(node)) {
+                            return false;
+                        }
+                        const matrixAssetId = node.getAttribute('data-matrix-asset-id');
+                        const matrixIdentifier = node.getAttribute('data-matrix-identifier');
+                        const matrixDomain = node.getAttribute('data-matrix-domain');
+                        if (!matrixAssetId || !matrixIdentifier || !matrixDomain) {
+                            return false;
+                        }
+                        return {
+                            ...extra.parse(node),
+                            matrixAssetId,
+                            matrixIdentifier,
+                            matrixDomain,
+                        };
+                    },
+                },
+            ],
+            toDOM: (node) => {
+                const { matrixAssetId, matrixIdentifier, matrixDomain, src, ...rest } = (0, core_1.omitExtraAttributes)(node.attrs, extra);
+                return [
+                    'img',
+                    {
+                        ...extra.dom(node),
+                        ...rest,
+                        src,
+                        'data-matrix-asset-id': matrixAssetId,
+                        'data-matrix-identifier': matrixIdentifier,
+                        'data-matrix-domain': matrixDomain,
+                    },
+                ];
+            },
+        };
+    }
+    insertAssetImage(attrs) {
+        return ({ tr, dispatch }) => {
+            const { from, to } = (0, remirror_1.getTextSelection)(tr.selection, tr.doc);
+            const node = this.type.create({ ...attrs, src: attrs.url });
+            dispatch?.(tr.replaceRangeWith(from, to, node));
+            return true;
+        };
+    }
+};
+__decorate([
+    (0, core_1.command)()
+], AssetImageExtension.prototype, "insertAssetImage", null);
+AssetImageExtension = __decorate([
+    (0, core_1.extension)({
+        defaultOptions: {
+            matrixDomain: '',
+        },
+        defaultPriority: core_1.ExtensionPriority.High,
+    })
+], AssetImageExtension);
+exports.AssetImageExtension = AssetImageExtension;

package/lib/Extensions/ImageExtension/ImageExtension.d.ts

@@ -0,0 +1,7 @@
+import { ImageExtension as RemirrorImageExtension } from 'remirror/extensions';
+import { PasteRule } from 'prosemirror-paste-rules';
+import { ApplySchemaAttributes, NodeSpecOverride, NodeExtensionSpec } from '@remirror/core';
+export declare class ImageExtension extends RemirrorImageExtension {
+    createPasteRules(): PasteRule[];
+    createNodeSpec(extra: ApplySchemaAttributes, override: NodeSpecOverride): NodeExtensionSpec;
+}

package/lib/Extensions/ImageExtension/ImageExtension.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImageExtension = void 0;
+const extensions_1 = require("remirror/extensions");
+class ImageExtension extends extensions_1.ImageExtension {
+    createPasteRules() {
+        // override super behaviour of handling file uploads.
+        return [];
+    }
+    createNodeSpec(extra, override) {
+        const spec = super.createNodeSpec(extra, override);
+        return {
+            ...spec,
+            selectable: true,
+        };
+    }
+}
+exports.ImageExtension = ImageExtension;

package/lib/Extensions/LinkExtension/AssetLinkExtension.d.ts

@@ -0,0 +1,27 @@
+import { ApplySchemaAttributes, FromToProps, MarkExtensionSpec, MarkSpecOverride } from 'remirror';
+import { CommandFunction, MarkExtension } from '@remirror/core';
+import { LinkTarget } from './common';
+export type AssetLinkAttributes = {
+    matrixAssetId: string;
+    matrixIdentifier: string;
+    matrixDomain: string;
+    target: LinkTarget;
+    href: string;
+    url: string;
+};
+export type AssetLinkOptions = {
+    matrixDomain?: string;
+    defaultTarget?: LinkTarget;
+    supportedTargets?: LinkTarget[];
+};
+export type UpdateAssetLinkProps = {
+    text: string;
+    attrs: Partial<AssetLinkAttributes>;
+    range: FromToProps;
+};
+export declare class AssetLinkExtension extends MarkExtension<AssetLinkOptions> {
+    get name(): string;
+    createMarkSpec(extra: ApplySchemaAttributes, override: MarkSpecOverride): MarkExtensionSpec;
+    updateAssetLink({ text, attrs, range }: UpdateAssetLinkProps): CommandFunction;
+    removeAssetLink(): CommandFunction;
+}

package/lib/Extensions/LinkExtension/AssetLinkExtension.js

@@ -0,0 +1,101 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssetLinkExtension = void 0;
+const remirror_1 = require("remirror");
+const core_1 = require("@remirror/core");
+const common_1 = require("./common");
+const CommandsExtension_1 = require("../CommandsExtension/CommandsExtension");
+const Extensions_1 = require("../Extensions");
+let AssetLinkExtension = class AssetLinkExtension extends core_1.MarkExtension {
+    get name() {
+        return Extensions_1.MarkName.AssetLink;
+    }
+    createMarkSpec(extra, override) {
+        return {
+            inclusive: false,
+            excludes: [this.name, Extensions_1.MarkName.Link].join(' '),
+            ...override,
+            attrs: {
+                ...extra.defaults(),
+                matrixAssetId: {},
+                matrixIdentifier: {},
+                href: { default: '' },
+                matrixDomain: { default: this.options.matrixDomain },
+                target: { default: this.options.defaultTarget },
+            },
+            parseDOM: [
+                {
+                    tag: 'a[data-matrix-asset-id]',
+                    getAttrs: (node) => {
+                        if (!(0, remirror_1.isElementDomNode)(node)) {
+                            return false;
+                        }
+                        const matrixAssetId = node.getAttribute('data-matrix-asset-id');
+                        const matrixIdentifier = node.getAttribute('data-matrix-identifier');
+                        const matrixDomain = node.getAttribute('data-matrix-domain');
+                        if (!matrixAssetId || !matrixIdentifier || !matrixDomain) {
+                            return false;
+                        }
+                        return {
+                            ...extra.parse(node),
+                            matrixAssetId,
+                            matrixIdentifier,
+                            matrixDomain,
+                            target: (0, common_1.validateTarget)(node.getAttribute('target'), this.options.supportedTargets, this.options.defaultTarget),
+                        };
+                    },
+                },
+            ],
+            toDOM: (node) => {
+                const { matrixAssetId, matrixIdentifier, matrixDomain, target, href, ...rest } = (0, core_1.omitExtraAttributes)(node.attrs, extra);
+                const rel = 'noopener noreferrer nofollow';
+                const attrs = {
+                    ...extra.dom(node),
+                    ...rest,
+                    rel,
+                    href,
+                    target: (0, common_1.validateTarget)(target, this.options.supportedTargets, this.options.defaultTarget),
+                    'data-matrix-asset-id': matrixAssetId,
+                    'data-matrix-identifier': matrixIdentifier,
+                    'data-matrix-domain': matrixDomain,
+                };
+                return ['a', attrs, 0];
+            },
+        };
+    }
+    updateAssetLink({ text, attrs, range }) {
+        return this.store.getExtension(CommandsExtension_1.CommandsExtension).updateMark({
+            attrs: { ...attrs, href: attrs.url },
+            text,
+            range,
+            mark: this.type,
+            removeMark: !attrs.matrixAssetId,
+        });
+    }
+    removeAssetLink() {
+        return (0, core_1.removeMark)({ type: this.type });
+    }
+};
+__decorate([
+    (0, core_1.command)()
+], AssetLinkExtension.prototype, "updateAssetLink", null);
+__decorate([
+    (0, core_1.command)()
+], AssetLinkExtension.prototype, "removeAssetLink", null);
+AssetLinkExtension = __decorate([
+    (0, core_1.extension)({
+        defaultOptions: {
+            matrixDomain: '',
+            defaultTarget: common_1.LinkTarget.Self,
+            supportedTargets: [common_1.LinkTarget.Self, common_1.LinkTarget.Blank],
+        },
+        defaultPriority: remirror_1.ExtensionPriority.High,
+    })
+], AssetLinkExtension);
+exports.AssetLinkExtension = AssetLinkExtension;

package/lib/Extensions/LinkExtension/LinkExtension.d.ts

@@ -0,0 +1,23 @@
+import { ApplySchemaAttributes, FromToProps, MarkExtensionSpec, MarkSpecOverride } from 'remirror';
+import { CommandFunction, MarkExtension } from '@remirror/core';
+import { LinkTarget } from './common';
+export type LinkAttributes = {
+    href: string;
+    title?: string;
+    target: LinkTarget;
+};
+export type LinkOptions = {
+    defaultTarget?: LinkTarget;
+    supportedTargets?: LinkTarget[];
+};
+export type UpdateLinkProps = {
+    text: string;
+    attrs: Partial<LinkAttributes>;
+    range: FromToProps;
+};
+export declare class LinkExtension extends MarkExtension<LinkOptions> {
+    get name(): string;
+    createMarkSpec(extra: ApplySchemaAttributes, override: MarkSpecOverride): MarkExtensionSpec;
+    updateLink({ text, attrs, range }: UpdateLinkProps): CommandFunction;
+    removeLink(): CommandFunction;
+}

package/lib/Extensions/LinkExtension/LinkExtension.js

@@ -0,0 +1,87 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LinkExtension = void 0;
+const remirror_1 = require("remirror");
+const core_1 = require("@remirror/core");
+const common_1 = require("./common");
+const CommandsExtension_1 = require("../CommandsExtension/CommandsExtension");
+const Extensions_1 = require("../Extensions");
+let LinkExtension = class LinkExtension extends core_1.MarkExtension {
+    get name() {
+        return Extensions_1.MarkName.Link;
+    }
+    createMarkSpec(extra, override) {
+        return {
+            inclusive: false,
+            excludes: [this.name, Extensions_1.MarkName.AssetLink].join(' '),
+            ...override,
+            attrs: {
+                ...extra.defaults(),
+                href: {},
+                title: { default: undefined },
+                target: { default: this.options.defaultTarget },
+            },
+            parseDOM: [
+                {
+                    tag: 'a[href]',
+                    getAttrs: (node) => {
+                        if (!(0, remirror_1.isElementDomNode)(node)) {
+                            return false;
+                        }
+                        return {
+                            ...extra.parse(node),
+                            href: node.getAttribute('href'),
+                            title: node.getAttribute('title'),
+                            target: (0, common_1.validateTarget)(node.getAttribute('target'), this.options.supportedTargets, this.options.defaultTarget),
+                        };
+                    },
+                },
+            ],
+            toDOM: (node) => {
+                const { target, ...rest } = (0, core_1.omitExtraAttributes)(node.attrs, extra);
+                const rel = 'noopener noreferrer nofollow';
+                const attrs = {
+                    ...extra.dom(node),
+                    ...rest,
+                    rel,
+                    target: (0, common_1.validateTarget)(target, this.options.supportedTargets, this.options.defaultTarget),
+                };
+                return ['a', attrs, 0];
+            },
+        };
+    }
+    updateLink({ text, attrs, range }) {
+        return this.store.getExtension(CommandsExtension_1.CommandsExtension).updateMark({
+            attrs,
+            text,
+            range,
+            mark: this.type,
+            removeMark: !attrs.href,
+        });
+    }
+    removeLink() {
+        return (0, core_1.removeMark)({ type: this.type });
+    }
+};
+__decorate([
+    (0, core_1.command)()
+], LinkExtension.prototype, "updateLink", null);
+__decorate([
+    (0, core_1.command)()
+], LinkExtension.prototype, "removeLink", null);
+LinkExtension = __decorate([
+    (0, core_1.extension)({
+        defaultOptions: {
+            defaultTarget: common_1.LinkTarget.Self,
+            supportedTargets: [common_1.LinkTarget.Self, common_1.LinkTarget.Blank],
+        },
+        defaultPriority: remirror_1.ExtensionPriority.Medium,
+    })
+], LinkExtension);
+exports.LinkExtension = LinkExtension;

package/lib/Extensions/LinkExtension/common.d.ts

@@ -0,0 +1,7 @@
+export declare enum LinkTarget {
+    Self = "_self",
+    Blank = "_blank",
+    Parent = "_parent",
+    Top = "_top"
+}
+export declare const validateTarget: (target: unknown, supportedTargets: LinkTarget[], defaultTarget: LinkTarget) => LinkTarget;

package/lib/Extensions/LinkExtension/common.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateTarget = exports.LinkTarget = void 0;
+var LinkTarget;
+(function (LinkTarget) {
+    LinkTarget["Self"] = "_self";
+    LinkTarget["Blank"] = "_blank";
+    LinkTarget["Parent"] = "_parent";
+    LinkTarget["Top"] = "_top";
+})(LinkTarget = exports.LinkTarget || (exports.LinkTarget = {}));
+const validateTarget = (target, supportedTargets, defaultTarget) => {
+    return supportedTargets.includes(target) ? target : defaultTarget;
+};
+exports.validateTarget = validateTarget;

package/lib/Extensions/PreformattedExtension/PreformattedExtension.d.ts

@@ -0,0 +1,12 @@
+import { ApplySchemaAttributes, CommandFunction, NodeExtension, NodeExtensionSpec, NodeSpecOverride } from '@remirror/core';
+import { NodeViewMethod } from 'remirror';
+export declare class PreformattedExtension extends NodeExtension {
+    get name(): "preformatted";
+    createTags(): ("block" | "formattingNode" | "textBlock")[];
+    createNodeSpec(extra: ApplySchemaAttributes, override: NodeSpecOverride): NodeExtensionSpec;
+    createNodeViews(): NodeViewMethod;
+    /**
+     * Toggle the <pre> for the current block.
+     */
+    togglePreformatted(): CommandFunction;
+}

package/lib/Extensions/PreformattedExtension/PreformattedExtension.js

@@ -0,0 +1,76 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PreformattedExtension = void 0;
+const core_1 = require("@remirror/core");
+let PreformattedExtension = class PreformattedExtension extends core_1.NodeExtension {
+    get name() {
+        return 'preformatted';
+    }
+    createTags() {
+        return [core_1.ExtensionTag.Block, core_1.ExtensionTag.TextBlock, core_1.ExtensionTag.FormattingNode];
+    }
+    createNodeSpec(extra, override) {
+        return {
+            content: 'inline*',
+            defining: true,
+            draggable: false,
+            ...override,
+            attrs: {
+                ...extra.defaults(),
+            },
+            parseDOM: [
+                {
+                    tag: 'pre',
+                },
+            ],
+            toDOM: (node) => {
+                return ['pre', extra.dom(node), 0];
+            },
+        };
+    }
+    createNodeViews() {
+        return (node) => {
+            const { nodeTextAlignment } = node.attrs;
+            // This is the pre container for the code block
+            const dom = document.createElement('div');
+            dom.classList.add(`preformatted`);
+            // This is the actual code content in the code block
+            const contentDOM = document.createElement('pre');
+            contentDOM.setAttribute('data-node-text-align', nodeTextAlignment);
+            contentDOM.setAttribute('style', `text-align:${nodeTextAlignment}`);
+            // Divider between code block and pre container
+            const dividerElement = document.createElement('div');
+            dividerElement.classList.add('block-divider');
+            // The material icon to use
+            const codeIcon = document.createElement('svg');
+            codeIcon.classList.add('material-symbols-rounded');
+            codeIcon.textContent = 'short_text';
+            dom.append(codeIcon);
+            dom.append(dividerElement);
+            dom.append(contentDOM);
+            return { dom, contentDOM };
+        };
+    }
+    /**
+     * Toggle the <pre> for the current block.
+     */
+    togglePreformatted() {
+        return (0, core_1.toggleBlockItem)({
+            type: this.type,
+            toggleType: 'paragraph',
+        });
+    }
+};
+__decorate([
+    (0, core_1.command)()
+], PreformattedExtension.prototype, "togglePreformatted", null);
+PreformattedExtension = __decorate([
+    (0, core_1.extension)({})
+], PreformattedExtension);
+exports.PreformattedExtension = PreformattedExtension;

package/lib/Extensions/UnsuportedExtension/UnsupportedNodeExtension.d.ts

@@ -0,0 +1,10 @@
+import { ApplySchemaAttributes, NodeExtension, NodeExtensionSpec, NodeSpecOverride } from '@remirror/core';
+import { NodeName } from '../Extensions';
+import { ComponentType } from 'react';
+import { NodeViewComponentProps } from '@remirror/react';
+export declare class UnsupportedNodeExtension extends NodeExtension {
+    get name(): NodeName.Unsupported;
+    ReactComponent: ComponentType<NodeViewComponentProps>;
+    createTags(): "inline"[];
+    createNodeSpec(extra: ApplySchemaAttributes, override: NodeSpecOverride): NodeExtensionSpec;
+}

package/lib/Extensions/UnsuportedExtension/UnsupportedNodeExtension.js

@@ -0,0 +1,76 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnsupportedNodeExtension = void 0;
+const core_1 = require("@remirror/core");
+const Extensions_1 = require("../Extensions");
+const CollapseBox_1 = __importDefault(require("../../ui/CollapseBox/CollapseBox"));
+let UnsupportedNodeExtension = class UnsupportedNodeExtension extends core_1.NodeExtension {
+    get name() {
+        return Extensions_1.NodeName.Unsupported;
+    }
+    ReactComponent = CollapseBox_1.default;
+    createTags() {
+        return [core_1.ExtensionTag.InlineNode];
+    }
+    createNodeSpec(extra, override) {
+        return {
+            selectable: false,
+            draggable: false,
+            atom: true,
+            inline: true,
+            ...override,
+            attrs: {
+                ...extra.defaults(),
+                originalNode: {},
+                errorMessage: {},
+            },
+            parseDOM: [
+                {
+                    tag: `[data-unsupported-node]`,
+                    getAttrs: (node) => {
+                        if (!(0, core_1.isElementDomNode)(node)) {
+                            return false;
+                        }
+                        const unsupportedNodes = node.getAttribute('data-unsupported-node');
+                        try {
+                            const decodedNodes = JSON.parse(unsupportedNodes);
+                            return {
+                                ...extra.parse(node),
+                                originalNode: decodedNodes?.originalNode,
+                                errorMessage: decodedNodes?.errorMessage,
+                            };
+                        }
+                        catch (error) {
+                            console.error('Failed to parse Remirror nodes from data-unsupported-node', error);
+                            return false;
+                        }
+                    },
+                },
+            ],
+            toDOM: (node) => {
+                const { originalNode, errorMessage, ...rest } = (0, core_1.omitExtraAttributes)(node.attrs, extra);
+                const attrs = {
+                    ...extra.dom(node),
+                    ...rest,
+                    originalNode,
+                    errorMessage,
+                    'data-unsupported-node': JSON.stringify({ originalNode, errorMessage }),
+                };
+                return ['div', attrs];
+            },
+        };
+    }
+};
+UnsupportedNodeExtension = __decorate([
+    (0, core_1.extension)({})
+], UnsupportedNodeExtension);
+exports.UnsupportedNodeExtension = UnsupportedNodeExtension;

package/lib/hooks/index.d.ts

@@ -0,0 +1,2 @@
+export * from './useExtensionNames';
+export * from './useExpandedSelection';

package/lib/hooks/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./useExtensionNames"), exports);
+__exportStar(require("./useExpandedSelection"), exports);