devextreme/cjs/__internal/ui/text_box/texteditor_button_collection/m_index.js

HTML5 JavaScript Component Suite for Responsive Web Development

/**
 * DevExtreme (cjs/__internal/ui/text_box/texteditor_button_collection/m_index.js)
 * Version: 24.2.6
 * Build date: Mon Mar 17 2025
 *
 * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
 * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
 */

"use strict";
Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.default = void 0;
var _renderer = _interopRequireDefault(require("../../../../core/renderer"));
var _ui = _interopRequireDefault(require("../../../../ui/widget/ui.errors"));
var _m_custom = _interopRequireDefault(require("./m_custom"));

function _interopRequireDefault(e) {
    return e && e.__esModule ? e : {
        default: e
    }
}

function _extends() {
    return _extends = Object.assign ? Object.assign.bind() : function(n) {
        for (var e = 1; e < arguments.length; e++) {
            var t = arguments[e];
            for (var r in t) {
                ({}).hasOwnProperty.call(t, r) && (n[r] = t[r])
            }
        }
        return n
    }, _extends.apply(null, arguments)
}
const TEXTEDITOR_BUTTONS_CONTAINER_CLASS = "dx-texteditor-buttons-container";

function checkButtonInfo(buttonInfo) {
    (() => {
        if (!buttonInfo || "object" !== typeof buttonInfo || Array.isArray(buttonInfo)) {
            throw _ui.default.Error("E1053")
        }
    })();
    (() => {
        if (!("name" in buttonInfo)) {
            throw _ui.default.Error("E1054")
        }
    })();
    (() => {
        const {
            name: name
        } = buttonInfo;
        if ("string" !== typeof name) {
            throw _ui.default.Error("E1055")
        }
    })();
    (() => {
        const {
            location: location
        } = buttonInfo;
        if ("location" in buttonInfo && "after" !== location && "before" !== location) {
            buttonInfo.location = "after"
        }
    })()
}

function checkNamesUniqueness(existingNames, newName) {
    if (existingNames.includes(newName)) {
        throw _ui.default.Error("E1055", newName)
    }
    existingNames.push(newName)
}

function isPredefinedButtonName(name, predefinedButtonsInfo) {
    return !!predefinedButtonsInfo.find((info => info.name === name))
}
class TextEditorButtonCollection {
    constructor(editor, defaultButtonsInfo) {
        this.buttons = [];
        this.defaultButtonsInfo = defaultButtonsInfo;
        this.editor = editor
    }
    _compileButtonInfo(buttons) {
        const names = [];
        return buttons.map((button => {
            const isStringButton = "string" === typeof button;
            if (!isStringButton) {
                checkButtonInfo(button)
            }
            const isDefaultButton = isStringButton || isPredefinedButtonName(button.name, this.defaultButtonsInfo);
            if (isDefaultButton) {
                const defaultButtonInfo = this.defaultButtonsInfo.find((_ref => {
                    let {
                        name: name
                    } = _ref;
                    return name === button || name === button.name
                }));
                if (!defaultButtonInfo) {
                    throw _ui.default.Error("E1056", this.editor.NAME, button)
                }
                checkNamesUniqueness(names, button);
                return defaultButtonInfo
            }
            const {
                name: name
            } = button;
            checkNamesUniqueness(names, name);
            return _extends({}, button, {
                Ctor: _m_custom.default
            })
        }))
    }
    _createButton(buttonsInfo) {
        const {
            Ctor: Ctor,
            options: options,
            name: name
        } = buttonsInfo;
        const button = new Ctor(name, this.editor, options);
        this.buttons.push(button);
        return button
    }
    _renderButtons(buttons, $container, targetLocation) {
        let $buttonsContainer = null;
        const buttonsInfo = buttons ? this._compileButtonInfo(buttons) : this.defaultButtonsInfo;
        buttonsInfo.forEach((buttonInfo => {
            const {
                location: location = "after"
            } = buttonInfo;
            if (location === targetLocation) {
                this._createButton(buttonInfo).render((() => {
                    $buttonsContainer = $buttonsContainer ?? (0, _renderer.default)("<div>").addClass("dx-texteditor-buttons-container");
                    if ("before" === targetLocation) {
                        $container.prepend($buttonsContainer)
                    } else {
                        $container.append($buttonsContainer)
                    }
                    return $buttonsContainer
                })())
            }
        }));
        return $buttonsContainer
    }
    clean() {
        this.buttons.forEach((button => button.dispose()));
        this.buttons = []
    }
    getButton(buttonName) {
        const button = this.buttons.find((_ref2 => {
            let {
                name: name
            } = _ref2;
            return name === buttonName
        }));
        return null === button || void 0 === button ? void 0 : button.instance
    }
    renderAfterButtons(buttons, $container) {
        return this._renderButtons(buttons, $container, "after")
    }
    renderBeforeButtons(buttons, $container) {
        return this._renderButtons(buttons, $container, "before")
    }
    updateButtons(names) {
        this.buttons.forEach((button => {
            if (!names || names.includes(button.name)) {
                button.update()
            }
        }))
    }
}
exports.default = TextEditorButtonCollection;