@akilli/editor-src 5.1.5

package/base/CommandManager.js

@@ -0,0 +1,60 @@
+import Command from './Command.js';
+
+export default class CommandManager {
+    /**
+     * @type {Map<string, Command>}
+     */
+    #items = new Map();
+
+    /**
+     * @param {Command[]} [commands = []]
+     */
+    constructor(commands = []) {
+        commands.forEach((command) => this.set(command));
+    }
+
+    /**
+     * @param {string} name
+     * @return {Command|undefined}
+     */
+    get(name) {
+        return this.#items.get(name);
+    }
+
+    /**
+     * @param {Command} command
+     * @return {void}
+     */
+    set(command) {
+        if (!(command instanceof Command)) {
+            throw new TypeError('Invalid argument');
+        }
+
+        this.#items.set(command.name, command);
+    }
+
+    /**
+     * @param {string} tagName
+     * @return {Command|undefined}
+     */
+    findByTagName(tagName) {
+        return Array.from(this.#items.values()).find((command) => command.tag?.name === tagName);
+    }
+
+    /**
+     * @param {string} name
+     * @return {void}
+     */
+    execute(name) {
+        this.get(name).execute();
+    }
+
+    /**
+     * @return {void}
+     */
+    freeze() {
+        this.#items.forEach((command) => Object.freeze(command));
+        Object.freeze(this.#items);
+        Object.freeze(this);
+    }
+}

package/base/ContentFilter.js

@@ -0,0 +1,109 @@
+import Filter from './Filter.js';
+import TagGroup from './TagGroup.js';
+import TagName from './TagName.js';
+
+export default class ContentFilter extends Filter {
+    /**
+     * @param {HTMLElement} element
+     * @return {void}
+     */
+    filter(element) {
+        const tag = this.editor.tags.get(element);
+        const allowedParagraph = this.editor.tags.allowed(element, TagName.P);
+        const allowedText = tag.editable || tag.group === TagGroup.FORMAT;
+        let p = [];
+        const wrap = (ref = null) => {
+            if (allowedParagraph && p.length > 0) {
+                const newP = this.editor.dom.createElement(TagName.P, { html: p.join(' ') });
+
+                if (ref) {
+                    this.editor.dom.insertBefore(newP, ref);
+                } else {
+                    this.editor.dom.insertLastChild(newP, element);
+                }
+
+                p = [];
+            }
+        };
+
+        Array.from(element.childNodes).forEach((child) => {
+            const text = child.textContent.trim();
+
+            if (child instanceof HTMLElement) {
+                const realChild = this.#convert(child);
+                const childTag = this.editor.tags.get(realChild);
+
+                if (childTag && this.editor.tags.allowed(element, realChild)) {
+                    wrap(realChild);
+                    this.#filter(realChild, childTag);
+                } else if (childTag && childTag.group === TagGroup.FORMAT && allowedParagraph) {
+                    const filteredChild = this.#filter(realChild, childTag);
+
+                    if (filteredChild) {
+                        p.push(filteredChild.outerHTML);
+                        element.removeChild(filteredChild);
+                    }
+                } else if (!allowedText && text && allowedParagraph) {
+                    p.push(text);
+                    element.removeChild(realChild);
+                } else if (allowedText && text) {
+                    element.replaceChild(this.editor.dom.createText(text), realChild);
+                } else {
+                    element.removeChild(realChild);
+                }
+            } else if (child instanceof Text) {
+                if (!allowedText && text && allowedParagraph) {
+                    p.push(text);
+                }
+
+                if (!allowedText || !text) {
+                    element.removeChild(child);
+                }
+            } else if (child instanceof Node) {
+                element.removeChild(child);
+            }
+        });
+
+        wrap();
+    }
+
+    /**
+     * @param {HTMLElement} element
+     * @return {HTMLElement}
+     */
+    #convert(element) {
+        const name = this.editor.config.base.filter[element.localName];
+
+        if (!name) {
+            return element;
+        }
+
+        const convert = this.editor.dom.createElement(name, { html: element.innerHTML });
+        element.parentElement.replaceChild(convert, element);
+
+        return convert;
+    }
+
+    /**
+     * @param {HTMLElement} element
+     * @param {Tag} tag
+     * @return {HTMLElement|undefined}
+     */
+    #filter(element, tag) {
+        Array.from(element.attributes).forEach(
+            (item) => !tag.attributes.includes(item.name) && element.removeAttribute(item.name)
+        );
+
+        if (element.hasChildNodes()) {
+            this.editor.filters.filter(element);
+        }
+
+        if (element.hasChildNodes() || tag.empty) {
+            return element;
+        }
+
+        element.parentElement?.removeChild(element);
+
+        return undefined;
+    }
+}

package/base/DeletableListener.js

@@ -0,0 +1,36 @@
+import Key from './Key.js';
+import Listener from './Listener.js';
+
+export default class DeletableListener extends Listener {
+    /**
+     * @param {Editor} editor
+     */
+    constructor(editor) {
+        super(editor);
+        this.editor.root.addEventListener('insert', this);
+    }
+
+    /**
+     * @param {CustomEvent} event
+     * @param {HTMLElement} event.detail.element
+     * @return {void}
+     */
+    insert({ detail: { element } }) {
+        if (element.hasAttribute('data-deletable')) {
+            element.addEventListener('keydown', this);
+        }
+    }
+
+    /**
+     * @param {KeyboardEvent} event
+     * @param {HTMLElement} event.target
+     * @return {void}
+     */
+    keydown(event) {
+        if (event.target === event.currentTarget && Key.isEventFor(event, Key.DEL, { ctrl: true })) {
+            this.editor.dom.delete(event.target);
+            event.preventDefault();
+            event.stopPropagation();
+        }
+    }
+}

package/base/DeleteCommand.js

@@ -0,0 +1,18 @@
+import Command from './Command.js';
+
+export default class DeleteCommand extends Command {
+    /**
+     * @param {Editor} editor
+     */
+    constructor(editor) {
+        super(editor, 'delete');
+    }
+
+    /**
+     * @return {void}
+     */
+    execute() {
+        const element = this.editor.dom.getActiveElement();
+        element?.hasAttribute('data-deletable') && this.editor.dom.delete(element);
+    }
+}

package/base/Dialog.js

@@ -0,0 +1,153 @@
+import Editor from './Editor.js';
+import FormCreator from './FormCreator.js';
+import TagName from './TagName.js';
+import { is, isOptString, isString } from './util.js';
+
+export default class Dialog {
+    /**
+     * @type {Editor}
+     */
+    #editor;
+
+    /**
+     * @return {Editor}
+     */
+    get editor() {
+        return this.#editor;
+    }
+
+    /**
+     * @type {string}
+     */
+    #name;
+
+    /**
+     * @return {string}
+     */
+    get name() {
+        return this.#name;
+    }
+
+    /**
+     * @type {string|undefined}
+     */
+    #browserUrl;
+
+    /**
+     * @return {string|undefined}
+     */
+    get browserUrl() {
+        return this.#browserUrl;
+    }
+
+    /**
+     * @type {FormCreator|undefined}
+     */
+    #formCreator;
+
+    /**
+     * @type {FormCreator|undefined}
+     */
+    get formCreator() {
+        return this.#formCreator;
+    }
+
+    /**
+     * @param {Editor} editor
+     * @param {string} name
+     * @param {string|undefined} browserUrl
+     */
+    constructor(editor, name, browserUrl = undefined) {
+        if (!(editor instanceof Editor) || !isString(name) || !isOptString(browserUrl)) {
+            throw new TypeError('Invalid argument');
+        }
+
+        this.#editor = editor;
+        this.#name = name;
+        this.#browserUrl = browserUrl;
+    }
+
+    /**
+     * Opens a dialog or a browser window if browser URL is set
+     *
+     * @param {function} save
+     * @param {Object} [attributes = {}]
+     * @return {void}
+     */
+    open(save, attributes = {}) {
+        this.browserUrl ? this.#openBrowser(save, attributes) : this.#openDialog(save, attributes);
+    }
+
+    /**
+     * Translates given string
+     *
+     * @protected
+     * @param {string} key
+     * @return {string}
+     */
+    _(key) {
+        return this.editor.translate(key);
+    }
+
+    /**
+     * @protected
+     * @return {void}
+     */
+    _prepareForm() {
+        throw new Error('Not implemented');
+    }
+
+    /**
+     * Opens a browser window and registers a listener for communication between editor and browser windows
+     *
+     * @param {function} save
+     * @param {Object} [attributes = {}]
+     * @return {void}
+     */
+    #openBrowser(save, attributes = {}) {
+        this.editor.dom.open({ url: this.browserUrl, name: this.name, call: save, params: attributes });
+    }
+
+    /**
+     * Opens a dialog and executes given callback on save
+     *
+     * @param {function} save
+     * @param {Object} [attributes = {}]
+     * @return {void}
+     */
+    #openDialog(save, attributes = {}) {
+        const range = this.editor.dom.getRange();
+        this.#cleanup();
+
+        /** @type {HTMLDialogElement} */
+        const dialog = this.editor.dom.createElement(TagName.DIALOG);
+        dialog.addEventListener('click', (event) => event.target === dialog && dialog.close());
+        dialog.addEventListener('close', () => {
+            range && this.editor.dom.setRange(range);
+            dialog.returnValue && save(JSON.parse(dialog.returnValue));
+            this.#cleanup();
+        });
+        this.editor.dom.insertLastChild(dialog, this.editor.element);
+
+        this.#formCreator = new FormCreator(this.editor);
+        this._prepareForm();
+        const form = this.formCreator.form;
+        form.addEventListener('submit', () => dialog.close(JSON.stringify(Object.fromEntries(new FormData(form)))));
+        form.addEventListener('reset', () => dialog.close());
+        new FormData(form).forEach((val, key) => is(attributes[key]) && (form.elements[key].value = attributes[key]));
+        this.editor.dom.insertLastChild(form, dialog);
+
+        dialog.showModal();
+    }
+
+    /**
+     * Removes all existing editor dialogs
+     *
+     * @return {void}
+     */
+    #cleanup() {
+        Array.from(this.editor.element.getElementsByTagName(TagName.DIALOG)).forEach((item) => {
+            item.parentElement.removeChild(item);
+        });
+    }
+}

package/base/DialogManager.js

@@ -0,0 +1,44 @@
+import Dialog from './Dialog.js';
+
+export default class DialogManager {
+    /**
+     * @type {Map<string, Dialog>}
+     */
+    #items = new Map();
+
+    /**
+     * @param {Dialog[]} [dialogs = []]
+     */
+    constructor(dialogs = []) {
+        dialogs.forEach((dialog) => this.set(dialog));
+    }
+
+    /**
+     * @param {string} name
+     * @return {Dialog|undefined}
+     */
+    get(name) {
+        return this.#items.get(name);
+    }
+
+    /**
+     * @param {Dialog} dialog
+     * @return {void}
+     */
+    set(dialog) {
+        if (!(dialog instanceof Dialog)) {
+            throw new TypeError('Invalid argument');
+        }
+
+        this.#items.set(dialog.name, dialog);
+    }
+
+    /**
+     * @return {void}
+     */
+    freeze() {
+        this.#items.forEach((dialog) => Object.freeze(dialog));
+        Object.freeze(this.#items);
+        Object.freeze(this);
+    }
+}

package/base/Dispatcher.js

@@ -0,0 +1,88 @@
+import TagName from './TagName.js';
+import { isFunction, isOptHtml, isString } from './util.js';
+
+export default class Dispatcher {
+    /**
+     * @type {HTMLElement}
+     */
+    #element;
+
+    /**
+     * @param {HTMLElement} element
+     */
+    constructor(element) {
+        if (!(element instanceof HTMLElement)) {
+            throw new TypeError('Invalid argument');
+        }
+
+        this.#element = element;
+        this.register(this.#observe.bind(this));
+    }
+
+    /**
+     * @param {string} type
+     * @param {HTMLElement|undefined} [element = undefined]
+     * @param {HTMLElement|undefined} [target = undefined]
+     * @return {void}
+     */
+    dispatch(type, element = undefined, target = undefined) {
+        if (!isString(type) || !isOptHtml(element) || !isOptHtml(target)) {
+            throw new TypeError('Invalid argument');
+        }
+
+        this.#element.dispatchEvent(new CustomEvent(type, { detail: { element, target } }));
+    }
+
+    /**
+     * Registers a mutation observer on managed element
+     *
+     * @param {function} call
+     * @param {MutationObserverInit} [opts = {childList: true, subtree: true}]
+     * @return {void}
+     */
+    register(call, opts = { childList: true, subtree: true }) {
+        if (!isFunction(call)) {
+            throw new TypeError('Invalid argument');
+        }
+
+        const observer = new MutationObserver(call);
+        observer.observe(this.#element, opts);
+    }
+
+    /**
+     * Dispatches a mutation event on managed element
+     *
+     * @param {string} type
+     * @param {Element} element
+     * @param {Node} target
+     * @return {void}
+     */
+    #dispatch(type, element, target) {
+        if (element instanceof HTMLElement && target instanceof HTMLElement) {
+            this.dispatch(type, element, target);
+            this.dispatch(`${type}${element.localName.replace('-', '')}`, element, target);
+        }
+    }
+
+    /**
+     * Observes mutations on managed element
+     *
+     * @param {MutationRecord[]} records
+     * @return {void}
+     */
+    #observe(records) {
+        records.forEach((record) => {
+            record.addedNodes.forEach((element) => {
+                if (element instanceof HTMLElement) {
+                    this.#dispatch('insert', element, record.target);
+                    Array.from(element.getElementsByTagName(TagName.ALL)).forEach((item) =>
+                        this.#dispatch('insert', item, record.target)
+                    );
+                }
+            });
+            record.removedNodes.forEach(
+                (element) => element instanceof HTMLElement && this.#dispatch('delete', element, record.target)
+            );
+        });
+    }
+}