devextreme/dist/transpiled/data/array_store.js

HTML5 JavaScript Component Suite for Responsive Web Development

"use strict";

var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };

var extend = require("../core/utils/extend").extend,
    typeUtils = require("../core/utils/type"),
    Guid = require("../core/guid"),
    objectUtils = require("../core/utils/object"),
    keysEqual = require("./utils").keysEqual,
    Query = require("./query"),
    errors = require("./errors").errors,
    Store = require("./abstract_store"),
    Deferred = require("../core/utils/deferred").Deferred;

var hasKey = function hasKey(target, keyOrKeys) {
    var key,
        keys = typeof keyOrKeys === "string" ? keyOrKeys.split() : keyOrKeys.slice();

    while (keys.length) {
        key = keys.shift();
        if (key in target) {
            return true;
        }
    }

    return false;
};

var trivialPromise = function trivialPromise() {
    var d = new Deferred();
    return d.resolve.apply(d, arguments).promise();
};

var rejectedPromise = function rejectedPromise() {
    var d = new Deferred();
    return d.reject.apply(d, arguments).promise();
};

/**
* @name ArrayStore
* @publicName ArrayStore
* @inherits Store
* @type object
* @module data/array_store
* @export default
*/
var ArrayStore = Store.inherit({
    ctor: function ctor(options) {
        if (Array.isArray(options)) {
            options = { data: options };
        } else {
            options = options || {};
        }

        this.callBase(options);

        var initialArray = options.data;
        if (initialArray && !Array.isArray(initialArray)) {
            throw errors.Error("E4006");
        }

        /**
         * @name ArrayStoreOptions.data
         * @publicName data
         * @type Array<any>
         */
        this._array = initialArray || [];
    },

    /**
    * @name ArrayStoreMethods.createQuery
    * @publicName createQuery()
    * @return object
    */
    createQuery: function createQuery() {
        return Query(this._array, {
            errorHandler: this._errorHandler
        });
    },

    _byKeyImpl: function _byKeyImpl(key) {
        var index = this._indexByKey(key);

        if (index === -1) {
            return rejectedPromise(errors.Error("E4009"));
        }

        return trivialPromise(this._array[index]);
    },

    _insertImpl: function _insertImpl(values) {
        var keyExpr = this.key(),
            keyValue,
            obj;

        if (typeUtils.isPlainObject(values)) {
            obj = extend({}, values);
        } else {
            obj = values;
        }

        if (keyExpr) {
            keyValue = this.keyOf(obj);
            if (keyValue === undefined || (typeof keyValue === "undefined" ? "undefined" : _typeof(keyValue)) === "object" && typeUtils.isEmptyObject(keyValue)) {
                if (Array.isArray(keyExpr)) {
                    throw errors.Error("E4007");
                }
                keyValue = obj[keyExpr] = String(new Guid());
            } else {
                if (this._array[this._indexByKey(keyValue)] !== undefined) {
                    return rejectedPromise(errors.Error("E4008"));
                }
            }
        } else {
            keyValue = obj;
        }

        this._array.push(obj);
        return trivialPromise(values, keyValue);
    },

    _updateImpl: function _updateImpl(key, values) {
        var index,
            target,
            keyExpr = this.key(),
            extendComplexObject = true;

        if (keyExpr) {

            if (hasKey(values, keyExpr) && !keysEqual(keyExpr, key, this.keyOf(values))) {
                return rejectedPromise(errors.Error("E4017"));
            }

            index = this._indexByKey(key);
            if (index < 0) {
                return rejectedPromise(errors.Error("E4009"));
            }

            target = this._array[index];
        } else {
            target = key;
        }

        objectUtils.deepExtendArraySafe(target, values, extendComplexObject);
        return trivialPromise(key, values);
    },

    _removeImpl: function _removeImpl(key) {
        var index = this._indexByKey(key);
        if (index > -1) {
            this._array.splice(index, 1);
        }
        return trivialPromise(key);
    },

    _indexByKey: function _indexByKey(key) {
        for (var i = 0, arrayLength = this._array.length; i < arrayLength; i++) {
            if (keysEqual(this.key(), this.keyOf(this._array[i]), key)) {
                return i;
            }
        }
        return -1;
    },

    /**
    * @name ArrayStoreMethods.clear
    * @publicName clear()
    */
    clear: function clear() {
        this.fireEvent("modifying");
        this._array = [];
        this.fireEvent("modified");
    }
}, "array");

module.exports = ArrayStore;