@squiz/formatted-text-editor 2.3.0 → 2.5.0

package/lib/Extensions/Extensions.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createExtensions = exports.MarkName = exports.NodeName = void 0;
+const extensions_1 = require("remirror/extensions");
+const PreformattedExtension_1 = require("./PreformattedExtension/PreformattedExtension");
+const AssetLinkExtension_1 = require("./LinkExtension/AssetLinkExtension");
+const LinkExtension_1 = require("./LinkExtension/LinkExtension");
+const ImageExtension_1 = require("./ImageExtension/ImageExtension");
+const CommandsExtension_1 = require("./CommandsExtension/CommandsExtension");
+const AssetImageExtension_1 = require("./ImageExtension/AssetImageExtension");
+const DAMImageExtension_1 = require("./ImageExtension/DAMImageExtension");
+const CodeBlockExtension_1 = require("./CodeBlockExtension/CodeBlockExtension");
+const ClearFormattingExtension_1 = require("./ClearFormattingExtension/ClearFormattingExtension");
+const UnsupportedNodeExtension_1 = require("./UnsuportedExtension/UnsupportedNodeExtension");
+const FetchUrlExtension_1 = require("./FetchUrlExtension/FetchUrlExtension");
+const extension_react_tables_1 = require("@remirror/extension-react-tables");
+const extension_react_component_1 = require("@remirror/extension-react-component");
+var NodeName;
+(function (NodeName) {
+    NodeName["Image"] = "image";
+    NodeName["CodeBlock"] = "codeBlock";
+    NodeName["AssetImage"] = "assetImage";
+    NodeName["DAMImage"] = "DAMImage";
+    NodeName["Text"] = "text";
+    NodeName["TableControllerCell"] = "tableControllerCell";
+    NodeName["tableCell"] = "tableCell";
+    NodeName["hardBreak"] = "hardBreak";
+    NodeName["Unsupported"] = "unsupportedNode";
+})(NodeName = exports.NodeName || (exports.NodeName = {}));
+var MarkName;
+(function (MarkName) {
+    MarkName["Link"] = "link";
+    MarkName["AssetLink"] = "assetLink";
+})(MarkName = exports.MarkName || (exports.MarkName = {}));
+const createExtensions = (context, enableDecorations = true) => {
+    return () => {
+        return [
+            new CommandsExtension_1.CommandsExtension(),
+            new extensions_1.BoldExtension(),
+            new extensions_1.DocExtension(),
+            new extensions_1.HeadingExtension(),
+            new extensions_1.ItalicExtension(),
+            new extensions_1.NodeFormattingExtension({ indents: [] }),
+            new extensions_1.ParagraphExtension(),
+            new extensions_1.HardBreakExtension(),
+            new CodeBlockExtension_1.CodeBlockExtension({ enableDecorations }),
+            new PreformattedExtension_1.PreformattedExtension({ enableDecorations }),
+            new extensions_1.UnderlineExtension(),
+            new extensions_1.HistoryExtension(),
+            new ImageExtension_1.ImageExtension(),
+            new ImageExtension_1.ImageExtension({ preferPastedTextContent: false }),
+            new AssetImageExtension_1.AssetImageExtension({
+                matrixDomain: context.matrix.matrixDomain,
+            }),
+            new DAMImageExtension_1.DAMImageExtension(),
+            new LinkExtension_1.LinkExtension(),
+            new AssetLinkExtension_1.AssetLinkExtension({
+                matrixDomain: context.matrix.matrixDomain,
+            }),
+            new UnsupportedNodeExtension_1.UnsupportedNodeExtension(),
+            new ClearFormattingExtension_1.ClearFormattingExtension(),
+            new extensions_1.BulletListExtension(),
+            new extensions_1.ListItemExtension(),
+            new extensions_1.OrderedListExtension(),
+            new extensions_1.HorizontalRuleExtension(),
+            new extensions_1.PlaceholderExtension(),
+            new FetchUrlExtension_1.FetchUrlExtension({
+                fetchUrl: context.resolveNodeToUrl,
+            }),
+            new extensions_1.TextExtension(),
+            new extension_react_tables_1.TableExtension(),
+            new extension_react_component_1.ReactComponentExtension(),
+        ];
+    };
+};
+exports.createExtensions = createExtensions;

package/lib/Extensions/FetchUrlExtension/FetchUrlExtension.d.ts

@@ -0,0 +1,12 @@
+import { PlainExtension } from '@remirror/core';
+import { Dispose, EditorView } from '@remirror/core-types';
+import { ResolveNodeToUrl } from '../../types';
+export type FetchUrlOptions = {
+    fetchUrl?: ResolveNodeToUrl;
+};
+export declare class FetchUrlExtension extends PlainExtension<FetchUrlOptions> {
+    get name(): string;
+    onView(view: EditorView): Dispose | void;
+    private findAssetLinkMark;
+    private fetchAndReplace;
+}

package/lib/Extensions/FetchUrlExtension/FetchUrlExtension.js

@@ -0,0 +1,69 @@
+"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);
+                }));
+            }
+            if (node.type.name === Extensions_1.NodeName.DAMImage && node.attrs.src === '') {
+                promises.push(this.fetchAndReplace(node.attrs, (url) => {
+                    const newNode = state.schema.nodes[Extensions_1.NodeName.DAMImage].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/DAMImageExtension.d.ts

@@ -0,0 +1,17 @@
+import { ApplySchemaAttributes, NodeExtension, NodeExtensionSpec, NodeSpecOverride, CommandFunction } from '@remirror/core';
+import { NodeName } from '../Extensions';
+export type DAMImageAttributes = {
+    damObjectId: string;
+    damSystemIdentifier: string;
+    damSystemType: string;
+    damAdditional?: {
+        variant: string;
+    };
+    url: string;
+};
+export declare class DAMImageExtension extends NodeExtension {
+    get name(): NodeName.DAMImage;
+    createTags(): ("inline" | "media")[];
+    createNodeSpec(extra: ApplySchemaAttributes, override: NodeSpecOverride): NodeExtensionSpec;
+    insertDAMImage(attrs: DAMImageAttributes): CommandFunction;
+}

package/lib/Extensions/ImageExtension/DAMImageExtension.js

@@ -0,0 +1,97 @@
+"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.DAMImageExtension = void 0;
+const core_1 = require("@remirror/core");
+const remirror_1 = require("remirror");
+const Extensions_1 = require("../Extensions");
+let DAMImageExtension = class DAMImageExtension extends core_1.NodeExtension {
+    get name() {
+        return Extensions_1.NodeName.DAMImage;
+    }
+    createTags() {
+        return [core_1.ExtensionTag.InlineNode, core_1.ExtensionTag.Media];
+    }
+    createNodeSpec(extra, override) {
+        return {
+            inline: true,
+            draggable: true,
+            selectable: true,
+            ...override,
+            attrs: {
+                ...extra.defaults(),
+                damObjectId: {},
+                damSystemIdentifier: {},
+                damSystemType: {},
+                damAdditional: { default: undefined },
+                src: { default: '' },
+            },
+            parseDOM: [
+                {
+                    tag: 'img[data-dam-object-id]',
+                    getAttrs: (node) => {
+                        if (!(0, core_1.isElementDomNode)(node)) {
+                            return false;
+                        }
+                        const damObjectId = node.getAttribute('data-dam-object-id');
+                        const damSystemIdentifier = node.getAttribute('data-dam-system-identifier');
+                        const damSystemType = node.getAttribute('data-dam-system-type');
+                        let damAdditional = node.getAttribute('data-dam-additional') || undefined;
+                        if (!damObjectId || !damSystemIdentifier || !damSystemType) {
+                            return false;
+                        }
+                        if (damAdditional) {
+                            damAdditional = JSON.parse(damAdditional);
+                        }
+                        return {
+                            ...extra.parse(node),
+                            damObjectId,
+                            damSystemIdentifier,
+                            damSystemType,
+                            damAdditional,
+                            src: '',
+                        };
+                    },
+                },
+            ],
+            toDOM: (node) => {
+                const { damObjectId, damSystemIdentifier, damSystemType, damAdditional, src, ...rest } = (0, core_1.omitExtraAttributes)(node.attrs, extra);
+                return [
+                    'img',
+                    {
+                        ...extra.dom(node),
+                        ...rest,
+                        src,
+                        'data-dam-object-id': damObjectId,
+                        'data-dam-system-identifier': damSystemIdentifier,
+                        'data-dam-system-type': damSystemType,
+                        'data-dam-additional': damAdditional ? JSON.stringify(damAdditional) : undefined,
+                    },
+                ];
+            },
+        };
+    }
+    insertDAMImage(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)()
+], DAMImageExtension.prototype, "insertDAMImage", null);
+DAMImageExtension = __decorate([
+    (0, core_1.extension)({
+        defaultOptions: {},
+        defaultPriority: core_1.ExtensionPriority.High,
+    })
+], DAMImageExtension);
+exports.DAMImageExtension = DAMImageExtension;

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;