@gravity-ui/markdown-editor 14.11.1 → 14.12.0

package/build/esm/bundle/config/previews/TextPreview.d.ts

@@ -0,0 +1,2 @@
+import './ActionPreview.css';
+export declare const TextPreview: () => JSX.Element;

package/build/esm/bundle/config/previews/TextPreview.js

@@ -0,0 +1,10 @@
+import React from 'react';
+import { cn } from '../../../classname';
+import { i18n } from '../../../i18n/action-previews';
+import { ActionPreview } from './ActionPreview';
+import './ActionPreview.css';
+const b = cn('action-preview');
+export const TextPreview = () => {
+    return (React.createElement(ActionPreview, null,
+        React.createElement("p", { className: b('text') }, i18n('text'))));
+};

package/build/esm/bundle/config/w-heading-config.js

@@ -1,7 +1,10 @@
+import React from 'react';
 import { i18n } from '../../i18n/menubar';
 import { Action as A, formatter as f } from '../../shortcuts';
 import { ActionName } from './action-names';
 import { icons } from './icons';
+import { HeadingPreview } from './previews/HeadingPreview';
+import { TextPreview } from './previews/TextPreview';
 export const wTextItemData = {
     id: ActionName.paragraph,
     title: i18n.bind(null, 'text'),
@@ -11,6 +14,7 @@ export const wTextItemData = {
     isActive: (e) => e.actions.toParagraph.isActive(),
     isEnable: (e) => e.actions.toParagraph.isEnable(),
     doNotActivateList: true,
+    preview: React.createElement(TextPreview, null),
 };
 export const wHeading1ItemData = {
     id: ActionName.heading1,
@@ -20,6 +24,7 @@ export const wHeading1ItemData = {
     exec: (e) => e.actions.toH1.run(),
     isActive: (e) => e.actions.toH1.isActive(),
     isEnable: (e) => e.actions.toH1.isEnable(),
+    preview: React.createElement(HeadingPreview, { level: 1 }),
 };
 export const wHeading2ItemData = {
     id: ActionName.heading2,
@@ -29,6 +34,7 @@ export const wHeading2ItemData = {
     exec: (e) => e.actions.toH2.run(),
     isActive: (e) => e.actions.toH2.isActive(),
     isEnable: (e) => e.actions.toH2.isEnable(),
+    preview: React.createElement(HeadingPreview, { level: 2 }),
 };
 export const wHeading3ItemData = {
     id: ActionName.heading3,
@@ -38,6 +44,7 @@ export const wHeading3ItemData = {
     exec: (e) => e.actions.toH3.run(),
     isActive: (e) => e.actions.toH3.isActive(),
     isEnable: (e) => e.actions.toH3.isEnable(),
+    preview: React.createElement(HeadingPreview, { level: 3 }),
 };
 export const wHeading4ItemData = {
     id: ActionName.heading4,
@@ -47,6 +54,7 @@ export const wHeading4ItemData = {
     exec: (e) => e.actions.toH4.run(),
     isActive: (e) => e.actions.toH4.isActive(),
     isEnable: (e) => e.actions.toH4.isEnable(),
+    preview: React.createElement(HeadingPreview, { level: 4 }),
 };
 export const wHeading5ItemData = {
     id: ActionName.heading5,
@@ -56,6 +64,7 @@ export const wHeading5ItemData = {
     exec: (e) => e.actions.toH5.run(),
     isActive: (e) => e.actions.toH5.isActive(),
     isEnable: (e) => e.actions.toH5.isEnable(),
+    preview: React.createElement(HeadingPreview, { level: 5 }),
 };
 export const wHeading6ItemData = {
     id: ActionName.heading6,
@@ -65,6 +74,7 @@ export const wHeading6ItemData = {
     exec: (e) => e.actions.toH6.run(),
     isActive: (e) => e.actions.toH6.isActive(),
     isEnable: (e) => e.actions.toH6.isEnable(),
+    preview: React.createElement(HeadingPreview, { level: 6 }),
 };
 export const wHeadingListConfig = {
     icon: icons.headline,

package/build/esm/bundle/toolbar/utils/toolbarsConfigs.js

@@ -16,7 +16,8 @@ const transformItem = (type, item, id = 'unknown') => {
         return {};
     }
     const isListButton = item.view.type === ToolbarDataType.ListButton;
-    return Object.assign(Object.assign(Object.assign({ type: (_a = item.view.type) !== null && _a !== void 0 ? _a : ToolbarDataType.SingleButton, id, title: item.view.title, hint: item.view.hint, icon: item.view.icon, hotkey: item.view.hotkey }, (isListButton && { withArrow: item.view.withArrow })), (type === 'wysiwyg' && item.wysiwyg && Object.assign({}, item.wysiwyg))), (type === 'markup' && item.markup && Object.assign({}, item.markup)));
+    const isSingleButton = item.view.type === ToolbarDataType.SingleButton;
+    return Object.assign(Object.assign(Object.assign(Object.assign({ type: (_a = item.view.type) !== null && _a !== void 0 ? _a : ToolbarDataType.SingleButton, id, title: item.view.title, hint: item.view.hint, icon: item.view.icon, hotkey: item.view.hotkey }, (isSingleButton && { preview: item.view.preview })), (isListButton && { withArrow: item.view.withArrow })), (type === 'wysiwyg' && item.wysiwyg && Object.assign({}, item.wysiwyg))), (type === 'markup' && item.markup && Object.assign({}, item.markup)));
 };
 export const createToolbarConfig = (editorType, toolbarPreset, toolbarName) => {
     var _a;

package/build/esm/bundle/types.d.ts

@@ -99,6 +99,17 @@ export declare type MarkdownEditorExperimentalOptions = {
      * @default false
      */
     preserveEmptyRows?: boolean;
+    /**
+     * Preserves the original formatting of unmodified blocks,
+     * restoring their structure during serialization
+     *
+     * **Use case:** Maintain consistent markup when switching modes
+     *
+     * **Note:** Applies to tracked blocks: `yfm_table`
+     *
+     * @default false
+     */
+    preserveMarkupFormatting?: boolean;
 };
 export declare type MarkdownEditorMarkupConfig = {
     /**

package/build/esm/core/Editor.d.ts

@@ -4,7 +4,7 @@ import { TransformFn } from './markdown/ProseMirrorTransformer';
 import type { ActionStorage } from './types/actions';
 import type { Extension } from './types/extension';
 import type { Parser } from './types/parser';
-import type { Serializer } from './types/serializer';
+import { Serializer } from './types/serializer';
 declare type OnChange = (editor: WysiwygEditor) => void;
 export declare type EscapeConfig = {
     commonEscape?: RegExp;
@@ -33,7 +33,7 @@ export declare class WysiwygEditor implements CommonEditor, ActionStorage {
     get serializer(): Serializer;
     get parser(): Parser;
     get actions(): WysiwygEditor.Actions;
-    constructor({ domElem, initialContent, extensions, allowHTML, mdPreset, linkify, pmTransformers, linkifyTlds, escapeConfig, onChange, onDocChange, }: WysiwygEditorOptions);
+    constructor({ domElem, initialContent, extensions, allowHTML, mdPreset, linkify, pmTransformers, linkifyTlds, escapeConfig, onChange, onDocChange, modifiers, }: WysiwygEditorOptions);
     action<T extends keyof WysiwygEditor.Actions>(actionName: T): WysiwygEditor.Actions[T];
     focus(): void;
     hasFocus(): boolean;

package/build/esm/core/Editor.js

@@ -4,21 +4,36 @@ import { EditorState } from 'prosemirror-state';
 import { EditorView } from 'prosemirror-view';
 import { WysiwygContentHandler } from './ContentHandler';
 import { ExtensionsManager } from './ExtensionsManager';
+import { SchemaDynamicModifier } from './SchemaDynamicModifier';
+import { MarkdownParserDynamicModifier } from './markdown/MarkdownParser';
+import { MarkdownSerializerDynamicModifier } from './markdown/MarkdownSerializerDynamicModifier';
 import { bindActions } from './utils/actions';
+import { convertDynamicModifiersConfigs } from './utils/dynamicModifiers';
 import { logTransactionMetrics } from './utils/metrics';
 export class WysiwygEditor {
-    constructor({ domElem, initialContent = '', extensions = () => { }, allowHTML, mdPreset, linkify, pmTransformers, linkifyTlds, escapeConfig, onChange, onDocChange, }) {
+    constructor({ domElem, initialContent = '', extensions = () => { }, allowHTML, mdPreset, linkify, pmTransformers, linkifyTlds, escapeConfig, onChange, onDocChange, modifiers, }) {
         _WysiwygEditor_view.set(this, void 0);
         _WysiwygEditor_serializer.set(this, void 0);
         _WysiwygEditor_parser.set(this, void 0);
         _WysiwygEditor_actions.set(this, void 0);
         _WysiwygEditor_contentHandler.set(this, void 0);
         _WysiwygEditor_escapeConfig.set(this, void 0);
+        const dynamicModifiersConfig = modifiers
+            ? convertDynamicModifiersConfigs(modifiers)
+            : undefined;
+        const dynamicModifiers = dynamicModifiersConfig
+            ? {
+                schema: new SchemaDynamicModifier(dynamicModifiersConfig.schema),
+                parser: new MarkdownParserDynamicModifier(dynamicModifiersConfig.parser),
+                serializer: new MarkdownSerializerDynamicModifier(dynamicModifiersConfig.serializer),
+            }
+            : undefined;
         const { schema, markupParser: parser, serializer, nodeViews, markViews, plugins, rawActions, actions, } = ExtensionsManager.process(extensions, {
             // "breaks" option only affects the renderer, but not the parser
             mdOpts: { html: allowHTML, linkify, breaks: true, preset: mdPreset },
             linkifyTlds,
             pmTransformers,
+            dynamicModifiers,
         });
         const state = EditorState.create({
             schema,

package/build/esm/core/ExtensionsManager.d.ts

@@ -1,6 +1,10 @@
 import MarkdownIt, { PresetName } from 'markdown-it';
+import { Schema } from 'prosemirror-model';
 import type { Plugin } from 'prosemirror-state';
 import { ActionsManager } from './ActionsManager';
+import { SchemaDynamicModifier } from './SchemaDynamicModifier';
+import { MarkdownParserDynamicModifier } from './markdown/MarkdownParser';
+import { MarkdownSerializerDynamicModifier } from './markdown/MarkdownSerializerDynamicModifier';
 import { TransformFn } from './markdown/ProseMirrorTransformer';
 import type { ActionSpec } from './types/actions';
 import type { Extension, ExtensionDeps } from './types/extension';
@@ -15,6 +19,11 @@ declare type ExtensionsManagerOptions = {
     };
     linkifyTlds?: string | string[];
     pmTransformers?: TransformFn[];
+    dynamicModifiers?: {
+        parser?: MarkdownParserDynamicModifier;
+        serializer?: MarkdownSerializerDynamicModifier;
+        schema?: SchemaDynamicModifier;
+    };
 };
 export declare class ExtensionsManager {
     #private;
@@ -24,7 +33,7 @@ export declare class ExtensionsManager {
         plugins: Plugin<any>[];
         nodeViews: Record<string, NodeViewConstructor>;
         markViews: Record<string, MarkViewConstructor>;
-        schema: import("prosemirror-model").Schema<any, any>;
+        schema: Schema<any, any>;
         textParser: import(".").Parser;
         markupParser: import(".").Parser;
         serializer: import(".").Serializer;
@@ -36,7 +45,7 @@ export declare class ExtensionsManager {
         plugins: Plugin<any>[];
         nodeViews: Record<string, NodeViewConstructor>;
         markViews: Record<string, MarkViewConstructor>;
-        schema: import("prosemirror-model").Schema<any, any>;
+        schema: Schema<any, any>;
         textParser: import(".").Parser;
         markupParser: import(".").Parser;
         serializer: import(".").Serializer;
@@ -45,6 +54,7 @@ export declare class ExtensionsManager {
     private processExtensions;
     private processNode;
     private processMark;
+    private createParser;
     private createDeps;
     private createDerived;
 }

package/build/esm/core/ExtensionsManager.js

@@ -1,4 +1,4 @@
-var _ExtensionsManager_schemaRegistry, _ExtensionsManager_parserRegistry, _ExtensionsManager_serializerRegistry, _ExtensionsManager_nodeViewCreators, _ExtensionsManager_markViewCreators, _ExtensionsManager_pmTransformers, _ExtensionsManager_mdForMarkup, _ExtensionsManager_mdForText, _ExtensionsManager_extensions, _ExtensionsManager_builder, _ExtensionsManager_spec, _ExtensionsManager_deps, _ExtensionsManager_plugins, _ExtensionsManager_actions, _ExtensionsManager_nodeViews, _ExtensionsManager_markViews;
+var _ExtensionsManager_schemaRegistry, _ExtensionsManager_parserRegistry, _ExtensionsManager_serializerRegistry, _ExtensionsManager_nodeViewCreators, _ExtensionsManager_markViewCreators, _ExtensionsManager_pmTransformers, _ExtensionsManager_mdForMarkup, _ExtensionsManager_mdForText, _ExtensionsManager_extensions, _ExtensionsManager_builder, _ExtensionsManager_spec, _ExtensionsManager_deps, _ExtensionsManager_plugins, _ExtensionsManager_actions, _ExtensionsManager_nodeViews, _ExtensionsManager_markViews, _ExtensionsManager_serializerDynamicModifier, _ExtensionsManager_parserDynamicModifier;
 import { __classPrivateFieldGet, __classPrivateFieldSet } from "tslib";
 import MarkdownIt from 'markdown-it';
 import { ActionsManager } from './ActionsManager';
@@ -8,10 +8,10 @@ import { SchemaSpecRegistry } from './SchemaSpecRegistry';
 import { SerializerTokensRegistry } from './SerializerTokensRegistry';
 export class ExtensionsManager {
     constructor({ extensions, options = {} }) {
-        var _a, _b, _c, _d;
-        _ExtensionsManager_schemaRegistry.set(this, new SchemaSpecRegistry());
-        _ExtensionsManager_parserRegistry.set(this, new ParserTokensRegistry());
-        _ExtensionsManager_serializerRegistry.set(this, new SerializerTokensRegistry());
+        var _a, _b, _c, _d, _e, _f, _g;
+        _ExtensionsManager_schemaRegistry.set(this, void 0);
+        _ExtensionsManager_parserRegistry.set(this, void 0);
+        _ExtensionsManager_serializerRegistry.set(this, void 0);
         _ExtensionsManager_nodeViewCreators.set(this, new Map());
         _ExtensionsManager_markViewCreators.set(this, new Map());
         _ExtensionsManager_pmTransformers.set(this, []);
@@ -25,6 +25,8 @@ export class ExtensionsManager {
         _ExtensionsManager_actions.set(this, {});
         _ExtensionsManager_nodeViews.set(this, {});
         _ExtensionsManager_markViews.set(this, {});
+        _ExtensionsManager_serializerDynamicModifier.set(this, void 0);
+        _ExtensionsManager_parserDynamicModifier.set(this, void 0);
         this.processNode = (name, { spec, fromMd, toMd: toMd, view }) => {
             __classPrivateFieldGet(this, _ExtensionsManager_schemaRegistry, "f").addNode(name, spec);
             __classPrivateFieldGet(this, _ExtensionsManager_parserRegistry, "f").addToken(fromMd.tokenName || name, fromMd.tokenSpec);
@@ -41,10 +43,17 @@ export class ExtensionsManager {
                 __classPrivateFieldGet(this, _ExtensionsManager_markViewCreators, "f").set(name, view);
             }
         };
+        __classPrivateFieldSet(this, _ExtensionsManager_schemaRegistry, new SchemaSpecRegistry(undefined, (_a = options.dynamicModifiers) === null || _a === void 0 ? void 0 : _a.schema), "f");
+        __classPrivateFieldSet(this, _ExtensionsManager_parserRegistry, new ParserTokensRegistry(), "f");
+        __classPrivateFieldSet(this, _ExtensionsManager_serializerRegistry, new SerializerTokensRegistry(), "f");
+        if (options.dynamicModifiers) {
+            __classPrivateFieldSet(this, _ExtensionsManager_parserDynamicModifier, (_b = options.dynamicModifiers) === null || _b === void 0 ? void 0 : _b.parser, "f");
+            __classPrivateFieldSet(this, _ExtensionsManager_serializerDynamicModifier, (_c = options.dynamicModifiers) === null || _c === void 0 ? void 0 : _c.serializer, "f");
+        }
         __classPrivateFieldSet(this, _ExtensionsManager_extensions, extensions, "f");
-        const mdPreset = (_b = (_a = options.mdOpts) === null || _a === void 0 ? void 0 : _a.preset) !== null && _b !== void 0 ? _b : 'default';
-        __classPrivateFieldSet(this, _ExtensionsManager_mdForMarkup, new MarkdownIt(mdPreset, (_c = options.mdOpts) !== null && _c !== void 0 ? _c : {}), "f");
-        __classPrivateFieldSet(this, _ExtensionsManager_mdForText, new MarkdownIt(mdPreset, (_d = options.mdOpts) !== null && _d !== void 0 ? _d : {}), "f");
+        const mdPreset = (_e = (_d = options.mdOpts) === null || _d === void 0 ? void 0 : _d.preset) !== null && _e !== void 0 ? _e : 'default';
+        __classPrivateFieldSet(this, _ExtensionsManager_mdForMarkup, new MarkdownIt(mdPreset, (_f = options.mdOpts) !== null && _f !== void 0 ? _f : {}), "f");
+        __classPrivateFieldSet(this, _ExtensionsManager_mdForText, new MarkdownIt(mdPreset, (_g = options.mdOpts) !== null && _g !== void 0 ? _g : {}), "f");
         if (options.linkifyTlds) {
             __classPrivateFieldGet(this, _ExtensionsManager_mdForMarkup, "f").linkify.tlds(options.linkifyTlds, true);
             __classPrivateFieldGet(this, _ExtensionsManager_mdForText, "f").linkify.tlds(options.linkifyTlds, true);
@@ -76,14 +85,21 @@ export class ExtensionsManager {
         __classPrivateFieldGet(this, _ExtensionsManager_spec, "f").nodes().forEach(this.processNode);
         __classPrivateFieldGet(this, _ExtensionsManager_spec, "f").marks().forEach(this.processMark);
     }
+    createParser(schema, mdInstance) {
+        return __classPrivateFieldGet(this, _ExtensionsManager_parserRegistry, "f").createParser(schema, mdInstance, __classPrivateFieldGet(this, _ExtensionsManager_pmTransformers, "f"), __classPrivateFieldGet(this, _ExtensionsManager_parserDynamicModifier, "f"));
+    }
     createDeps() {
+        const actions = new ActionsManager();
         const schema = __classPrivateFieldGet(this, _ExtensionsManager_schemaRegistry, "f").createSchema();
+        const markupParser = this.createParser(schema, __classPrivateFieldGet(this, _ExtensionsManager_mdForMarkup, "f"));
+        const textParser = this.createParser(schema, __classPrivateFieldGet(this, _ExtensionsManager_mdForText, "f"));
+        const serializer = __classPrivateFieldGet(this, _ExtensionsManager_serializerRegistry, "f").createSerializer(__classPrivateFieldGet(this, _ExtensionsManager_serializerDynamicModifier, "f"));
         __classPrivateFieldSet(this, _ExtensionsManager_deps, {
             schema,
-            actions: new ActionsManager(),
-            markupParser: __classPrivateFieldGet(this, _ExtensionsManager_parserRegistry, "f").createParser(schema, __classPrivateFieldGet(this, _ExtensionsManager_mdForMarkup, "f"), __classPrivateFieldGet(this, _ExtensionsManager_pmTransformers, "f")),
-            textParser: __classPrivateFieldGet(this, _ExtensionsManager_parserRegistry, "f").createParser(schema, __classPrivateFieldGet(this, _ExtensionsManager_mdForText, "f"), __classPrivateFieldGet(this, _ExtensionsManager_pmTransformers, "f")),
-            serializer: __classPrivateFieldGet(this, _ExtensionsManager_serializerRegistry, "f").createSerializer(),
+            actions,
+            markupParser,
+            textParser,
+            serializer,
         }, "f");
     }
     createDerived() {
@@ -97,4 +113,4 @@ export class ExtensionsManager {
         }
     }
 }
-_ExtensionsManager_schemaRegistry = new WeakMap(), _ExtensionsManager_parserRegistry = new WeakMap(), _ExtensionsManager_serializerRegistry = new WeakMap(), _ExtensionsManager_nodeViewCreators = new WeakMap(), _ExtensionsManager_markViewCreators = new WeakMap(), _ExtensionsManager_pmTransformers = new WeakMap(), _ExtensionsManager_mdForMarkup = new WeakMap(), _ExtensionsManager_mdForText = new WeakMap(), _ExtensionsManager_extensions = new WeakMap(), _ExtensionsManager_builder = new WeakMap(), _ExtensionsManager_spec = new WeakMap(), _ExtensionsManager_deps = new WeakMap(), _ExtensionsManager_plugins = new WeakMap(), _ExtensionsManager_actions = new WeakMap(), _ExtensionsManager_nodeViews = new WeakMap(), _ExtensionsManager_markViews = new WeakMap();
+_ExtensionsManager_schemaRegistry = new WeakMap(), _ExtensionsManager_parserRegistry = new WeakMap(), _ExtensionsManager_serializerRegistry = new WeakMap(), _ExtensionsManager_nodeViewCreators = new WeakMap(), _ExtensionsManager_markViewCreators = new WeakMap(), _ExtensionsManager_pmTransformers = new WeakMap(), _ExtensionsManager_mdForMarkup = new WeakMap(), _ExtensionsManager_mdForText = new WeakMap(), _ExtensionsManager_extensions = new WeakMap(), _ExtensionsManager_builder = new WeakMap(), _ExtensionsManager_spec = new WeakMap(), _ExtensionsManager_deps = new WeakMap(), _ExtensionsManager_plugins = new WeakMap(), _ExtensionsManager_actions = new WeakMap(), _ExtensionsManager_nodeViews = new WeakMap(), _ExtensionsManager_markViews = new WeakMap(), _ExtensionsManager_serializerDynamicModifier = new WeakMap(), _ExtensionsManager_parserDynamicModifier = new WeakMap();

package/build/esm/core/ParserTokensRegistry.d.ts

@@ -1,9 +1,10 @@
 import type MarkdownIt from 'markdown-it';
 import type { Schema } from 'prosemirror-model';
+import { MarkdownParserDynamicModifier } from './markdown/MarkdownParser';
 import { TransformFn } from './markdown/ProseMirrorTransformer';
 import type { Parser, ParserToken } from './types/parser';
 export declare class ParserTokensRegistry {
     #private;
     addToken(name: string, token: ParserToken): this;
-    createParser(schema: Schema, tokenizer: MarkdownIt, pmTransformers: TransformFn[]): Parser;
+    createParser(schema: Schema, tokenizer: MarkdownIt, pmTransformers: TransformFn[], dynamicModifier?: MarkdownParserDynamicModifier): Parser;
 }

package/build/esm/core/ParserTokensRegistry.js

@@ -9,8 +9,8 @@ export class ParserTokensRegistry {
         __classPrivateFieldGet(this, _ParserTokensRegistry_tokens, "f")[name] = token;
         return this;
     }
-    createParser(schema, tokenizer, pmTransformers) {
-        return new MarkdownParser(schema, tokenizer, __classPrivateFieldGet(this, _ParserTokensRegistry_tokens, "f"), pmTransformers);
+    createParser(schema, tokenizer, pmTransformers, dynamicModifier) {
+        return new MarkdownParser(schema, tokenizer, __classPrivateFieldGet(this, _ParserTokensRegistry_tokens, "f"), pmTransformers, dynamicModifier);
     }
 }
 _ParserTokensRegistry_tokens = new WeakMap();

package/build/esm/core/SchemaDynamicModifier.d.ts

@@ -0,0 +1,3 @@
+export declare type TokenAttrs = {
+    [name: string]: unknown;
+};

package/build/esm/core/SchemaDynamicModifier.js

@@ -0,0 +1,21 @@
+/** @internal */
+export class SchemaDynamicModifier {
+    constructor(config) {
+        this.nodeSpecsProcessors = new Map(Object.entries(config));
+    }
+    processNodeSpec(name, nodeSpec) {
+        let updatedSpec = nodeSpec;
+        this.nodeSpecsProcessors.forEach((processor, elementType) => {
+            if (name === elementType &&
+                processor.allowedAttrs &&
+                processor.allowedAttrs.length > 0 &&
+                nodeSpec) {
+                updatedSpec = Object.assign(Object.assign({}, nodeSpec), { attrs: Object.assign(Object.assign({}, nodeSpec.attrs), processor.allowedAttrs.reduce((acc, key) => {
+                        acc[key] = { default: null };
+                        return acc;
+                    }, {})) });
+            }
+        });
+        return updatedSpec;
+    }
+}

package/build/esm/core/SchemaSpecRegistry.d.ts

@@ -1,7 +1,8 @@
 import { MarkSpec, NodeSpec, Schema } from 'prosemirror-model';
+import { SchemaDynamicModifier } from './SchemaDynamicModifier';
 export declare class SchemaSpecRegistry {
     #private;
-    constructor(topNode?: string);
+    constructor(topNode?: string, dynamicModifier?: SchemaDynamicModifier);
     addNode(name: string, spec: NodeSpec): this;
     addMark(name: string, spec: MarkSpec): this;
     createSchema(): Schema<string, string>;

package/build/esm/core/SchemaSpecRegistry.js

@@ -1,13 +1,18 @@
-var _SchemaSpecRegistry_spec;
+var _SchemaSpecRegistry_spec, _SchemaSpecRegistry_dynamicModifier;
 import { __classPrivateFieldGet, __classPrivateFieldSet } from "tslib";
 import { Schema } from 'prosemirror-model';
 export class SchemaSpecRegistry {
-    constructor(topNode) {
+    constructor(topNode, dynamicModifier) {
         _SchemaSpecRegistry_spec.set(this, void 0);
+        _SchemaSpecRegistry_dynamicModifier.set(this, void 0);
         __classPrivateFieldSet(this, _SchemaSpecRegistry_spec, { topNode, nodes: {}, marks: {} }, "f");
+        __classPrivateFieldSet(this, _SchemaSpecRegistry_dynamicModifier, dynamicModifier, "f");
     }
     addNode(name, spec) {
-        __classPrivateFieldGet(this, _SchemaSpecRegistry_spec, "f").nodes[name] = spec;
+        const modifiedSpec = __classPrivateFieldGet(this, _SchemaSpecRegistry_dynamicModifier, "f")
+            ? __classPrivateFieldGet(this, _SchemaSpecRegistry_dynamicModifier, "f").processNodeSpec(name, spec)
+            : spec;
+        __classPrivateFieldGet(this, _SchemaSpecRegistry_spec, "f").nodes[name] = modifiedSpec;
         return this;
     }
     addMark(name, spec) {
@@ -18,4 +23,4 @@ export class SchemaSpecRegistry {
         return new Schema(__classPrivateFieldGet(this, _SchemaSpecRegistry_spec, "f"));
     }
 }
-_SchemaSpecRegistry_spec = new WeakMap();
+_SchemaSpecRegistry_spec = new WeakMap(), _SchemaSpecRegistry_dynamicModifier = new WeakMap();

package/build/esm/core/SerializerTokensRegistry.d.ts

@@ -1,7 +1,8 @@
+import { MarkdownSerializerDynamicModifier } from './markdown/MarkdownSerializerDynamicModifier';
 import type { Serializer, SerializerMarkToken, SerializerNodeToken } from './types/serializer';
 export declare class SerializerTokensRegistry {
     #private;
     addNode(name: string, node: SerializerNodeToken): this;
     addMark(name: string, mark: SerializerMarkToken): this;
-    createSerializer(): Serializer;
+    createSerializer(dynamicModifier?: MarkdownSerializerDynamicModifier): Serializer;
 }

package/build/esm/core/SerializerTokensRegistry.js

@@ -14,8 +14,8 @@ export class SerializerTokensRegistry {
         __classPrivateFieldGet(this, _SerializerTokensRegistry_marks, "f")[name] = mark;
         return this;
     }
-    createSerializer() {
-        return new MarkdownSerializer(__classPrivateFieldGet(this, _SerializerTokensRegistry_nodes, "f"), __classPrivateFieldGet(this, _SerializerTokensRegistry_marks, "f"));
+    createSerializer(dynamicModifier) {
+        return new MarkdownSerializer(__classPrivateFieldGet(this, _SerializerTokensRegistry_nodes, "f"), __classPrivateFieldGet(this, _SerializerTokensRegistry_marks, "f"), dynamicModifier);
     }
 }
 _SerializerTokensRegistry_nodes = new WeakMap(), _SerializerTokensRegistry_marks = new WeakMap();

package/build/esm/core/index.d.ts

@@ -9,3 +9,5 @@ export type { Extension, ExtensionAuto, ExtensionWithOptions, ExtensionDeps, Ext
 export type { Parser, ParserToken } from './types/parser';
 export type { Serializer, SerializerState, SerializerNodeToken, SerializerMarkToken, } from './types/serializer';
 export type { NodeViewConstructor, MarkViewConstructor } from './types/node-views';
+export type { MarkdownParserDynamicModifierConfig } from './markdown/MarkdownParser';
+export type { MarkdownSerializerDynamicModifierConfig } from './markdown/MarkdownSerializerDynamicModifier';

package/build/esm/core/markdown/MarkdownParser.d.ts

@@ -1,9 +1,10 @@
 import type { Match } from 'linkify-it';
 import type MarkdownIt from 'markdown-it';
+import type Token from 'markdown-it/lib/token';
 import { Mark, Node, NodeType, Schema } from 'prosemirror-model';
 import type { Parser, ParserToken } from '../types/parser';
 import { TransformFn } from './ProseMirrorTransformer';
-declare type TokenAttrs = {
+export declare type TokenAttrs = {
     [name: string]: unknown;
 };
 export declare class MarkdownParser implements Parser {
@@ -17,7 +18,8 @@ export declare class MarkdownParser implements Parser {
     tokens: Record<string, ParserToken>;
     tokenizer: MarkdownIt;
     pmTransformers: TransformFn[];
-    constructor(schema: Schema, tokenizer: MarkdownIt, tokens: Record<string, ParserToken>, pmTransformers: TransformFn[]);
+    dynamicModifier: MarkdownParserDynamicModifier | null;
+    constructor(schema: Schema, tokenizer: MarkdownIt, tokens: Record<string, ParserToken>, pmTransformers: TransformFn[], dynamicModifier?: MarkdownParserDynamicModifier);
     validateLink(url: string): boolean;
     normalizeLink(url: string): string;
     normalizeLinkText(url: string): string;
@@ -30,6 +32,7 @@ export declare class MarkdownParser implements Parser {
     private getTokenType;
     private handlePrimitiveToken;
     private handleMark;
+    private getNodeSchema;
     private handleNode;
     private handleBlock;
     private handleToken;
@@ -41,4 +44,5 @@ export declare class MarkdownParser implements Parser {
     private closeMark;
     private parseTokens;
 }
-export {};
+export declare type ProcessNodeAttrs = (token: Token, attrs: TokenAttrs, allowedAttrs?: string[]) => TokenAttrs;
+export declare type ProcessNode = (node: Node) => Node;

package/build/esm/core/markdown/MarkdownParser.js

@@ -9,14 +9,23 @@ var TokenType;
     TokenType["close"] = "close";
     TokenType["default"] = "default";
 })(TokenType || (TokenType = {}));
+/**
+ * Remove suffixes from the node name.
+ * Crops specified `openSuffix` and `closeSuffix` from the end of the given `tokName`.
+ */
+function cropNodeName(tokName, openSuffix, closeSuffix) {
+    const regex = new RegExp(`(${openSuffix})$|(${closeSuffix})$`);
+    return tokName.replace(regex, '');
+}
 export class MarkdownParser {
-    constructor(schema, tokenizer, tokens, pmTransformers) {
+    constructor(schema, tokenizer, tokens, pmTransformers, dynamicModifier) {
         this.stack = [];
         this.schema = schema;
         this.marks = Mark.none;
         this.tokens = tokens;
         this.tokenizer = tokenizer;
         this.pmTransformers = pmTransformers;
+        this.dynamicModifier = dynamicModifier !== null && dynamicModifier !== void 0 ? dynamicModifier : null;
     }
     validateLink(url) {
         return this.tokenizer.validateLink(url);
@@ -37,6 +46,9 @@ export class MarkdownParser {
             let mdItTokens;
             try {
                 mdItTokens = this.tokenizer.parse(text, {});
+                if (this.dynamicModifier) {
+                    mdItTokens = this.dynamicModifier.processTokens(mdItTokens, text);
+                }
             }
             catch (err) {
                 const e = err;
@@ -65,11 +77,20 @@ export class MarkdownParser {
     }
     //#region helpers
     getTokenAttrs(token, tokenSpec, tokenStream, i) {
-        if (tokenSpec.getAttrs)
-            return tokenSpec.getAttrs(token, tokenStream, i);
-        else if (tokenSpec.attrs instanceof Function)
-            return tokenSpec.attrs(token);
-        return tokenSpec.attrs;
+        let attrs = {};
+        if (tokenSpec.getAttrs) {
+            attrs = tokenSpec.getAttrs(token, tokenStream, i);
+        }
+        else if (tokenSpec.attrs instanceof Function) {
+            attrs = tokenSpec.attrs(token);
+        }
+        else {
+            attrs = tokenSpec.attrs;
+        }
+        if (this.dynamicModifier) {
+            attrs = this.dynamicModifier.processAttrs(token, attrs !== null && attrs !== void 0 ? attrs : {});
+        }
+        return attrs;
     }
     getTokenSpec(token) {
         var _a;
@@ -77,12 +98,14 @@ export class MarkdownParser {
         let tokName = ((_a = token.meta) === null || _a === void 0 ? void 0 : _a['pm-node']) || token.type;
         // Cropping _open and _close from node name end
         // e.g. paragraph_open -> paragraph
-        tokName = tokName.replace(new RegExp(`(${openSuffix})$|(${closeSuffix})$`), '');
+        tokName = cropNodeName(tokName, openSuffix, closeSuffix);
         let tokenSpec;
-        if (tokName in this.tokens)
+        if (tokName in this.tokens) {
             tokenSpec = this.tokens[tokName];
-        if (!tokenSpec)
+        }
+        if (!tokenSpec) {
             throw new RangeError(`No token spec for token: ${JSON.stringify(token)}`);
+        }
         return tokenSpec;
     }
     // Getting token type from its name
@@ -136,14 +159,18 @@ export class MarkdownParser {
             }
         }
     }
+    getNodeSchema(tokenSpec) {
+        const spec = this.schema.nodes[tokenSpec.name];
+        return spec;
+    }
     handleNode(_token, tokenSpec, attrs) {
-        const schemaSpec = this.schema.nodes[tokenSpec.name];
+        const schemaSpec = this.getNodeSchema(tokenSpec);
         // Adding node as is, becasuse it doesn't contain content.
         this.addNode(schemaSpec, attrs);
     }
     handleBlock(token, tokenSpec, attrs) {
         var _a;
-        const schemaSpec = this.schema.nodes[tokenSpec.name];
+        const schemaSpec = this.getNodeSchema(tokenSpec);
         if (tokenSpec.noCloseToken) {
             this.openNode(schemaSpec, attrs);
             if (tokenSpec.contentField === 'children' && ((_a = token.children) === null || _a === void 0 ? void 0 : _a.length)) {
@@ -186,9 +213,13 @@ export class MarkdownParser {
     //#endregion
     //#region state methods
     addNode(type, attrs, content) {
-        const node = type.createAndFill(attrs, content, this.marks);
-        if (!node)
+        let node = type.createAndFill(attrs, content, this.marks);
+        if (!node) {
             return null;
+        }
+        if (this.dynamicModifier) {
+            node = this.dynamicModifier.processNodes(node);
+        }
         this.push(node);
         return node;
     }
@@ -197,11 +228,13 @@ export class MarkdownParser {
     }
     closeNode() {
         // Marks operate within a node. Therefore, when we close the node, we reset the existing marks.
-        if (this.marks.length)
+        if (this.marks.length) {
             this.marks = Mark.none;
+        }
         const info = this.stack.pop();
-        if (info)
+        if (info) {
             return this.addNode(info.type, info.attrs, info.content);
+        }
         return null;
     }
     addText(text) {
@@ -248,3 +281,38 @@ function maybeMerge(a, b) {
 function withoutTrailingNewline(str) {
     return str[str.length - 1] === '\n' || str.endsWith('\\n') ? str.slice(0, str.length - 1) : str;
 }
+/** @internal */
+export class MarkdownParserDynamicModifier {
+    constructor(config) {
+        this.elementProcessors = new Map(Object.entries(config));
+    }
+    processTokens(tokens, rawMarkup) {
+        return tokens.map((token, index) => {
+            const processor = this.elementProcessors.get(cropNodeName(token.type, openSuffix, ''));
+            if (!processor || !processor.processToken || processor.processToken.length === 0) {
+                return token;
+            }
+            return processor.processToken.reduce((currentToken, process) => {
+                return process(currentToken, index, rawMarkup);
+            }, token);
+        });
+    }
+    processAttrs(token, attrs) {
+        const processor = this.elementProcessors.get(cropNodeName(token.type, openSuffix, ''));
+        if (!processor || !processor.processNodeAttrs || processor.processNodeAttrs.length === 0) {
+            return attrs;
+        }
+        return processor.processNodeAttrs.reduce((currentAttrs, process) => {
+            return process(token, currentAttrs);
+        }, attrs);
+    }
+    processNodes(node) {
+        const processor = this.elementProcessors.get(node.type.name);
+        if (!processor || !processor.processNode || processor.processNode.length === 0) {
+            return node;
+        }
+        return processor.processNode.reduce((currentNode, process) => {
+            return process(currentNode);
+        }, node);
+    }
+}