@amcharts/amcharts4/.internal/core/Base.js

/**
 * Base functionality
*/
import { __extends } from "tslib";
import { List, ListTemplate } from "./utils/List";
import { OrderedListTemplate, SortedListTemplate } from "./utils/SortedList";
import { Dictionary, DictionaryTemplate } from "./utils/Dictionary";
import { Disposer } from "./utils/Disposer";
import { EventDispatcher } from "./utils/EventDispatcher";
import { Adapter } from "./utils/Adapter";
import { Color, color } from "./utils/Color";
import { Percent, percent } from "./utils/Percent";
import { registry } from "./Registry";
import { cache } from "./utils/Cache";
import * as $array from "./utils/Array";
import * as $object from "./utils/Object";
import * as $type from "./utils/Type";
//import * as $debug from "./utils/Debug";
/**
 * Provides base functionality for all derivative objects, like generating ids,
 * handling cache, etc.
 */
var BaseObject = /** @class */ (function () {
    //protected _classes: { [index: string]: any } = {};
    /**
     * Constructor
     * * Sets class name
     */
    function BaseObject() {
        /**
         * Indicates if this object has already been deleted. Any
         * destruction/disposal code should take this into account when deciding
         * wheter to run potentially costly disposal operations if they already have
         * been run.
         */
        this._disposed = false;
        /**
         * List of IDisposer which will be disposed when the BaseObject is disposed.
         */
        this._disposers = [];
        this.className = "BaseObject";
        //this.debug();
    }
    BaseObject.prototype.debug = function () {
        //$debug.debug(this);
    };
    Object.defineProperty(BaseObject.prototype, "uid", {
        /**
         * Returns object's internal unique ID.
         *
         * @return Unique ID
         */
        get: function () {
            if (!this._uid) {
                this._uid = registry.getUniqueId();
                registry.map.setKey(this._uid, this);
            }
            return this._uid;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(BaseObject.prototype, "id", {
        /**
         * @return Id
         */
        get: function () {
            return this._id;
        },
        /**
         * Sets the user-defined id of the element.
         *
         * @param value Id
         */
        set: function (value) {
            //registry.map.setKey(value, this); // registry.map only stores by uid
            this._id = value;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(BaseObject.prototype, "map", {
        /**
         * Returns a universal collection for mapping ids with objects.
         *
         * @ignore Exclude from docs
         * @return Map collection
         */
        get: function () {
            if (!this._map) {
                this._map = new Dictionary();
            }
            return this._map;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(BaseObject.prototype, "delayedMap", {
        /**
         * Returns mapping for objects referenced by id in JSON config that are not yet
         * available at processing time.
         *
         * @ignore Exclude from docs
         * @return Map collection
         */
        get: function () {
            if (!this._delayedMap) {
                this._delayedMap = new Dictionary();
            }
            return this._delayedMap;
        },
        enumerable: true,
        configurable: true
    });
    /**
     * Logs an id and property of the target element that is not yet available
     * for later assignment.
     *
     * @ignore
     * @param  property  Property to set
     * @param  id        ID of the target element
     */
    BaseObject.prototype.addDelayedMap = function (property, id) {
        var map = this.delayedMap;
        if (!map.hasKey(id)) {
            map.setKey(id, []);
        }
        var list = map.getKey(id);
        list.push({
            property: property,
            target: this
        });
    };
    /**
     * Processes delayed JSON config items.
     *
     * @ignore
     */
    BaseObject.prototype.processDelayedMap = function () {
        var _this = this;
        this.delayedMap.each(function (id, list) {
            if (_this.map.hasKey(id)) {
                var target_1 = _this.map.getKey(id);
                $array.each(list, function (item) {
                    item.target[item.property] = target_1;
                });
                _this.delayedMap.removeKey(id);
            }
        });
    };
    /**
     * Applies properties from all assigned themes.
     *
     * @ignore Exclude from docs
     */
    BaseObject.prototype.applyTheme = function () {
        var _this = this;
        // TODO is this needed ?
        if (registry) {
            var themes = this.getCurrentThemes();
            // TODO is this needed ?
            if (themes) {
                $array.each(themes, function (theme, index) {
                    theme(_this);
                });
            }
        }
    };
    Object.defineProperty(BaseObject.prototype, "themes", {
        /**
         * @ignore Exclude from docs
         * @return An array of themes
         */
        get: function () {
            return this._themes;
        },
        /**
         * A list of themes to be used for this element.
         *
         * @ignore Exclude from docs
         * @param value An array of themes
         */
        set: function (value) {
            this._themes = value;
        },
        enumerable: true,
        configurable: true
    });
    /**
     * Returns a list of themes that should be applied to this element. It could
     * either be a list of themes set explicitly on this element, or system-wide.
     *
     * @return List of themes
     */
    BaseObject.prototype.getCurrentThemes = function () {
        return this.themes || registry.themes;
    };
    /**
     * Returns if this object has been already been disposed.
     *
     * @return Is disposed?
     */
    BaseObject.prototype.isDisposed = function () {
        return this._disposed;
    };
    /**
     * Destroys this object and all related data.
     */
    BaseObject.prototype.dispose = function () {
        if (!this._disposed) {
            this._disposed = true;
            var a = this._disposers;
            this._disposers = null;
            while (a.length !== 0) {
                var disposer = a.shift();
                disposer.dispose();
            }
            // Clear cache
            this.clearCache();
            // remove from clones list
            if (this.clonedFrom) {
                this.clonedFrom.clones.removeValue(this);
            }
            var uid = this._uid;
            if (uid != null) {
                registry.map.removeKey(uid);
            }
        }
    };
    /**
     * Adds an IDisposer, which will be disposed when this object is disposed.
     *
     * @param target Object to dispose
     * @ignore Exclude from docs
     */
    BaseObject.prototype.addDisposer = function (target) {
        this._disposers.push(target);
    };
    /**
     * Disposes disposable object and removes it from `_disposers`.
     *
     * @param target Object to dispose
     * @ignore Exclude from docs
     */
    BaseObject.prototype.removeDispose = function (target) {
        //if(target){
        if (!this._disposed) {
            var index = $array.indexOf(this._disposers, target);
            if (index > -1) {
                this._disposers.splice(index, 1);
            }
        }
        target.dispose();
        //}
    };
    /**
     * Makes a copy of this object and returns the clone. Try to avoid cloning complex objects like chart, create new instances if you need them.
     *
     * @param cloneId  An id to use for clone (if not set a unique id will be generated)
     * @returns Clone
     */
    BaseObject.prototype.clone = function (cloneId) {
        if (!cloneId) {
            cloneId = "clone-" + registry.getUniqueId();
        }
        var newObject = new this.constructor();
        newObject.cloneId = cloneId;
        newObject.copyFrom(this);
        // add to clones list
        // this.clones.push(newObject); // moved this to copyFrom
        return newObject;
    };
    Object.defineProperty(BaseObject.prototype, "clones", {
        /**
         * Returns a collection of object's clones.
         *
         * @ignore Exclude from docs
         * @return Clones
         */
        get: function () {
            if (!this._clones) {
                this._clones = new List();
            }
            return this._clones;
        },
        enumerable: true,
        configurable: true
    });
    /**
     * Copies all properties and related data from different element.
     *
     * @param object Source element
     */
    BaseObject.prototype.copyFrom = function (object) {
        object.clones.push(this); // do not moveValue, as it is expensive! even if there will be several items in clones list, it's not that bad.
        this.clonedFrom = object;
    };
    Object.defineProperty(BaseObject.prototype, "className", {
        /**
         * @ignore Exclude from docs
         * @return Class name
         */
        get: function () {
            return this._className;
        },
        /**
         * Element's class name. (a class that was used to instantiate the element)
         *
         * @ignore Exclude from docs
         * @param value  Class name
         */
        set: function (value) {
            this._className = value;
            /*if (registry) {
                registry.registeredClasses[value] = typeof this;
            }*/
        },
        enumerable: true,
        configurable: true
    });
    /**
     * Caches value in object's cache.
     *
     * @ignore Exclude from docs
     * @param key    Key
     * @param value  Value
     * @param ttl    TTL in seconds
     */
    BaseObject.prototype.setCache = function (key, value, ttl) {
        cache.set(this.uid, key, value, ttl);
    };
    /**
     * Retrieves cached value.
     *
     * If optional second padarameter is specified, it will return that value
     * if cache is not available or is expired.
     *
     * @ignore Exclude from docs
     * @param key    Key
     * @param value  Value to return if cache is not available
     * @return Value
     */
    BaseObject.prototype.getCache = function (key, value) {
        if (value === void 0) { value = undefined; }
        return cache.get(this.uid, key, value);
    };
    /**
     * Clears object's local cache.
     *
     * @ignore Exclude from docs
     */
    BaseObject.prototype.clearCache = function () {
        cache.clear(this.uid);
    };
    /**
     * Creates [[Disposer]] for `setTimeout` function call. This ensures that all
     * timeouts created by the object will be cleared when object itself is
     * disposed.
     *
     * @ignore Exclude from docs
     * @param fn     Callback function
     * @param delay  Timeout (ms)
     * @return Disposer for timeout
     */
    BaseObject.prototype.setTimeout = function (fn, delay) {
        var _this = this;
        var id = setTimeout(function () {
            _this.removeDispose(disposer);
            fn();
        }, delay);
        var disposer = new Disposer(function () {
            clearTimeout(id);
        });
        this._disposers.push(disposer);
        return disposer;
    };
    /**
     * Creates [[Disposer]] for `setInterval` function call. This ensures that all
     * timeouts created by the object will be cleared when object itself is
     * disposed.
     *
     * @ignore Exclude from docs
     * @param fn     Callback function
     * @param delay  Timeout (ms)
     * @return Disposer for timeout
     */
    BaseObject.prototype.setInterval = function (fn, delay) {
        var _this = this;
        var id = setInterval(function () {
            _this.removeDispose(disposer);
            fn();
        }, delay);
        var disposer = new Disposer(function () {
            clearTimeout(id);
        });
        this._disposers.push(disposer);
        return disposer;
    };
    Object.defineProperty(BaseObject.prototype, "config", {
        /**
         * ==========================================================================
         * JSON-BASED CONFIG PROCESSING
         * ==========================================================================
         * @hidden
         */
        /**
         * Use this property to set JSON-based config. When set, triggers processing
         * routine, which will go through all properties, and try to apply values,
         * create instances, etc.
         *
         * Use this with caution, as it is a time-consuming process. It's used for
         * initialchart setup only, not routine operations.
         *
         * @param json JSON config
         */
        set: function (config) {
            try {
                this.processConfig(config);
            }
            catch (e) {
                /*if (this instanceof Sprite) {
                    this.raiseCriticalError(e);
                }*/
                this.raiseCriticalError(e);
            }
        },
        enumerable: true,
        configurable: true
    });
    /**
     * Processes the JSON config.
     *
     * @param json  JSON config
     * @ignore Exclude from docs
     */
    BaseObject.prototype.processConfig = function (config) {
        var _this = this;
        if (!config) {
            return;
        }
        // Get target
        var target = this;
        // Iterate through all of the items
        $object.eachOrdered(config, function (configKey, value) {
            var configValue = value;
            // Is this a callback?
            if (configKey == "callback" && typeof value == "function") {
                value.call(target);
            }
            // Check if there's a property in target
            if (_this.hasProperty(configKey)) {
                var item_1;
                // Do we have instructions to create an object?
                // We create a new object if "type" key is set, but only if the
                // target object is of different type.
                if ($type.isObject(configValue)
                    && $type.hasValue(configValue["type"])
                    && (!$type.isObject(target[configKey])
                        || !$type.hasValue(target[configKey].className)
                        || configValue["forceCreate"]
                        || target[configKey].className != configValue["type"])
                    && !_this.asIs(configKey)) {
                    item_1 = _this.createClassInstance(configValue["type"]);
                    // Create new instance
                    if (item_1) {
                        target[configKey] = item_1;
                    }
                    else {
                        item_1 = target[configKey];
                    }
                }
                else {
                    // Get item from the object
                    item_1 = target[configKey];
                }
                /**
                 * It is...
                 * --------------------------------------------------------------------
                 */
                if (item_1 instanceof Adapter) {
                    // ... an Adapter, try to add handlers to it
                    // ------------------------------------------------------------------
                    _this.processAdapters(item_1, configValue);
                }
                else if (item_1 instanceof EventDispatcher) {
                    // ... an EventDispatcher, try to add handlers to it
                    // ------------------------------------------------------------------
                    _this.processEvents(item_1, configValue);
                }
                else if (configKey == "locale" && $type.isString(configValue)) {
                    // ... a locale specified as string, e.g. "fr_FR"
                    // ------------------------------------------------------------------
                    if (window["am4lang_" + configValue]) {
                        target[configKey] = window["am4lang_" + configValue];
                    }
                }
                else if (configKey == "parent" && $type.isString(configValue)) {
                    // ... a parent referred via its it
                    // ------------------------------------------------------------------
                    var parent_1 = _this.map.getKey(configValue);
                    if (parent_1) {
                        target[configKey] = parent_1;
                    }
                    else {
                        _this.addDelayedMap("parent", configValue);
                    }
                }
                else if (_this.asIs(configKey)) {
                    // ... a special field, just set it to new value
                    // ------------------------------------------------------------------
                    // (no need to add each indvidual item)
                    target[configKey] = configValue;
                }
                else if (_this.asFunction(configKey) && $type.isString(configValue)) {
                    // ... a field indicating function name to look for in registry
                    // ------------------------------------------------------------------
                    if ($type.hasValue(registry.registeredClasses[configValue])) {
                        target[configKey] = registry.registeredClasses[configValue];
                    }
                    else {
                        throw Error("Invalid easing function: " + configValue);
                    }
                }
                else if (configValue instanceof BaseObject) {
                    // ... a BaseObject object, we just going to use it as it is
                    // ------------------------------------------------------------------
                    target[configKey] = configValue;
                }
                else if (item_1 instanceof BaseObject) {
                    // ... another child BaseObject
                    // ------------------------------------------------------------------
                    // Let's just pass in config part in and let itself deal with it
                    item_1.config = configValue;
                }
                else if (item_1 instanceof ListTemplate || item_1 instanceof OrderedListTemplate || item_1 instanceof SortedListTemplate) {
                    // ... a list with template
                    // ------------------------------------------------------------------
                    // Let's see what we can do with it
                    if ($type.isArray(configValue)) {
                        // It's an array.
                        // Create a list item for entry, or try to apply properties to an
                        // existing entry if possible and it is present.
                        if (item_1 instanceof ListTemplate) {
                            _this.processListTemplate(configValue, item_1);
                        }
                        else {
                            _this.processOrderedTemplate(configValue, item_1);
                        }
                    }
                    else if ($type.isObject(configValue)) {
                        // It's a single oject.
                        // Treat it as a template.
                        if (configValue instanceof BaseObject) {
                            // Item is already a BaseObject, no need to process it further
                            item_1.template = configValue;
                        }
                        else {
                            // Now let's find out if the whole object if a template, or we
                            // need to get it from `template` key
                            var templateValue = void 0;
                            if ($type.hasValue(configValue.template)) {
                                templateValue = configValue.template;
                            }
                            else {
                                templateValue = configValue;
                            }
                            if (item_1.template instanceof BaseObject) {
                                // Template is a BaseObject so we will just let its config
                                // deal with the configuration
                                item_1.template.config = templateValue;
                            }
                            else {
                                $object.each(templateValue, function (entryKey, entryValue) {
                                    var listItem = item_1.template[entryKey];
                                    if (listItem instanceof Adapter) {
                                        _this.processAdapters(listItem, entryValue);
                                    }
                                    else if (listItem instanceof EventDispatcher) {
                                        _this.processEvents(listItem, entryValue);
                                    }
                                    else if (listItem instanceof DictionaryTemplate) {
                                        _this.processDictionaryTemplate(listItem, entryValue);
                                    }
                                    else if (item_1.template[entryKey] instanceof BaseObject) {
                                        // Template is a BaseObject. Let it deal with its own config.
                                        item_1.template[entryKey].config = entryValue;
                                    }
                                    else if ($type.isObject(entryValue) && $type.hasValue(entryValue["type"])) {
                                        listItem = _this.createClassInstance(entryValue["type"]);
                                        if (listItem) {
                                            if (listItem instanceof BaseObject) {
                                                listItem.config = entryValue;
                                            }
                                            item_1.template[entryKey] = listItem;
                                        }
                                        else {
                                            item_1.template[entryKey] = entryValue;
                                        }
                                    }
                                    else if (listItem instanceof List) {
                                        // It's List, process it
                                        _this.processList(entryValue, listItem);
                                    }
                                    else {
                                        // Aything else. Just assing and be done with it.
                                        item_1.template[entryKey] = _this.maybeColorOrPercent(entryValue);
                                    }
                                });
                            }
                            // Check maybe there are `values` to insert
                            if ($type.hasValue(configValue.values)) {
                                if (item_1 instanceof ListTemplate) {
                                    _this.processListTemplate(configValue.values, item_1);
                                }
                                else {
                                    _this.processOrderedTemplate(configValue.values, item_1);
                                }
                            }
                        }
                    }
                    else {
                        // Something else?
                        // Not sure what to do with it on a list - ignore
                    }
                }
                else if (item_1 instanceof List) {
                    // ... a list
                    // ------------------------------------------------------------------
                    if (configKey == "children") {
                        _this.processList(configValue, item_1, _this);
                    }
                    else {
                        _this.processList(configValue, item_1);
                    }
                }
                else if (item_1 instanceof DictionaryTemplate) {
                    // ... a dictionary with template
                    // ------------------------------------------------------------------
                    _this.processDictionaryTemplate(item_1, configValue);
                }
                else if (item_1 instanceof Dictionary) {
                    // ... a dictionary
                    // ------------------------------------------------------------------
                    _this.processDictionary(item_1, configValue);
                }
                else if (item_1 instanceof Color || item_1 instanceof Percent) {
                    // ... it's a Color or Percent
                    // ------------------------------------------------------------------
                    target[configKey] = _this.maybeColorOrPercent(configValue);
                }
                else if ($type.isObject(item_1) && $type.isObject(configValue)) {
                    // ... a regular object
                    // ------------------------------------------------------------------
                    $object.copyAllProperties(configValue, item_1);
                }
                else {
                    // ... something else - probably a simple property or object
                    // ------------------------------------------------------------------
                    // Maybe convert to `Percent` or `Color`?
                    configValue = _this.maybeColorOrPercent(configValue);
                    // Assign
                    target[configKey] = configValue;
                }
            }
            else if (!_this.isReserved(configKey)) {
                // Doesn't have property set. But we're going to assume JSON config
                // creator knows what he/she is doing and set it anyway.
                target[configKey] = configValue;
            }
        }, this.configOrder);
        // Any errors?
        if (this.processingErrors.length) {
            var errors = this.processingErrors.join("\n");
            this._processingErrors = [];
            throw Error(errors);
        }
    };
    /**
     * Tries to detect if value is color or percent and converts to proper object
     * if necessary.
     *
     * Returns the same source value if no color/percent detected
     *
     * @param value  Source value
     * @return Converted value
     */
    BaseObject.prototype.maybeColorOrPercent = function (value) {
        if ($type.isString(value)) {
            if (value.match(/^[\-]?[0-9.]+\%$/)) {
                return percent($type.toNumber(value));
            }
            else if (value.match(/^\#[0-9abcdef]{3,}$/i)) {
                return color(value);
            }
        }
        return value;
    };
    BaseObject.prototype.processAdapters = function (item, config) {
        var _this = this;
        if ($type.isArray(config)) {
            $array.each(config, function (entry, index) {
                item.add(entry.key, entry.callback, entry.priority || 0, _this);
            });
        }
        else if ($type.isObject(config)) {
            $object.each(config, function (key, entry) {
                if (!item.has(key, entry)) {
                    item.add(key, entry);
                }
            });
        }
    };
    BaseObject.prototype.processEvents = function (item, config) {
        var _this = this;
        if ($type.isArray(config)) {
            $array.each(config, function (entry, index) {
                item.on(entry.type, entry.callback, _this);
            });
        }
        else if ($type.isObject(config)) {
            $object.each(config, function (key, entry) {
                if (!item.has(key, entry)) {
                    item.on(key, entry);
                }
            });
        }
    };
    /**
     * Processes JSON config for a [[DictionaryTemplate]] item.
     *
     * @todo Description
     * @param item    Item
     * @param config  Config
     */
    BaseObject.prototype.processDictionaryTemplate = function (item, config) {
        // We can only process object
        // Not sure what to do with other types - ignore
        if ($type.isObject(config)) {
            // Create an entry for each item, or override properties for
            // existing one.
            $object.each(config, function (entryKey, entryValue) {
                var listItem;
                // Get existing one, or create a new one
                if (entryKey == "template") {
                    listItem = item.template;
                }
                else if (item.hasKey(entryKey)) {
                    listItem = item.getKey(entryKey);
                }
                else {
                    listItem = item.create(entryKey);
                }
                // Set data
                if (listItem instanceof BaseObject) {
                    listItem.config = entryValue;
                }
                else if ($type.isObject(listItem) && $type.isObject(entryValue)) {
                    $object.copyAllProperties(entryValue, listItem);
                }
                else {
                    listItem.setKey(entryKey, entryValue);
                }
            });
        }
    };
    /**
     * Processes JSON config for a [[Dictionary]] item.
     *
     * @todo Description
     * @param item    Item
     * @param config  Config
     */
    BaseObject.prototype.processDictionary = function (item, config) {
        // We can only process object
        // Not sure what to do with other types - ignore
        if ($type.isObject(config)) {
            // Create an entry for each item, or override properties for
            // existing one.
            // @todo support for non-basic types
            $object.each(config, function (entryKey, entryValue) {
                item.setKey(entryKey, entryValue);
            });
        }
    };
    /**
     * Processes [[ListTemplate]].
     *
     * @param configValue  Config value
     * @param item         Item
     */
    BaseObject.prototype.processListTemplate = function (configValue, item) {
        var _this = this;
        $array.each(configValue, function (entry, index) {
            var type = _this.getConfigEntryType(entry);
            var listItem;
            if (item.hasIndex(index) && !entry["forceCreate"]) {
                listItem = item.getIndex(index);
            }
            else if (entry instanceof BaseObject) {
                // Item is already a BaseObject, no need to process it further
                item.push(entry);
                return;
            }
            else if (type) {
                listItem = item.create(type);
            }
            else {
                listItem = item.create();
            }
            if (entry === listItem) {
                // It's already the same item, do nothing
            }
            else {
                if ($type.isObject(entry)) {
                    // If the list item is BaseObject, we just need to let it
                    // deal if its own config
                    if (listItem instanceof BaseObject) {
                        listItem.config = entry;
                    }
                    else if ($type.isObject(listItem) && $type.isObject(entry)) {
                        $object.copyAllProperties(entry, listItem);
                    }
                    else {
                        item.setIndex(item.indexOf(listItem), entry);
                    }
                }
            }
        });
        // Truncate the list if it contains less items than the config
        // array
        while (configValue.length > item.length) {
            item.pop();
        }
    };
    /**
     * Processes [[OrdererListTemplate]] or [[SortedListTemplate]].
     *
     * @param configValue  Config value
     * @param item         Item
     */
    BaseObject.prototype.processOrderedTemplate = function (configValue, item) {
        var _this = this;
        $array.each(configValue, function (entry, index) {
            var type = _this.getConfigEntryType(entry);
            var listItem;
            if (type) {
                listItem = item.create(type);
            }
            else {
                listItem = item.create();
            }
            if ($type.isObject(entry)) {
                // If the list item is BaseObject, we just need to let it
                // deal if its own config
                if (listItem instanceof BaseObject) {
                    listItem.config = entry;
                }
                else if ($type.isObject(listItem) && $type.isObject(entry)) {
                    $object.copyAllProperties(entry, listItem);
                }
                else {
                    item.insert(entry);
                }
            }
        });
    };
    /**
     * Processes [[List]].
     *
     * @param configValue  Config value
     * @param item         Item
     */
    BaseObject.prototype.processList = function (configValue, item, parent) {
        var _this = this;
        // Convert to array if necessary
        if (!$type.isArray(configValue)) {
            configValue = [configValue];
        }
        // It's an array
        // Create a list item for entry
        var itemCount = item.length;
        var extraCount = 0;
        $array.each(configValue, function (entry, index) {
            if ($type.isObject(entry)) {
                // An object.
                //
                // Let's see if we can instantiate a class out of it, or we need
                // to push it into list as it is.
                //
                // If there are items already at the specified index in the list,
                // apply properties rather than create a new one.
                var listItem = void 0;
                if ((index < itemCount) && !entry["forceCreate"]) {
                    listItem = item.getIndex(index);
                }
                else if (entry instanceof BaseObject) {
                    // Item is already a BaseObject, no need to process it further
                    item.push(entry);
                    return;
                }
                else {
                    extraCount++;
                    listItem = _this.createEntryInstance(entry);
                    if (parent) {
                        listItem.parent = parent;
                    }
                    else {
                        item.push(listItem);
                    }
                }
                // If the list item is BaseObject, we just need to let it
                // deal if its own config
                if (listItem instanceof BaseObject) {
                    listItem.config = entry;
                }
                else if ($type.isObject(listItem) && $type.isObject(entry)) {
                    $object.copyAllProperties(entry, listItem);
                }
            }
            else {
                // Basic value.
                // Just push it into list, or override existing value
                if (item.hasIndex(index)) {
                    item.setIndex(index, entry);
                }
                else {
                    item.push(entry);
                }
            }
        });
        // Truncate the list if it contains less items than the config
        // array
        while (!parent && (configValue.length + extraCount) < item.length) {
            item.pop();
        }
    };
    /**
     * This function is used to sort element's JSON config properties, so that
     * some properties that absolutely need to be processed last, can be put at
     * the end.
     *
     * @ignore Exclude from docs
     * @param a  Element 1
     * @param b  Element 2
     * @return Sorting number
     */
    BaseObject.prototype.configOrder = function (a, b) {
        if (a == b) {
            return 0;
        }
        // Language must come first, so it's all set up when the rest of the
        // elements are being instantiated
        else if (a == "language") {
            return -1;
        }
        else if (b == "language") {
            return 1;
        }
        else {
            return 0;
        }
    };
    /**
     * Checks if field should be just assigned as is, without any checking when
     * processing JSON config.
     *
     * Extending functions can override this function to do their own checks.
     *
     * @param field  Field name
     * @return Assign as is?
     */
    BaseObject.prototype.asIs = function (field) {
        return $array.indexOf(["locale"], field) != -1;
    };
    /**
     * Checks if field needs to be converted to function, if it is specified
     * as string.
     *
     * @param field  Field name
     * @return Assign as function?
     */
    BaseObject.prototype.asFunction = function (field) {
        return false;
    };
    /**
     * Creates a relevant class instance if such class definition exists.
     *
     * @ignore Exclude from docs
     * @param className  Class name
     * @return Instance
     */
    BaseObject.prototype.createClassInstance = function (className) {
        if ($type.hasValue(registry.registeredClasses[className])) {
            return new registry.registeredClasses[className]();
        }
        else {
            throw Error("Invalid type: \"" + className + "\".");
        }
    };
    /**
     * Creates a class instance for a config entry using it's type. (as set in
     * `type` property)
     *
     * @ignore Exclude from docs
     * @param config  Config part
     * @return Instance
     */
    BaseObject.prototype.createEntryInstance = function (config) {
        var res;
        if ($type.hasValue(config["type"])) {
            res = this.createClassInstance(config["type"]);
        }
        if (!res) {
            return config;
        }
        return res;
    };
    /**
     * Determines config object type.
     *
     * @ignore Exclude from docs
     * @param config  Config part
     * @return Type
     */
    BaseObject.prototype.getConfigEntryType = function (config) {
        if ($type.hasValue(config["type"])) {
            if ($type.hasValue(registry.registeredClasses[config["type"]])) {
                return registry.registeredClasses[config["type"]];
            }
            else {
                throw Error("Invalid type: \"" + config["type"] + "\".");
            }
        }
        return;
    };
    /**
     * Checks if this element has a property.
     *
     * @ignore Exclude from docs
     * @param prop  Property name
     * @return Has property?
     */
    BaseObject.prototype.hasProperty = function (prop) {
        return prop in this ? true : false;
    };
    /**
     * Checkes whether JSON key is a reserved keyword.
     *
     * @param key  Key
     * @return Reserved
     */
    BaseObject.prototype.isReserved = function (key) {
        return ["type", "forceCreate"].indexOf(key) !== -1;
    };
    Object.defineProperty(BaseObject.prototype, "processingErrors", {
        /**
         * A list of errors that happened during JSON processing.
         *
         * @return Errors
         */
        get: function () {
            if (!this._processingErrors) {
                this._processingErrors = [];
            }
            return this._processingErrors;
        },
        enumerable: true,
        configurable: true
    });
    return BaseObject;
}());
export { BaseObject };
;
/**
 * A version of [[BaseObject]] with events properties and methods.
 * Classes that use [[EventDispatcher]] should extend this instead of
 * [[BaseObject]] directly.
 */
var BaseObjectEvents = /** @class */ (function (_super) {
    __extends(BaseObjectEvents, _super);
    /**
     * Constructor
     */
    function BaseObjectEvents() {
        var _this = _super.call(this) || this;
        _this.className = "BaseObjectEvents";
        return _this;
    }
    Object.defineProperty(BaseObjectEvents.prototype, "events", {
        /**
         * An [[EventDispatcher]] instance
         */
        get: function () {
            if (!this._eventDispatcher) {
                this._eventDispatcher = new EventDispatcher();
                this._disposers.push(this._eventDispatcher);
            }
            return this._eventDispatcher;
        },
        enumerable: true,
        configurable: true
    });
    //public set events(value:EventDispatcher<AMEvent<this, this["_events"]>>){
    //	this._eventDispatcher = value;
    //}
    /**
     * Dispatches an event using own event dispatcher. Will automatically
     * populate event data object with event type and target (this element).
     * It also checks if there are any handlers registered for this sepecific
     * event.
     *
     * @param eventType Event type (name)
     * @param data      Data to pass into event handler(s)
     */
    BaseObjectEvents.prototype.dispatch = function (eventType, data) {
        // @todo Implement proper type check
        if (this._eventDispatcher) {
            if (this.events.isEnabled(eventType)) {
                if (data) {
                    data.type = eventType;
                    data.target = data.target || this;
                    this.events.dispatch(eventType, {
                        type: eventType,
                        target: this
                    });
                }
                else {
                    this.events.dispatch(eventType, {
                        type: eventType,
                        target: this
                    });
                }
            }
        }
    };
    /**
     * Works like `dispatch`, except event is triggered immediately, without
     * waiting for the next frame cycle.
     *
     * @param eventType Event type (name)
     * @param data      Data to pass into event handler(s)
     */
    BaseObjectEvents.prototype.dispatchImmediately = function (eventType, data) {
        // @todo Implement proper type check
        if (this._eventDispatcher) {
            if (this.events.isEnabled(eventType)) {
                if (data) {
                    data.type = eventType;
                    data.target = data.target || this;
                    this.events.dispatchImmediately(eventType, data);
                }
                else {
                    this.events.dispatchImmediately(eventType, {
                        type: eventType,
                        target: this
                    });
                }
            }
        }
    };
    /**
     * Copies all parameters from another [[Sprite]].
     *
     * @param source Source object
     */
    BaseObjectEvents.prototype.copyFrom = function (source) {
        _super.prototype.copyFrom.call(this, source);
        if (source._eventDispatcher) {
            this.events.copyFrom(source._eventDispatcher);
        }
    };
    return BaseObjectEvents;
}(BaseObject));
export { BaseObjectEvents };
//# sourceMappingURL=Base.js.map