can-observable-array/dist/can-observable-array.js

Observable arrays

"use strict";

function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }

function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }

function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }

function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }

function _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get(target, property, receiver || target); }

function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }

function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }

function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }

function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }

function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }

function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }

var canReflect = require("can-reflect");

var _require = require("can-observable-mixin"),
    createConstructorFunction = _require.createConstructorFunction,
    makeDefineInstanceKey = _require.makeDefineInstanceKey,
    mixins = _require.mixins,
    mixinMapProps = _require.mixinMapProps,
    mixinTypeEvents = _require.mixinTypeEvents;

var _require2 = require("./helpers"),
    convertItem = _require2.convertItem,
    convertItems = _require2.convertItems,
    dispatchLengthPatch = _require2.dispatchLengthPatch;

var namespace = require("can-namespace");

var ProxyArray = require("./proxy-array")();

var queues = require("can-queues");

var type = require("can-type"); // symbols aren't enumerable ... we'd need a version of Object that treats them that way


var localOnPatchesSymbol = "can.patches";
var onKeyValueSymbol = Symbol.for("can.onKeyValue");
var offKeyValueSymbol = Symbol.for("can.offKeyValue");
var metaSymbol = Symbol.for("can.meta");

function isListLike(items) {
  return canReflect.isListLike(items) && typeof items !== "string";
}

var MixedInArray = mixinTypeEvents(mixinMapProps(ProxyArray));

var ObservableArray = /*#__PURE__*/function (_MixedInArray, _Symbol$species, _Symbol$for, _Symbol$for2, _Symbol$for3, _Symbol$for4, _Symbol$for5, _Symbol$for6) {
  _inherits(ObservableArray, _MixedInArray);

  var _super = _createSuper(ObservableArray);

  // TODO define stuff here
  function ObservableArray(items, props) {
    var _this;

    _classCallCheck(this, ObservableArray);

    // Arrays can be passed a length like `new Array(15)`
    var isLengthArg = typeof items === "number";

    if (isLengthArg) {
      _this = _super.call(this, items);
    } else if (arguments.length > 0 && !isListLike(items)) {
      throw new Error("can-observable-array: Unexpected argument: " + _typeof(items));
    } else {
      _this = _super.call(this);
    }

    mixins.finalizeClass(_this.constructor);
    mixins.initialize(_assertThisInitialized(_this), props || {});

    for (var i = 0, len = items && items.length; i < len; i++) {
      _this[i] = convertItem(_this.constructor, items[i]);
    } // Define class fields observables
    //and return the proxy


    return _possibleConstructorReturn(_this, new Proxy(_assertThisInitialized(_this), {
      defineProperty: function defineProperty(target, prop, descriptor) {
        if ('items' === prop) {
          throw new Error('ObservableArray does not support a class field named items. Try using a different name or using static items');
        } // do not create expando properties for special keys set by can-observable-mixin


        if (prop === '_instanceDefinitions') {
          return Reflect.defineProperty(target, prop, descriptor);
        }

        var value = descriptor.value; // do not create expando properties for properties that are described
        // by `static props` or `static propertyDefaults`

        var props = target.constructor.props;

        if (props && props[prop] || target.constructor.propertyDefaults) {
          if (value) {
            target.set(prop, value);
            return true;
          }

          return Reflect.defineProperty(target, prop, descriptor);
        } // create expandos to make all other properties observable


        return mixins.expando(target, prop, value);
      }
    }));
  }

  _createClass(ObservableArray, [{
    key: "push",
    value: function push() {
      var _get2;

      for (var _len = arguments.length, items = new Array(_len), _key = 0; _key < _len; _key++) {
        items[_key] = arguments[_key];
      }

      return (_get2 = _get(_getPrototypeOf(ObservableArray.prototype), "push", this)).call.apply(_get2, [this].concat(items));
    }
  }, {
    key: "unshift",
    value: function unshift() {
      var _get3;

      for (var _len2 = arguments.length, items = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
        items[_key2] = arguments[_key2];
      }

      return (_get3 = _get(_getPrototypeOf(ObservableArray.prototype), "unshift", this)).call.apply(_get3, [this].concat(items));
    }
  }, {
    key: "filter",
    value: function filter(callback) {
      if (_typeof(callback) === "object") {
        var props = callback;

        callback = function callback(item) {
          for (var prop in props) {
            if (item[prop] !== props[prop]) {
              return false;
            }
          }

          return true;
        };
      }

      return _get(_getPrototypeOf(ObservableArray.prototype), "filter", this).call(this, callback);
    }
  }, {
    key: "forEach",
    value: function forEach() {
      for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
        args[_key3] = arguments[_key3];
      }

      return Array.prototype.forEach.apply(this, args);
    }
  }, {
    key: "splice",
    value: function splice() {
      for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
        args[_key4] = arguments[_key4];
      }

      var index = args[0],
          howMany = args[1],
          added = [],
          i,
          len,
          listIndex,
          allSame = args.length > 2;
      index = index || 0; // converting the arguments to the right type

      for (i = 0, len = args.length - 2; i < len; i++) {
        listIndex = i + 2;
        added.push(args[listIndex]); // Now lets check if anything will change

        if (this[i + index] !== args[listIndex]) {
          allSame = false;
        }
      } // if nothing has changed, then return


      if (allSame && this.length <= added.length) {
        return added;
      } // default howMany if not provided


      if (howMany === undefined) {
        howMany = args[1] = this.length - index;
      }

      queues.batch.start();

      var removed = _get(_getPrototypeOf(ObservableArray.prototype), "splice", this).apply(this, args);

      queues.batch.stop();
      return removed;
    }
  }, {
    key: _Symbol$for2,
    value:
    /* Symbols */
    function value(index, deleteCount, insert) {
      return this.splice.apply(this, _toConsumableArray([index, deleteCount].concat(insert)));
    }
  }, {
    key: _Symbol$for3,
    value: function value(handler, queue) {
      this[onKeyValueSymbol](localOnPatchesSymbol, handler, queue);
    }
  }, {
    key: _Symbol$for4,
    value: function value(handler, queue) {
      this[offKeyValueSymbol](localOnPatchesSymbol, handler, queue);
    }
  }, {
    key: _Symbol$for5,
    get: function get() {
      return true;
    }
  }, {
    key: _Symbol$for6,
    value: function value() {
      var base = _get(_getPrototypeOf(ObservableArray.prototype), Symbol.for("can.getOwnEnumerableKeys"), this).call(this);

      var keysSet = new Set([].concat(_toConsumableArray(Object.keys(this)), _toConsumableArray(base)));
      return Array.from(keysSet);
    }
  }], [{
    key: _Symbol$species,
    get: function get() {
      return this;
    }
  }, {
    key: _Symbol$for,
    value: function value(items) {
      var array = items || [];
      return new this(array);
    }
  }, {
    key: "convertsTo",
    value: function convertsTo(Type) {
      var ConvertedType = type.convert(Type);

      var ArrayType = /*#__PURE__*/function (_this2) {
        _inherits(ArrayType, _this2);

        var _super2 = _createSuper(ArrayType);

        function ArrayType() {
          _classCallCheck(this, ArrayType);

          return _super2.apply(this, arguments);
        }

        _createClass(ArrayType, null, [{
          key: "items",
          get: function get() {
            return ConvertedType;
          }
        }]);

        return ArrayType;
      }(this);

      var name = "ConvertedObservableArray<".concat(canReflect.getName(Type), ">");
      canReflect.setName(ArrayType, name);
      return ArrayType;
    }
  }]);

  return ObservableArray;
}(MixedInArray, Symbol.species, Symbol.for("can.new"), Symbol.for("can.splice"), Symbol.for("can.onPatches"), Symbol.for("can.offPatches"), Symbol.for("can.isListLike"), Symbol.for("can.getOwnEnumerableKeys"));

var mutateMethods = {
  "push": function push(arr, args) {
    return [{
      index: arr.length - args.length,
      deleteCount: 0,
      insert: args,
      type: "splice"
    }];
  },
  "pop": function pop(arr, args, oldLength) {
    return [{
      index: arr.length,
      deleteCount: oldLength > 0 ? 1 : 0,
      type: "splice"
    }];
  },
  "shift": function shift(arr, args, oldLength) {
    return [{
      index: 0,
      deleteCount: oldLength > 0 ? 1 : 0,
      type: "splice"
    }];
  },
  "unshift": function unshift(arr, args) {
    return [{
      index: 0,
      deleteCount: 0,
      insert: args,
      type: "splice"
    }];
  },
  "splice": function splice(arr, args, oldLength) {
    var index = args[0] < 0 ? Math.max(oldLength + args[0], 0) : Math.min(oldLength, args[0]);
    return [{
      index: index,
      deleteCount: Math.max(0, Math.min(args[1], oldLength - index)),
      insert: args.slice(2),
      type: "splice"
    }];
  },
  "sort": function sort(arr) {
    return [{
      index: 0,
      deleteCount: arr.length,
      insert: arr,
      type: "splice"
    }];
  },
  "reverse": function reverse(arr) {
    return [{
      index: 0,
      deleteCount: arr.length,
      insert: arr,
      type: "splice"
    }];
  }
};
var convertArgs = {
  "push": function push(arr, args) {
    return convertItems(arr.constructor, args);
  },
  "unshift": function unshift(arr, args) {
    return convertItems(arr.constructor, args);
  },
  "splice": function splice(arr, args) {
    return args.slice(0, 2).concat(convertItems(arr.constructor, args.slice(2)));
  }
};
canReflect.eachKey(mutateMethods, function (makePatches, prop) {
  var protoFn = ObservableArray.prototype[prop];

  ObservableArray.prototype[prop] = function () {
    var oldLength = this.length;
    var args = Array.from(arguments);

    if (convertArgs[prop]) {
      args = convertArgs[prop](this, args);
    } // prevent `length` event from being dispatched by get/set proxy hooks


    this[metaSymbol].preventSideEffects = (this[metaSymbol].preventSideEffects || 0) + 1;
    var result = protoFn.apply(this, args);
    this[metaSymbol].preventSideEffects--;
    var patches = makePatches(this, args, oldLength);
    dispatchLengthPatch.call(this, prop, patches, this.length, oldLength);
    return result;
  };
});
makeDefineInstanceKey(ObservableArray); // Export a constructor function to workaround an issue where ES2015 classes
// cannot be extended in code that's transpiled by Babel.

module.exports = namespace.ObservableArray = createConstructorFunction(ObservableArray);