Show: Inherited Protected Private Deprecated

# File `src/ui/react/src/adapter/main.js`

                                (function() {
                                    'use strict';

                                    /**
                                     * AlloyEditor static object.
                                     *
                                     * @class AlloyEditor
                                     * @type {Object}
                                     */
                                    var AlloyEditor = {
                                        /**
                                         * Creates an instance of AlloyEditor.
                                         *
                                         * @method editable
                                         * @static
                                         * @param {String|Node} node The Node ID or HTMl node, which AlloyEditor should use as an editable area.
                                         * @param {Object} config Configuration attributes for the current instance of AlloyEditor.
                                         * @return {Object} An instance of {{#crossLink "Core"}}{{/crossLink}}
                                         */
                                        editable: function(node, config) {
                                            config = config || {};
                                            config.srcNode = node;

                                            AlloyEditor.implementEventTarget();

                                            return new AlloyEditor.Core(config);
                                        },

                                        /**
                                         * The full URL for the AlloyEditor installation directory.
                                         * It is possible to manually provide the base path by setting a
                                         * global variable named `ALLOYEDITOR_BASEPATH`. This global variable
                                         * must be set **before** the editor script loading.
                                         *
                                         * @method getBasePath
                                         * @static
                                         * @return {String} The found base path
                                         */
                                        getBasePath: function() {
                                            // Find out the editor directory path, based on its <script> tag.
                                            var path = window.ALLOYEDITOR_BASEPATH || '';

                                            if (!path) {
                                                var scripts = document.getElementsByTagName('script');

                                                for (var i = 0; i < scripts.length; i++) {
                                                    var match = scripts[ i ].src.match(AlloyEditor.regexBasePath);

                                                    if (match) {
                                                        path = match[1];
                                                        break;
                                                    }
                                                }
                                            }

                                            // In IE (only) the script.src string is the raw value entered in the
                                            // HTML source. Other browsers return the full resolved URL instead.
                                            if (path.indexOf(':/') === -1 && path.slice(0, 2) !== '//' ) {
                                                // Absolute path.
                                                if (path.indexOf('/') === 0) {
                                                    path = location.href.match(/^.*?:\/\/[^\/]*/)[0] + path;
                                                }
                                                // Relative path.
                                                else {
                                                    path = location.href.match(/^[^\?]*\/(?:)/)[0] + path;
                                                }
                                            }

                                            if (!path){
                                                throw 'The AlloyEditor installation path could not be automatically detected. Please set the global variable "ALLOYEDITOR_BASEPATH" before creating editor instances.';
                                            }

                                            return path;
                                        },

                                        /**
                                         * Detects and load the corresponding language file if AlloyEditor language strings are not already present.
                                         * The function fires a {{#crossLink "AlloyEditor/languageResourcesLoaded:event"}}{{/crossLink}} event
                                         *
                                         * @method loadLanguageResources
                                         * @static
                                         * @param {Function} callback Optional callback to be called when AlloyEditor loads the language resource.
                                         */
                                        loadLanguageResources: function(callback) {
                                            AlloyEditor.implementEventTarget();

                                            if (AlloyEditor.Lang.isFunction(callback)) {
                                                if (AlloyEditor.Strings) {
                                                    setTimeout(callback, 0);
                                                } else {
                                                    AlloyEditor.once('languageResourcesLoaded', callback);
                                                }
                                            }

                                            if (!AlloyEditor._langResourceRequested) {
                                                AlloyEditor._langResourceRequested = true;

                                                var languages = ['af', 'ar', 'bg', 'bn', 'bs', 'ca', 'cs', 'cy', 'da', 'de', 'el', 'en-au', 'en-ca', 'en-gb', 'en', 'eo', 'es', 'et', 'eu', 'fa', 'fi', 'fo', 'fr-ca', 'fr', 'gl', 'gu', 'he', 'hi', 'hr', 'hu', 'id', 'is', 'it', 'ja', 'ka', 'km', 'ko', 'ku', 'lt', 'lv', 'mk', 'mn', 'ms', 'nb', 'nl', 'no', 'pl', 'pt-br', 'pt', 'ro', 'ru', 'si', 'sk', 'sl', 'sq', 'sr-latn', 'sr', 'sv', 'th', 'tr', 'tt', 'ug', 'uk', 'vi', 'zh-cn', 'zh'];

                                                var userLanguage = navigator.language || navigator.userLanguage || 'en';

                                                var parts = userLanguage.toLowerCase().match(/([a-z]+)(?:-([a-z]+))?/);
                                                var lang = parts[1];
                                                var locale = parts[2];

                                                if (languages[lang + '-' + locale]) {
                                                    lang = lang + '-' + locale;
                                                } else if (!languages.indexOf(lang)) {
                                                    lang = 'en';
                                                }

                                                CKEDITOR.scriptLoader.load(AlloyEditor.getUrl('lang/alloy-editor/' + lang + '.js'), function(loaded) {
                                                    if (loaded) {
                                                        AlloyEditor.fire('languageResourcesLoaded');
                                                    }
                                                }, this);
                                            }
                                        },

                                        /**
                                         * Gets the full URL for AlloyEditor resources. By default, URLs
                                         * returned by this function contain a querystring parameter ("t")
                                         * set to the {@link CKEDITOR#timestamp} value.
                                         *
                                         * @method getUrl
                                         * @static
                                         * @param {String} resource The resource whose full URL we want to get.
                                         * It may be a full, absolute, or relative URL.
                                         * @return {String} The full URL.
                                         */
                                        getUrl: function(resource) {
                                            var basePath = AlloyEditor.getBasePath();

                                            // If this is not a full or absolute path.
                                            if (resource.indexOf(':/') === -1 && resource.indexOf('/') !== 0) {
                                                resource = basePath + resource;
                                            }

                                            // Add the timestamp, except for directories.
                                            if (CKEDITOR.timestamp && resource.charAt( resource.length - 1 ) !== '/' && !(/[&?]t=/).test(resource)) {
                                                resource += (resource.indexOf('?') >= 0 ? '&' : '?') + 't=' + CKEDITOR.timestamp;
                                            }

                                            return resource;
                                        },

                                        /**
                                         * Implements event firing and subscribing via CKEDITOR.event.
                                         *
                                         * @method implementEventTarget
                                         * @static
                                         */
                                        implementEventTarget: function() {
                                            if (!AlloyEditor.fire && !AlloyEditor.on) {
                                                CKEDITOR.event.implementOn(AlloyEditor);
                                            }
                                        },

                                        /**
                                         * Regular expression which should match the script which have been used to load AlloyEditor.
                                         *
                                         * @property regexBasePath
                                         * @type {RegExp}
                                         * @static
                                         */
                                        regexBasePath: /(^|.*[\\\/])(?:alloy-editor[^/]+|alloy-editor)\.js(?:\?.*|;.*)?$/i,

                                        /**
                                         * And object, containing all currently registered buttons in AlloyEditor.
                                         *
                                         * @property Buttons
                                         * @type {Object}
                                         * @static
                                         */
                                        Buttons: {},

                                        /**
                                         * And object, containing all currently registered toolbars in AlloyEditor.
                                         *
                                         * @property Toolbars
                                         * @type {Object}
                                         * @static
                                         */
                                        Toolbars: {}

                                        /**
                                         * Fired when AlloyEditor detects the browser language and loads the corresponding language file. Once this event
                                         * is fired, AlloyEditor.Strings will be populated with data.
                                         *
                                         * @event languageResourcesLoaded
                                         */
                                    };

                                    if (typeof module !== 'undefined' && typeof module.exports === 'object') {
                                        module.exports = AlloyEditor;
                                    }

                                    if (typeof window !== 'undefined') {
                                        window.AlloyEditor = AlloyEditor;
                                    } else if(typeof global !== 'undefined') {
                                        global.AlloyEditor = AlloyEditor;
                                    } else if (typeof self !== 'undefined') {
                                        self.AlloyEditor = AlloyEditor;
                                    } else {
                                        this.AlloyEditor = AlloyEditor;
                                    }
                                }());