@lotte-innovate/ui-component-test 0.1.114 → 0.1.116

package/dist/public/tinymce/plugins/advlist/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/public/tinymce/plugins/advlist/index.js

@@ -0,0 +1,8 @@
+"use strict";
+// Exports the "advlist" plugin for usage with module loaders
+// Usage:
+//   CommonJS:
+//     require('tinymce/plugins/advlist')
+//   ES2015:
+//     import 'tinymce/plugins/advlist'
+require('./plugin.js');

package/dist/public/tinymce/plugins/advlist/plugin.js

@@ -0,0 +1,255 @@
+"use strict";
+/**
+ * TinyMCE version 6.8.5 (TBD)
+ */
+(function () {
+    'use strict';
+    var global$1 = tinymce.util.Tools.resolve('tinymce.PluginManager');
+    var applyListFormat = function (editor, listName, styleValue) {
+        var cmd = listName === 'UL' ? 'InsertUnorderedList' : 'InsertOrderedList';
+        editor.execCommand(cmd, false, styleValue === false ? null : { 'list-style-type': styleValue });
+    };
+    var register$2 = function (editor) {
+        editor.addCommand('ApplyUnorderedListStyle', function (ui, value) {
+            applyListFormat(editor, 'UL', value['list-style-type']);
+        });
+        editor.addCommand('ApplyOrderedListStyle', function (ui, value) {
+            applyListFormat(editor, 'OL', value['list-style-type']);
+        });
+    };
+    var option = function (name) { return function (editor) { return editor.options.get(name); }; };
+    var register$1 = function (editor) {
+        var registerOption = editor.options.register;
+        registerOption('advlist_number_styles', {
+            processor: 'string[]',
+            default: 'default,lower-alpha,lower-greek,lower-roman,upper-alpha,upper-roman'.split(',')
+        });
+        registerOption('advlist_bullet_styles', {
+            processor: 'string[]',
+            default: 'default,circle,square'.split(',')
+        });
+    };
+    var getNumberStyles = option('advlist_number_styles');
+    var getBulletStyles = option('advlist_bullet_styles');
+    var isNullable = function (a) { return a === null || a === undefined; };
+    var isNonNullable = function (a) { return !isNullable(a); };
+    var global = tinymce.util.Tools.resolve('tinymce.util.Tools');
+    var Optional = /** @class */ (function () {
+        function Optional(tag, value) {
+            this.tag = tag;
+            this.value = value;
+        }
+        Optional.some = function (value) {
+            return new Optional(true, value);
+        };
+        Optional.none = function () {
+            return Optional.singletonNone;
+        };
+        Optional.prototype.fold = function (onNone, onSome) {
+            if (this.tag) {
+                return onSome(this.value);
+            }
+            else {
+                return onNone();
+            }
+        };
+        Optional.prototype.isSome = function () {
+            return this.tag;
+        };
+        Optional.prototype.isNone = function () {
+            return !this.tag;
+        };
+        Optional.prototype.map = function (mapper) {
+            if (this.tag) {
+                return Optional.some(mapper(this.value));
+            }
+            else {
+                return Optional.none();
+            }
+        };
+        Optional.prototype.bind = function (binder) {
+            if (this.tag) {
+                return binder(this.value);
+            }
+            else {
+                return Optional.none();
+            }
+        };
+        Optional.prototype.exists = function (predicate) {
+            return this.tag && predicate(this.value);
+        };
+        Optional.prototype.forall = function (predicate) {
+            return !this.tag || predicate(this.value);
+        };
+        Optional.prototype.filter = function (predicate) {
+            if (!this.tag || predicate(this.value)) {
+                return this;
+            }
+            else {
+                return Optional.none();
+            }
+        };
+        Optional.prototype.getOr = function (replacement) {
+            return this.tag ? this.value : replacement;
+        };
+        Optional.prototype.or = function (replacement) {
+            return this.tag ? this : replacement;
+        };
+        Optional.prototype.getOrThunk = function (thunk) {
+            return this.tag ? this.value : thunk();
+        };
+        Optional.prototype.orThunk = function (thunk) {
+            return this.tag ? this : thunk();
+        };
+        Optional.prototype.getOrDie = function (message) {
+            if (!this.tag) {
+                throw new Error(message !== null && message !== void 0 ? message : 'Called getOrDie on None');
+            }
+            else {
+                return this.value;
+            }
+        };
+        Optional.from = function (value) {
+            return isNonNullable(value) ? Optional.some(value) : Optional.none();
+        };
+        Optional.prototype.getOrNull = function () {
+            return this.tag ? this.value : null;
+        };
+        Optional.prototype.getOrUndefined = function () {
+            return this.value;
+        };
+        Optional.prototype.each = function (worker) {
+            if (this.tag) {
+                worker(this.value);
+            }
+        };
+        Optional.prototype.toArray = function () {
+            return this.tag ? [this.value] : [];
+        };
+        Optional.prototype.toString = function () {
+            return this.tag ? "some(".concat(this.value, ")") : 'none()';
+        };
+        return Optional;
+    }());
+    Optional.singletonNone = new Optional(false);
+    var findUntil = function (xs, pred, until) {
+        for (var i = 0, len = xs.length; i < len; i++) {
+            var x = xs[i];
+            if (pred(x, i)) {
+                return Optional.some(x);
+            }
+            else if (until(x, i)) {
+                break;
+            }
+        }
+        return Optional.none();
+    };
+    var isCustomList = function (list) { return /\btox\-/.test(list.className); };
+    var isChildOfBody = function (editor, elm) {
+        return editor.dom.isChildOf(elm, editor.getBody());
+    };
+    var matchNodeNames = function (regex) { return function (node) { return isNonNullable(node) && regex.test(node.nodeName); }; };
+    var isListNode = matchNodeNames(/^(OL|UL|DL)$/);
+    var isTableCellNode = matchNodeNames(/^(TH|TD)$/);
+    var inList = function (editor, parents, nodeName) { return findUntil(parents, function (parent) { return isListNode(parent) && !isCustomList(parent); }, isTableCellNode).exists(function (list) { return list.nodeName === nodeName && isChildOfBody(editor, list); }); };
+    var getSelectedStyleType = function (editor) {
+        var listElm = editor.dom.getParent(editor.selection.getNode(), 'ol,ul');
+        var style = editor.dom.getStyle(listElm, 'listStyleType');
+        return Optional.from(style);
+    };
+    var isWithinNonEditable = function (editor, element) { return element !== null && !editor.dom.isEditable(element); };
+    var isWithinNonEditableList = function (editor, element) {
+        var parentList = editor.dom.getParent(element, 'ol,ul,dl');
+        return isWithinNonEditable(editor, parentList) && editor.selection.isEditable();
+    };
+    var setNodeChangeHandler = function (editor, nodeChangeHandler) {
+        var initialNode = editor.selection.getNode();
+        nodeChangeHandler({
+            parents: editor.dom.getParents(initialNode),
+            element: initialNode
+        });
+        editor.on('NodeChange', nodeChangeHandler);
+        return function () { return editor.off('NodeChange', nodeChangeHandler); };
+    };
+    var styleValueToText = function (styleValue) {
+        return styleValue.replace(/\-/g, ' ').replace(/\b\w/g, function (chr) {
+            return chr.toUpperCase();
+        });
+    };
+    var normalizeStyleValue = function (styleValue) { return isNullable(styleValue) || styleValue === 'default' ? '' : styleValue; };
+    var makeSetupHandler = function (editor, nodeName) { return function (api) {
+        var updateButtonState = function (editor, parents) {
+            var element = editor.selection.getStart(true);
+            api.setActive(inList(editor, parents, nodeName));
+            api.setEnabled(!isWithinNonEditableList(editor, element) && editor.selection.isEditable());
+        };
+        var nodeChangeHandler = function (e) { return updateButtonState(editor, e.parents); };
+        return setNodeChangeHandler(editor, nodeChangeHandler);
+    }; };
+    var addSplitButton = function (editor, id, tooltip, cmd, nodeName, styles) {
+        editor.ui.registry.addSplitButton(id, {
+            tooltip: tooltip,
+            icon: nodeName === 'OL' ? 'ordered-list' : 'unordered-list',
+            presets: 'listpreview',
+            columns: 3,
+            fetch: function (callback) {
+                var items = global.map(styles, function (styleValue) {
+                    var iconStyle = nodeName === 'OL' ? 'num' : 'bull';
+                    var iconName = styleValue === 'disc' || styleValue === 'decimal' ? 'default' : styleValue;
+                    var itemValue = normalizeStyleValue(styleValue);
+                    var displayText = styleValueToText(styleValue);
+                    return {
+                        type: 'choiceitem',
+                        value: itemValue,
+                        icon: 'list-' + iconStyle + '-' + iconName,
+                        text: displayText
+                    };
+                });
+                callback(items);
+            },
+            onAction: function () { return editor.execCommand(cmd); },
+            onItemAction: function (_splitButtonApi, value) {
+                applyListFormat(editor, nodeName, value);
+            },
+            select: function (value) {
+                var listStyleType = getSelectedStyleType(editor);
+                return listStyleType.map(function (listStyle) { return value === listStyle; }).getOr(false);
+            },
+            onSetup: makeSetupHandler(editor, nodeName)
+        });
+    };
+    var addButton = function (editor, id, tooltip, cmd, nodeName, styleValue) {
+        editor.ui.registry.addToggleButton(id, {
+            active: false,
+            tooltip: tooltip,
+            icon: nodeName === 'OL' ? 'ordered-list' : 'unordered-list',
+            onSetup: makeSetupHandler(editor, nodeName),
+            onAction: function () { return editor.queryCommandState(cmd) || styleValue === '' ? editor.execCommand(cmd) : applyListFormat(editor, nodeName, styleValue); }
+        });
+    };
+    var addControl = function (editor, id, tooltip, cmd, nodeName, styles) {
+        if (styles.length > 1) {
+            addSplitButton(editor, id, tooltip, cmd, nodeName, styles);
+        }
+        else {
+            addButton(editor, id, tooltip, cmd, nodeName, normalizeStyleValue(styles[0]));
+        }
+    };
+    var register = function (editor) {
+        addControl(editor, 'numlist', 'Numbered list', 'InsertOrderedList', 'OL', getNumberStyles(editor));
+        addControl(editor, 'bullist', 'Bullet list', 'InsertUnorderedList', 'UL', getBulletStyles(editor));
+    };
+    var Plugin = function () {
+        global$1.add('advlist', function (editor) {
+            if (editor.hasPlugin('lists')) {
+                register$1(editor);
+                register(editor);
+                register$2(editor);
+            }
+            else {
+                console.error('Please use the Lists plugin together with the Advanced List plugin.');
+            }
+        });
+    };
+    Plugin();
+})();

package/dist/public/tinymce/plugins/code/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/public/tinymce/plugins/code/index.js

@@ -0,0 +1,8 @@
+"use strict";
+// Exports the "code" plugin for usage with module loaders
+// Usage:
+//   CommonJS:
+//     require('tinymce/plugins/code')
+//   ES2015:
+//     import 'tinymce/plugins/code'
+require('./plugin.js');

package/dist/public/tinymce/plugins/code/plugin.js

@@ -0,0 +1,77 @@
+"use strict";
+/**
+ * TinyMCE version 6.8.5 (TBD)
+ */
+(function () {
+    'use strict';
+    var global = tinymce.util.Tools.resolve('tinymce.PluginManager');
+    var setContent = function (editor, html) {
+        editor.focus();
+        editor.undoManager.transact(function () {
+            editor.setContent(html);
+        });
+        editor.selection.setCursorLocation();
+        editor.nodeChanged();
+    };
+    var getContent = function (editor) {
+        return editor.getContent({ source_view: true });
+    };
+    var open = function (editor) {
+        var editorContent = getContent(editor);
+        editor.windowManager.open({
+            title: 'Source Code',
+            size: 'large',
+            body: {
+                type: 'panel',
+                items: [{
+                        type: 'textarea',
+                        name: 'code'
+                    }]
+            },
+            buttons: [
+                {
+                    type: 'cancel',
+                    name: 'cancel',
+                    text: 'Cancel'
+                },
+                {
+                    type: 'submit',
+                    name: 'save',
+                    text: 'Save',
+                    primary: true
+                }
+            ],
+            initialData: { code: editorContent },
+            onSubmit: function (api) {
+                setContent(editor, api.getData().code);
+                api.close();
+            }
+        });
+    };
+    var register$1 = function (editor) {
+        editor.addCommand('mceCodeEditor', function () {
+            open(editor);
+        });
+    };
+    var register = function (editor) {
+        var onAction = function () { return editor.execCommand('mceCodeEditor'); };
+        editor.ui.registry.addButton('code', {
+            icon: 'sourcecode',
+            tooltip: 'Source code',
+            onAction: onAction
+        });
+        editor.ui.registry.addMenuItem('code', {
+            icon: 'sourcecode',
+            text: 'Source code',
+            onAction: onAction
+        });
+    };
+    var Plugin = function () {
+        global.add('code', function (editor) {
+            register$1(editor);
+            register(editor);
+            return {};
+        });
+    };
+    Plugin();
+})();

package/dist/public/tinymce/plugins/codesample/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/public/tinymce/plugins/codesample/index.js

@@ -0,0 +1,8 @@
+"use strict";
+// Exports the "codesample" plugin for usage with module loaders
+// Usage:
+//   CommonJS:
+//     require('tinymce/plugins/codesample')
+//   ES2015:
+//     import 'tinymce/plugins/codesample'
+require('./plugin.js');

package/dist/public/tinymce/plugins/codesample/plugin.d.ts

@@ -0,0 +1,45 @@
+declare var plainTextGrammar: {};
+export function Token(type: any, content: any, alias: any, matchedStr: any): void;
+export namespace Token {
+    function stringify(o: any, language: any): any;
+}
+export class Token {
+    constructor(type: any, content: any, alias: any, matchedStr: any);
+    type: any;
+    content: any;
+    alias: any;
+    length: number;
+}
+export declare let manual: any;
+export declare let disableWorkerMessageHandler: any;
+export declare namespace util {
+    function encode(tokens: any): any;
+    function type(o: any): string;
+    function objId(obj: any): any;
+    function clone(o: any, visited: any): any;
+    function getLanguage(element: any): string;
+    function setLanguage(element: any, language: any): void;
+    function currentScript(): HTMLOrSVGScriptElement | null;
+    function isActive(element: any, className: any, defaultActivation: any): boolean;
+}
+export declare namespace languages {
+    export { plainTextGrammar as plain };
+    export { plainTextGrammar as plaintext };
+    export { plainTextGrammar as text };
+    export { plainTextGrammar as txt };
+    export function extend(id: any, redef: any): any;
+    export function insertBefore(inside: any, before: any, insert: any, root: any): {};
+    export function DFS(o: any, callback: any, type: any, visited: any): void;
+}
+export declare let plugins: {};
+export declare function highlightAll(async: any, callback: any): void;
+export declare function highlightAllUnder(container: any, async: any, callback: any): void;
+export declare function highlightElement(element: any, async: any, callback: any): void;
+export declare function highlight(text: any, grammar: any, language: any): any;
+export declare function tokenize(text: any, grammar: any): any[];
+export declare namespace hooks {
+    let all: {};
+    function add(name: any, callback: any): void;
+    function run(name: any, env: any): void;
+}
+export {};