@acorex/cdk 22.4.8 → 22.4.11

package/fesm2022/acorex-cdk-text-editor.mjs

@@ -0,0 +1,942 @@
+import { isPlatformBrowser } from '@angular/common';
+import * as i0 from '@angular/core';
+import { signal, inject, PLATFORM_ID, Injectable } from '@angular/core';
+
+const AX_TEXT_EDITOR_FONT_SIZE_TOKEN_VALUES = {
+    small: '0.75em',
+    large: '1.5em',
+    huge: '2.5em',
+};
+const AX_TEXT_EDITOR_ZOOM_PRESETS = [40, 50, 75, 90, 100, 125, 150, 175, 200];
+const AX_TEXT_EDITOR_ZOOM_MIN = 40;
+const AX_TEXT_EDITOR_ZOOM_MAX = 200;
+const AX_TEXT_EDITOR_FONT_SIZES = [8, 9, 10, 11, 12, 14, 16, 18, 20, 24, 28, 32, 36, 48, 72];
+const AX_TEXT_EDITOR_DEFAULT_TEXT_COLORS = [
+    '#f59e0b',
+    '#eab308',
+    '#22c55e',
+    '#06b6d4',
+    '#3b82f6',
+    '#a855f7',
+    '#ec4899',
+    '#ef4444',
+];
+const AX_TEXT_EDITOR_DEFAULT_BACKGROUND_COLORS = [
+    '#ffffff',
+    '#f5e6c8',
+    '#fde68a',
+    '#f9a8d4',
+    '#bbf7d0',
+    '#ddd6fe',
+    '#fbcfe8',
+    '#fdba74',
+];
+const AX_DEFAULT_TEXT_EDITOR_FEATURES = {
+    table: true,
+    image: true,
+    video: true,
+    superscript: true,
+    subscript: true,
+    keepSelection: true,
+    placeholder: true,
+};
+const AX_EMPTY_TEXT_EDITOR_STATE = {
+    bold: false,
+    italic: false,
+    underline: false,
+    strike: false,
+    code: false,
+    codeBlock: false,
+    headingLevel: null,
+    bulletList: false,
+    orderedList: false,
+    blockquote: false,
+    superscript: false,
+    subscript: false,
+    textAlign: null,
+    textColor: null,
+    highlightColor: null,
+    linkHref: null,
+    fontSize: null,
+    textDirection: null,
+    table: false,
+    canUndo: false,
+    canRedo: false,
+    isEmpty: true,
+    isFocused: false,
+};
+
+class AXTextEditor {
+    constructor() {
+        this.editor = signal(null, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "editor" }] : /* istanbul ignore next */ []));
+        this.state = signal(AX_EMPTY_TEXT_EDITOR_STATE, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "state" }] : /* istanbul ignore next */ []));
+        this.ready = signal(false, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "ready" }] : /* istanbul ignore next */ []));
+        this.version = signal(0, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "version" }] : /* istanbul ignore next */ []));
+        this.platformId = inject(PLATFORM_ID);
+        this.destroyed = false;
+        this.applyingContent = false;
+        this.commandsApi = null;
+    }
+    async init(container, options = {}) {
+        if (!isPlatformBrowser(this.platformId)) {
+            return;
+        }
+        const element = typeof container === 'string' ? document.querySelector(container) : container;
+        if (!element) {
+            return;
+        }
+        this.destroyed = false;
+        const editable = options.readOnly === true ? false : (options.editable ?? true);
+        const [{ createTextEditorExtensions }, commandsApi, { Editor }] = await Promise.all([
+            Promise.resolve().then(function () { return textEditor_extensions; }),
+            Promise.resolve().then(function () { return textEditor_commands; }),
+            import('@tiptap/core'),
+        ]);
+        this.commandsApi = commandsApi;
+        const extensions = await createTextEditorExtensions({
+            placeholder: options.placeholder,
+            features: options.features,
+            headingLevels: options.headingLevels,
+            extensions: options.extensions,
+        });
+        if (this.destroyed) {
+            return;
+        }
+        const editor = new Editor({
+            element,
+            extensions,
+            content: options.content ?? '',
+            editable,
+            editorProps: {
+                ...options.editorProps,
+                attributes: {
+                    class: 'ax-text-editor-prose',
+                    ...(typeof options.editorProps?.attributes === 'object' ? options.editorProps.attributes : {}),
+                },
+                handleDOMEvents: {
+                    ...options.editorProps?.handleDOMEvents,
+                },
+            },
+            onUpdate: ({ editor: ed }) => {
+                this.refreshState(ed);
+                if (!this.applyingContent) {
+                    options.onUpdate?.(ed);
+                }
+            },
+            onSelectionUpdate: ({ editor: ed }) => {
+                this.refreshState(ed);
+                options.onSelectionUpdate?.(ed);
+            },
+            onTransaction: ({ editor: ed }) => {
+                this.refreshState(ed);
+                options.onTransaction?.(ed);
+            },
+            onFocus: ({ editor: ed, event }) => {
+                this.refreshState(ed);
+                options.onFocus?.(ed, event);
+            },
+            onBlur: ({ editor: ed, event }) => {
+                this.refreshState(ed);
+                options.onBlur?.(ed, event);
+            },
+        });
+        this.editor.set(editor);
+        this.ready.set(true);
+        this.refreshState(editor);
+    }
+    destroy() {
+        this.destroyed = true;
+        const ed = this.editor();
+        ed?.destroy();
+        this.editor.set(null);
+        this.ready.set(false);
+        this.state.set(AX_EMPTY_TEXT_EDITOR_STATE);
+        this.version.set(0);
+        this.commandsApi = null;
+    }
+    refresh() {
+        const ed = this.editor();
+        if (ed) {
+            this.refreshState(ed);
+        }
+    }
+    setContent(value, emit = false) {
+        const ed = this.editor();
+        if (!ed) {
+            return;
+        }
+        const content = value == null || value === '' ? '' : value;
+        this.applyingContent = true;
+        try {
+            ed.commands.setContent(content, { emitUpdate: emit });
+            this.refreshState(ed);
+        }
+        finally {
+            this.applyingContent = false;
+        }
+    }
+    getHTML() {
+        return this.editor()?.getHTML() ?? '';
+    }
+    getJSON() {
+        return this.editor()?.getJSON() ?? null;
+    }
+    getText(options) {
+        return this.editor()?.getText(options) ?? '';
+    }
+    isEmpty() {
+        return this.editor()?.isEmpty ?? true;
+    }
+    isFocused() {
+        return this.editor()?.isFocused ?? false;
+    }
+    isEditable() {
+        return this.editor()?.isEditable ?? false;
+    }
+    setEditable(editable) {
+        const ed = this.editor();
+        if (!ed || ed.isEditable === editable) {
+            return;
+        }
+        ed.setEditable(editable, false);
+        this.refreshState(ed);
+    }
+    focus() {
+        this.editor()?.commands.focus();
+    }
+    blur() {
+        this.editor()?.commands.blur();
+    }
+    chain() {
+        return this.editor()?.chain() ?? null;
+    }
+    get commands() {
+        return this.editor()?.commands;
+    }
+    isActive(command, attrs) {
+        this.version();
+        const ed = this.editor();
+        if (!ed) {
+            return false;
+        }
+        return this.getCommandsApi().isTextEditorCommandActive(ed, command, attrs);
+    }
+    can(command, attrs) {
+        this.version();
+        const ed = this.editor();
+        if (!ed || !ed.isEditable) {
+            return false;
+        }
+        return this.getCommandsApi().canRunTextEditorCommand(ed, command, attrs);
+    }
+    run(command, attrs) {
+        const ed = this.editor();
+        if (!ed || !ed.isEditable) {
+            return false;
+        }
+        const result = this.getCommandsApi().runTextEditorCommand(ed, command, attrs);
+        this.refreshState(ed);
+        return result;
+    }
+    getCommandsApi() {
+        if (!this.commandsApi) {
+            throw new Error('AXTextEditor commands are not loaded. Call init() first.');
+        }
+        return this.commandsApi;
+    }
+    insertContent(value) {
+        const result = this.editor()?.chain().focus().insertContent(value).run() ?? false;
+        this.refresh();
+        return result;
+    }
+    clearContent() {
+        const result = this.editor()?.commands.clearContent() ?? false;
+        this.refresh();
+        return result;
+    }
+    insertImage(src, alt) {
+        this.run('image', { src, alt });
+    }
+    insertVideo(src) {
+        this.run('video', { src });
+    }
+    setLink(href) {
+        this.run('link', { href });
+    }
+    unsetLink() {
+        this.run('unlink');
+    }
+    clearFormatting() {
+        this.editor()?.chain().focus().clearNodes().unsetAllMarks().run();
+        this.refresh();
+    }
+    toggleHeading(level) {
+        this.run('heading', { level });
+    }
+    setTextAlign(align) {
+        this.run('align', { align });
+    }
+    setTextDirection(direction) {
+        this.run('direction', { direction });
+    }
+    refreshState(editor) {
+        this.version.update((value) => value + 1);
+        const textColor = editor.getAttributes('textStyle')['color'];
+        const fontSizeCss = editor.getAttributes('textStyle')['fontSize'];
+        const highlightColor = editor.getAttributes('highlight')['color'];
+        const linkHref = editor.getAttributes('link')['href'];
+        const dir = (editor.getAttributes('paragraph')['dir'] || editor.getAttributes('heading')['dir']);
+        let headingLevel = null;
+        for (let level = 1; level <= 6; level++) {
+            if (editor.isActive('heading', { level })) {
+                headingLevel = level;
+                break;
+            }
+        }
+        let textAlign = null;
+        for (const align of ['left', 'center', 'right', 'justify']) {
+            if (editor.isActive({ textAlign: align })) {
+                textAlign = align;
+                break;
+            }
+        }
+        this.state.set({
+            bold: editor.isActive('bold'),
+            italic: editor.isActive('italic'),
+            underline: editor.isActive('underline'),
+            strike: editor.isActive('strike'),
+            code: editor.isActive('code'),
+            codeBlock: editor.isActive('codeBlock'),
+            headingLevel,
+            bulletList: editor.isActive('bulletList'),
+            orderedList: editor.isActive('orderedList'),
+            blockquote: editor.isActive('blockquote'),
+            superscript: editor.isActive('superscript'),
+            subscript: editor.isActive('subscript'),
+            textAlign,
+            textColor: textColor ?? null,
+            highlightColor: highlightColor ?? null,
+            linkHref: linkHref ?? null,
+            fontSize: fontSizeCss ?? null,
+            textDirection: dir ?? null,
+            table: editor.isActive('table'),
+            canUndo: editor.can().undo(),
+            canRedo: editor.can().redo(),
+            isEmpty: editor.isEmpty,
+            isFocused: editor.isFocused,
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.6", ngImport: i0, type: AXTextEditor, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.1.6", ngImport: i0, type: AXTextEditor }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.6", ngImport: i0, type: AXTextEditor, decorators: [{
+            type: Injectable
+        }] });
+
+function escapeHtml(value) {
+    return value.replaceAll('&', '&amp;').replaceAll('<', '&lt;').replaceAll('>', '&gt;').replaceAll('"', '&quot;');
+}
+function normalizeHref(value) {
+    const href = value.trim();
+    if (!href)
+        return '';
+    if (/^(https?:|mailto:|tel:|#|\/)/i.test(href))
+        return href;
+    return `https://${href}`;
+}
+function headingLevel(attrs) {
+    const level = Number(attrs?.['level']);
+    if (level >= 1 && level <= 6) {
+        return level;
+    }
+    return undefined;
+}
+function resolveFontSize(attrs) {
+    const raw = attrs?.['size'];
+    if (raw == null || raw === '') {
+        return null;
+    }
+    const size = String(raw);
+    if (size === 'small' || size === 'large' || size === 'huge') {
+        return AX_TEXT_EDITOR_FONT_SIZE_TOKEN_VALUES[size];
+    }
+    return size;
+}
+function isTextEditorCommandActive(editor, command, attrs) {
+    switch (command) {
+        case 'heading': {
+            const level = headingLevel(attrs);
+            return level ? editor.isActive('heading', { level }) : editor.isActive('heading');
+        }
+        case 'paragraph':
+            return editor.isActive('paragraph');
+        case 'align':
+            return editor.isActive({ textAlign: attrs?.['align'] });
+        case 'direction':
+            return editor.isActive({ dir: attrs?.['direction'] });
+        case 'link':
+            return editor.isActive('link');
+        case 'image':
+            return editor.isActive('image');
+        case 'video':
+            return editor.isActive('video');
+        case 'fontSize':
+            return Boolean(editor.getAttributes('textStyle')?.['fontSize']);
+        case 'insertTable':
+            return editor.isActive('table');
+        case 'unlink':
+        case 'color':
+        case 'highlight':
+        case 'undo':
+        case 'redo':
+        case 'horizontalRule':
+            return false;
+        default:
+            return editor.isActive(command);
+    }
+}
+function canRunTextEditorCommand(editor, command, attrs) {
+    switch (command) {
+        case 'undo':
+            return editor.can().undo();
+        case 'redo':
+            return editor.can().redo();
+        case 'heading': {
+            const level = headingLevel(attrs);
+            return level ? editor.can().setHeading({ level }) : editor.can().setParagraph();
+        }
+        case 'paragraph':
+            return editor.can().setParagraph();
+        case 'align':
+            return editor.can().setTextAlign(String(attrs?.['align'] ?? 'left'));
+        case 'direction':
+            return true;
+        case 'color':
+            return attrs?.['color'] ? editor.can().setColor(String(attrs['color'])) : editor.can().unsetColor();
+        case 'highlight':
+            return attrs?.['color']
+                ? editor.can().setHighlight({ color: String(attrs['color']) })
+                : editor.can().unsetHighlight();
+        case 'fontSize':
+            return editor.isEditable;
+        case 'link':
+            return editor.isEditable;
+        case 'unlink':
+            return editor.isEditable && editor.can().unsetLink();
+        case 'image':
+        case 'video':
+            return editor.isEditable;
+        case 'insertTable':
+            return editor.can().insertTable({
+                rows: Number(attrs?.['rows'] ?? 3),
+                cols: Number(attrs?.['cols'] ?? 3),
+                withHeaderRow: Boolean(attrs?.['withHeaderRow'] ?? false),
+            });
+        case 'addColumnBefore':
+            return editor.can().addColumnBefore();
+        case 'addColumnAfter':
+            return editor.can().addColumnAfter();
+        case 'deleteColumn':
+            return editor.can().deleteColumn();
+        case 'addRowBefore':
+            return editor.can().addRowBefore();
+        case 'addRowAfter':
+            return editor.can().addRowAfter();
+        case 'deleteRow':
+            return editor.can().deleteRow();
+        case 'toggleHeaderRow':
+            return editor.can().toggleHeaderRow();
+        case 'deleteTable':
+            return editor.can().deleteTable();
+        case 'blockquote':
+            return editor.can().toggleBlockquote();
+        case 'code':
+            return editor.can().toggleCode();
+        case 'codeBlock':
+            return editor.can().toggleCodeBlock();
+        case 'horizontalRule':
+            return editor.can().setHorizontalRule();
+        case 'bulletList':
+            return editor.isEditable && Boolean(editor.schema.nodes['bulletList']);
+        case 'orderedList':
+            return editor.isEditable && Boolean(editor.schema.nodes['orderedList']);
+        case 'superscript':
+            return editor.can().toggleSuperscript();
+        case 'subscript':
+            return editor.can().toggleSubscript();
+        case 'bold':
+            return editor.can().toggleBold();
+        case 'italic':
+            return editor.can().toggleItalic();
+        case 'underline':
+            return editor.can().toggleUnderline();
+        case 'strike':
+            return editor.can().toggleStrike();
+        default:
+            return false;
+    }
+}
+function runTextEditorCommand(editor, command, attrs) {
+    const chain = editor.chain().focus();
+    switch (command) {
+        case 'undo':
+            return chain.undo().run();
+        case 'redo':
+            return chain.redo().run();
+        case 'heading': {
+            const level = headingLevel(attrs);
+            return level ? chain.setHeading({ level }).run() : chain.setParagraph().run();
+        }
+        case 'paragraph':
+            return chain.setParagraph().run();
+        case 'align':
+            return chain.setTextAlign(String(attrs?.['align'] ?? 'left')).run();
+        case 'direction': {
+            const direction = attrs?.['direction'] === 'rtl' ? 'rtl' : 'ltr';
+            return chain
+                .updateAttributes('paragraph', { dir: direction })
+                .updateAttributes('heading', { dir: direction })
+                .run();
+        }
+        case 'color':
+            return attrs?.['color'] ? chain.setColor(String(attrs['color'])).run() : chain.unsetColor().run();
+        case 'highlight':
+            return attrs?.['color']
+                ? chain.setHighlight({ color: String(attrs['color']) }).run()
+                : chain.unsetHighlight().run();
+        case 'fontSize':
+            return chain.setFontSize(resolveFontSize(attrs)).run();
+        case 'link': {
+            const href = normalizeHref(String(attrs?.['href'] ?? ''));
+            if (!href) {
+                return chain.extendMarkRange('link').unsetLink().run();
+            }
+            if (editor.state.selection.empty) {
+                const safeHref = escapeHtml(href);
+                return chain.insertContent(`<a href="${safeHref}">${safeHref}</a>`).run();
+            }
+            return chain.extendMarkRange('link').setLink({ href }).run();
+        }
+        case 'unlink':
+            return chain.extendMarkRange('link').unsetLink().run();
+        case 'image': {
+            const src = String(attrs?.['src'] ?? '').trim();
+            if (!src)
+                return false;
+            return chain.setImage({ src, alt: String(attrs?.['alt'] ?? '') }).run();
+        }
+        case 'video': {
+            const src = String(attrs?.['src'] ?? '').trim();
+            if (!src)
+                return false;
+            return chain.setVideo({ src }).run();
+        }
+        case 'insertTable':
+            return chain
+                .insertTable({
+                rows: Number(attrs?.['rows'] ?? 3),
+                cols: Number(attrs?.['cols'] ?? 3),
+                withHeaderRow: Boolean(attrs?.['withHeaderRow'] ?? false),
+            })
+                .run();
+        case 'addColumnBefore':
+            return chain.addColumnBefore().run();
+        case 'addColumnAfter':
+            return chain.addColumnAfter().run();
+        case 'deleteColumn':
+            return chain.deleteColumn().run();
+        case 'addRowBefore':
+            return chain.addRowBefore().run();
+        case 'addRowAfter':
+            return chain.addRowAfter().run();
+        case 'deleteRow':
+            return chain.deleteRow().run();
+        case 'toggleHeaderRow':
+            return chain.toggleHeaderRow().run();
+        case 'deleteTable':
+            return chain.deleteTable().run();
+        case 'blockquote':
+            return chain.toggleBlockquote().run();
+        case 'code':
+            return chain.toggleCode().run();
+        case 'codeBlock':
+            return chain.toggleCodeBlock().run();
+        case 'horizontalRule':
+            return chain.setHorizontalRule().run();
+        case 'bulletList':
+            return chain.toggleBulletList().run();
+        case 'orderedList':
+            return chain.toggleOrderedList().run();
+        case 'superscript':
+            return chain.toggleSuperscript().run();
+        case 'subscript':
+            return chain.toggleSubscript().run();
+        case 'bold':
+            return chain.toggleBold().run();
+        case 'italic':
+            return chain.toggleItalic().run();
+        case 'underline':
+            return chain.toggleUnderline().run();
+        case 'strike':
+            return chain.toggleStrike().run();
+        default:
+            return false;
+    }
+}
+
+var textEditor_commands = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    canRunTextEditorCommand: canRunTextEditorCommand,
+    isTextEditorCommandActive: isTextEditorCommandActive,
+    runTextEditorCommand: runTextEditorCommand
+});
+
+function createSuperscript(core) {
+    return core.Mark.create({
+        name: 'superscript',
+        excludes: 'subscript',
+        parseHTML() {
+            return [{ tag: 'sup' }];
+        },
+        renderHTML({ HTMLAttributes }) {
+            return ['sup', core.mergeAttributes(HTMLAttributes), 0];
+        },
+        addCommands() {
+            return {
+                toggleSuperscript: () => ({ commands }) => commands.toggleMark(this.name),
+            };
+        },
+    });
+}
+function createSubscript(core) {
+    return core.Mark.create({
+        name: 'subscript',
+        excludes: 'superscript',
+        parseHTML() {
+            return [{ tag: 'sub' }];
+        },
+        renderHTML({ HTMLAttributes }) {
+            return ['sub', core.mergeAttributes(HTMLAttributes), 0];
+        },
+        addCommands() {
+            return {
+                toggleSubscript: () => ({ commands }) => commands.toggleMark(this.name),
+            };
+        },
+    });
+}
+function createKeepSelection(core, pmState, pmView) {
+    const keepSelectionKey = new pmState.PluginKey('axKeepSelection');
+    return core.Extension.create({
+        name: 'keepSelection',
+        addProseMirrorPlugins() {
+            return [
+                new pmState.Plugin({
+                    key: keepSelectionKey,
+                    state: {
+                        init() {
+                            return pmView.DecorationSet.empty;
+                        },
+                        apply(tr, set) {
+                            const meta = tr.getMeta(keepSelectionKey);
+                            if (meta === 'clear')
+                                return pmView.DecorationSet.empty;
+                            if (meta && meta.from !== meta.to) {
+                                return pmView.DecorationSet.create(tr.doc, [
+                                    pmView.Decoration.inline(meta.from, meta.to, { class: 'ax-text-editor-kept-selection' }),
+                                ]);
+                            }
+                            return set.map(tr.mapping, tr.doc);
+                        },
+                    },
+                    props: {
+                        decorations(state) {
+                            return keepSelectionKey.getState(state);
+                        },
+                        handleDOMEvents: {
+                            blur(view) {
+                                const { from, to } = view.state.selection;
+                                if (from !== to) {
+                                    view.dispatch(view.state.tr.setMeta(keepSelectionKey, { from, to }));
+                                }
+                                return false;
+                            },
+                            focus(view) {
+                                const decorations = keepSelectionKey.getState(view.state);
+                                if (decorations?.find().length) {
+                                    view.dispatch(view.state.tr.setMeta(keepSelectionKey, 'clear'));
+                                }
+                                return false;
+                            },
+                        },
+                    },
+                }),
+            ];
+        },
+    });
+}
+function createTextDirection(core) {
+    return core.Extension.create({
+        name: 'textDirection',
+        addGlobalAttributes() {
+            return [
+                {
+                    types: ['paragraph', 'heading'],
+                    attributes: {
+                        dir: {
+                            default: null,
+                            parseHTML: (element) => element.getAttribute('dir'),
+                            renderHTML: (attributes) => (attributes['dir'] ? { dir: attributes['dir'] } : {}),
+                        },
+                    },
+                },
+            ];
+        },
+    });
+}
+function createFontSize(core) {
+    return core.Extension.create({
+        name: 'axTextEditorFontSize',
+        addGlobalAttributes() {
+            return [
+                {
+                    types: ['textStyle'],
+                    attributes: {
+                        fontSize: {
+                            default: null,
+                            parseHTML: (element) => element.style.fontSize?.replace(/['"]+/g, '') || null,
+                            renderHTML: (attributes) => attributes['fontSize'] ? { style: `font-size: ${attributes['fontSize']}` } : {},
+                        },
+                    },
+                },
+            ];
+        },
+        addCommands() {
+            return {
+                setFontSize: (size) => ({ chain }) => {
+                    if (!size) {
+                        return chain().focus().setMark('textStyle', { fontSize: null }).removeEmptyTextStyle().run();
+                    }
+                    return chain().focus().setMark('textStyle', { fontSize: size }).run();
+                },
+            };
+        },
+    });
+}
+function createVideo(core) {
+    return core.Node.create({
+        name: 'video',
+        group: 'block',
+        atom: true,
+        addOptions() {
+            return {
+                HTMLAttributes: {},
+            };
+        },
+        addAttributes() {
+            return {
+                src: {
+                    default: null,
+                },
+            };
+        },
+        parseHTML() {
+            return [
+                { tag: 'video[src]' },
+                { tag: 'div[data-text-editor-video] video' },
+                { tag: 'div[data-wysiwyg-video] iframe' },
+                { tag: 'iframe[src]' },
+            ];
+        },
+        renderHTML({ HTMLAttributes }) {
+            const src = String(HTMLAttributes['src'] ?? '');
+            if (isEmbedSrc(src)) {
+                return [
+                    'div',
+                    core.mergeAttributes(this.options.HTMLAttributes, { 'data-text-editor-video': '' }),
+                    [
+                        'iframe',
+                        core.mergeAttributes({
+                            src,
+                            frameborder: '0',
+                            allowfullscreen: 'true',
+                            allow: 'accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture',
+                        }),
+                    ],
+                ];
+            }
+            return [
+                'video',
+                core.mergeAttributes(this.options.HTMLAttributes, HTMLAttributes, {
+                    class: 'ax-text-editor-video',
+                    controls: 'true',
+                }),
+            ];
+        },
+        addCommands() {
+            return {
+                setVideo: ({ src }) => ({ commands }) => commands.insertContent({
+                    type: this.name,
+                    attrs: { src: toVideoSrc(src) },
+                }),
+            };
+        },
+    });
+}
+function isEmbedSrc(src) {
+    return /youtube\.com\/embed\/|youtu\.be\//i.test(src);
+}
+function toVideoSrc(src) {
+    const trimmed = src.trim();
+    if (!trimmed)
+        return trimmed;
+    try {
+        const url = new URL(trimmed);
+        if (url.hostname.includes('youtube.com') && url.searchParams.get('v')) {
+            return `https://www.youtube.com/embed/${url.searchParams.get('v')}`;
+        }
+        if (url.hostname === 'youtu.be') {
+            return `https://www.youtube.com/embed/${url.pathname.slice(1)}`;
+        }
+    }
+    catch {
+        return trimmed;
+    }
+    return trimmed;
+}
+const DEFAULT_HEADING_LEVELS = [1, 2, 3];
+function resolvePlaceholder(placeholder) {
+    if (typeof placeholder === 'function') {
+        return placeholder();
+    }
+    return placeholder ?? '';
+}
+async function createTextEditorExtensions(placeholderOrOptions = '') {
+    const options = typeof placeholderOrOptions === 'function' || typeof placeholderOrOptions === 'string'
+        ? { placeholder: placeholderOrOptions }
+        : placeholderOrOptions;
+    const features = { ...AX_DEFAULT_TEXT_EDITOR_FEATURES, ...options.features };
+    const headingLevels = options.headingLevels ?? DEFAULT_HEADING_LEVELS;
+    const [core, pmState, pmView, starterKitMod, textStyleMod, highlightMod, textAlignMod, extensionsMod, tableMod, imageMod] = await Promise.all([
+        import('@tiptap/core'),
+        import('@tiptap/pm/state'),
+        import('@tiptap/pm/view'),
+        import('@tiptap/starter-kit'),
+        import('@tiptap/extension-text-style'),
+        import('@tiptap/extension-highlight'),
+        import('@tiptap/extension-text-align'),
+        import('@tiptap/extensions'),
+        import('@tiptap/extension-table/kit'),
+        import('@tiptap/extension-image'),
+    ]);
+    const Image = imageMod.default ?? imageMod.Image;
+    const Highlight = highlightMod.default ?? highlightMod.Highlight;
+    const extensions = [
+        starterKitMod.StarterKit.configure({
+            heading: {
+                levels: headingLevels,
+                HTMLAttributes: {
+                    class: 'ax-text-editor-heading',
+                },
+            },
+            link: {
+                openOnClick: false,
+                HTMLAttributes: {
+                    class: 'ax-text-editor-link',
+                },
+            },
+            code: {
+                HTMLAttributes: {
+                    class: 'ax-text-editor-code',
+                },
+            },
+            codeBlock: {
+                HTMLAttributes: {
+                    class: 'ax-text-editor-code-block',
+                },
+            },
+            bulletList: {
+                HTMLAttributes: {
+                    class: 'ax-text-editor-bullet-list',
+                },
+            },
+            orderedList: {
+                HTMLAttributes: {
+                    class: 'ax-text-editor-ordered-list',
+                },
+            },
+            listItem: {
+                HTMLAttributes: {
+                    class: 'ax-text-editor-list-item',
+                },
+            },
+        }),
+        textStyleMod.TextStyle,
+        textStyleMod.Color,
+        createFontSize(core),
+        Highlight.configure({ multicolor: true }),
+        textAlignMod.TextAlign.configure({
+            types: ['heading', 'paragraph'],
+        }),
+        createTextDirection(core),
+    ];
+    if (features.superscript) {
+        extensions.push(createSuperscript(core));
+    }
+    if (features.subscript) {
+        extensions.push(createSubscript(core));
+    }
+    if (features.keepSelection) {
+        extensions.push(createKeepSelection(core, pmState, pmView));
+    }
+    if (features.table) {
+        extensions.push(tableMod.TableKit.configure({
+            table: {
+                resizable: true,
+                lastColumnResizable: true,
+                cellMinWidth: 64,
+                HTMLAttributes: {
+                    class: 'ax-text-editor-table',
+                },
+            },
+        }));
+    }
+    if (features.image) {
+        extensions.push(Image.configure({
+            inline: true,
+            allowBase64: true,
+            HTMLAttributes: {
+                class: 'ax-text-editor-image',
+            },
+        }));
+    }
+    if (features.video) {
+        extensions.push(createVideo(core));
+    }
+    if (features.placeholder) {
+        extensions.push(extensionsMod.Placeholder.configure({
+            placeholder: () => resolvePlaceholder(options.placeholder),
+            showOnlyCurrent: true,
+        }));
+    }
+    if (options.extensions?.length) {
+        extensions.push(...options.extensions);
+    }
+    return extensions;
+}
+
+var textEditor_extensions = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    createTextEditorExtensions: createTextEditorExtensions
+});
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { AXTextEditor, AX_DEFAULT_TEXT_EDITOR_FEATURES, AX_EMPTY_TEXT_EDITOR_STATE, AX_TEXT_EDITOR_DEFAULT_BACKGROUND_COLORS, AX_TEXT_EDITOR_DEFAULT_TEXT_COLORS, AX_TEXT_EDITOR_FONT_SIZES, AX_TEXT_EDITOR_FONT_SIZE_TOKEN_VALUES, AX_TEXT_EDITOR_ZOOM_MAX, AX_TEXT_EDITOR_ZOOM_MIN, AX_TEXT_EDITOR_ZOOM_PRESETS, canRunTextEditorCommand, createTextEditorExtensions, isTextEditorCommandActive, runTextEditorCommand };
+//# sourceMappingURL=acorex-cdk-text-editor.mjs.map