breeze-client 2.1.7 → 2.2.0

package/esm2022/src/observable-array.mjs

@@ -0,0 +1,183 @@
+import { core } from './core';
+let mixin = {
+    push: function (...args) {
+        if (this._inProgress) {
+            return -1;
+        }
+        let goodAdds = this._getGoodAdds(args);
+        if (!goodAdds.length) {
+            return this.length;
+        }
+        this._beforeChange();
+        let result;
+        let objPrototype = Object.getPrototypeOf(this);
+        if (objPrototype.push) {
+            result = objPrototype.push.apply(this, goodAdds);
+        }
+        else {
+            result = Array.prototype.push.apply(this, goodAdds);
+        }
+        processAdds(this, goodAdds);
+        return result;
+    },
+    _push: function (...args) {
+        if (this._inProgress) {
+            return -1;
+        }
+        let goodAdds = args;
+        this._beforeChange();
+        let result;
+        let objPrototype = Object.getPrototypeOf(this);
+        if (objPrototype.push) {
+            result = objPrototype.push.apply(this, goodAdds);
+        }
+        else {
+            result = Array.prototype.push.apply(this, goodAdds);
+        }
+        processAdds(this, goodAdds);
+        return result;
+    },
+    unshift: function (...args) {
+        let goodAdds = this._getGoodAdds(args);
+        if (!goodAdds.length) {
+            return this.length;
+        }
+        this._beforeChange();
+        let result;
+        let objPrototype = Object.getPrototypeOf(this);
+        if (objPrototype.unshift) {
+            result = objPrototype.unshift.apply(this, goodAdds);
+        }
+        else {
+            result = Array.prototype.unshift.apply(this, goodAdds);
+        }
+        processAdds(this, goodAdds);
+        return result;
+    },
+    pop: function () {
+        this._beforeChange();
+        let result;
+        let objPrototype = Object.getPrototypeOf(this);
+        if (objPrototype.pop) {
+            result = objPrototype.pop.apply(this);
+        }
+        else {
+            result = Array.prototype.pop.apply(this);
+        }
+        processRemoves(this, [result]);
+        return result;
+    },
+    shift: function () {
+        this._beforeChange();
+        let result;
+        let objPrototype = Object.getPrototypeOf(this);
+        if (objPrototype.shift) {
+            result = objPrototype.shift.apply(this);
+        }
+        else {
+            result = Array.prototype.shift.apply(this);
+        }
+        processRemoves(this, [result]);
+        return result;
+    },
+    splice: function (...args) {
+        let goodAdds = this._getGoodAdds(core.arraySlice(args, 2));
+        let newArgs = core.arraySlice(args, 0, 2).concat(goodAdds);
+        this._beforeChange();
+        let result;
+        let objPrototype = Object.getPrototypeOf(this);
+        if (objPrototype.splice) {
+            result = objPrototype.splice.apply(this, newArgs);
+        }
+        else {
+            result = Array.prototype.splice.apply(this, newArgs);
+        }
+        processRemoves(this, result);
+        if (goodAdds.length) {
+            processAdds(this, goodAdds);
+        }
+        return result;
+    },
+    getEntityAspect: function () {
+        return this.parent.entityAspect || this.parent.complexAspect.getEntityAspect();
+    },
+    _getEventParent: function () {
+        return this.getEntityAspect();
+    },
+    _getPendingPubs: function () {
+        let em = this.getEntityAspect().entityManager;
+        return em && em._pendingPubs;
+    },
+    _beforeChange: function () {
+        // default is to do nothing
+    }
+};
+function updateEntityState(obsArray) {
+    let entityAspect = obsArray.getEntityAspect();
+    if (entityAspect.entityState.isUnchanged()) {
+        entityAspect.setModified();
+    }
+    if (entityAspect.entityState.isModified() && !obsArray._origValues) {
+        obsArray._origValues = obsArray.slice(0);
+    }
+}
+function publish(publisher, eventName, eventArgs) {
+    let pendingPubs = publisher._getPendingPubs();
+    if (pendingPubs) {
+        if (!publisher._pendingArgs) {
+            publisher._pendingArgs = eventArgs;
+            pendingPubs.push(function () {
+                publisher[eventName].publish(publisher._pendingArgs);
+                publisher._pendingArgs = null;
+            });
+        }
+        else {
+            combineArgs(publisher._pendingArgs, eventArgs);
+        }
+    }
+    else {
+        publisher[eventName].publish(eventArgs);
+    }
+}
+function initializeParent(obsArray, parent, parentProperty) {
+    obsArray.parent = parent;
+    obsArray.parentProperty = parentProperty;
+}
+function processAdds(obsArray, adds) {
+    obsArray._processAdds(adds);
+    // this is referencing the name of the method on the complexArray not the name of the event
+    //var args = { added: adds };
+    //args[obsArray._typeName] = obsArray;
+    publish(obsArray, "arrayChanged", { array: obsArray, added: adds });
+}
+function processRemoves(obsArray, removes) {
+    obsArray._processRemoves(removes);
+    // this is referencing the name of the method on the array not the name of the event
+    publish(obsArray, "arrayChanged", { array: obsArray, removed: removes });
+}
+// TODO: see if this function already exists in core and can be imported.
+function combineArgs(target, source) {
+    for (let key in source) {
+        if (key !== "array" && target.hasOwnProperty(key)) {
+            let sourceValue = source[key];
+            let targetValue = target[key];
+            if (targetValue) {
+                if (!Array.isArray(targetValue)) {
+                    throw new Error("Cannot combine non array args");
+                }
+                Array.prototype.push.apply(targetValue, sourceValue);
+            }
+            else {
+                target[key] = sourceValue;
+            }
+        }
+    }
+}
+/** @hidden @internal */
+export const observableArray = {
+    mixin: mixin,
+    updateEntityState: updateEntityState,
+    publish: publish,
+    initializeParent: initializeParent
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"observable-array.js","sourceRoot":"","sources":["../../../src/observable-array.ts"],"names":[],"mappings":"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","sourcesContent":["import { core } from './core';\r\nimport { BreezeEvent } from './event';\r\nimport { EntityAspect } from './entity-aspect';\r\nimport { DataProperty } from './entity-metadata';\r\n\r\n/** @hidden */\r\nexport interface ObservableArray {\r\n  push: (...args: any[]) => number;\r\n  _push: (...args: any[]) => number;\r\n  unshift: (...args: any[]) =>  number;\r\n  pop: () => any;\r\n  shift: () => any;\r\n  splice: (...args: any[]) => any[];\r\n  slice: (a: number, b?: number) => any[]; // implemented on the native array\r\n  length: number;\r\n  \r\n  getEntityAspect: () => EntityAspect;\r\n  arrayChanged: BreezeEvent<ArrayChangedArgs>;\r\n  parent?: Object;\r\n  parentProperty?: DataProperty;\r\n  _getEventParent: () => Object;\r\n  _getPendingPubs: () => any[]; // TODO: Pub[]\r\n  _beforeChange: () => void;\r\n  _processAdds(items: any[]): void;\r\n  _processRemoves(items: any[]): void;\r\n  _origValues: any[];\r\n  _pendingArgs: any;\r\n}\r\n\r\nexport interface ArrayChangedArgs {\r\n  array: any[];\r\n  added?: any[]; \r\n  removed?: any[];\r\n}\r\n\r\nlet mixin = {\r\n  push: function(...args: any[]) {\r\n    if (this._inProgress) {\r\n      return -1;\r\n    }\r\n\r\n    let goodAdds = this._getGoodAdds(args);\r\n    if (!goodAdds.length) {\r\n      return this.length;\r\n    }\r\n    this._beforeChange();\r\n    let result;\r\n    let objPrototype = Object.getPrototypeOf(this);\r\n    if (objPrototype.push) {\r\n        result = objPrototype.push.apply(this, goodAdds);\r\n    } else {\r\n        result = Array.prototype.push.apply(this, goodAdds);\r\n    }\r\n    processAdds(this, goodAdds);\r\n    return result;\r\n  },\r\n\r\n  _push: function(...args: any[]) {\r\n    if (this._inProgress) {\r\n      return -1;\r\n    }\r\n    let goodAdds = args;\r\n    this._beforeChange();\r\n    let result;\r\n    let objPrototype = Object.getPrototypeOf(this);\r\n    if (objPrototype.push) {\r\n        result = objPrototype.push.apply(this, goodAdds);\r\n    } else {\r\n        result = Array.prototype.push.apply(this, goodAdds);\r\n    }\r\n    processAdds(this, goodAdds);\r\n    return result;\r\n  },\r\n\r\n  unshift: function(...args: any[]) {\r\n    let goodAdds = this._getGoodAdds(args);\r\n    if (!goodAdds.length) {\r\n      return this.length;\r\n    }\r\n    this._beforeChange();\r\n    let result;\r\n    let objPrototype = Object.getPrototypeOf(this);\r\n    if (objPrototype.unshift) {\r\n        result = objPrototype.unshift.apply(this, goodAdds);\r\n    } else {\r\n        result = Array.prototype.unshift.apply(this, goodAdds);\r\n    }\r\n    processAdds(this, goodAdds);\r\n    return result;\r\n  },\r\n\r\n  pop: function() {\r\n    this._beforeChange();\r\n    let result;\r\n    let objPrototype = Object.getPrototypeOf(this);\r\n    if (objPrototype.pop) {\r\n        result = objPrototype.pop.apply(this);\r\n    } else {\r\n        result = Array.prototype.pop.apply(this);\r\n    }\r\n    processRemoves(this, [result]);\r\n    return result;\r\n  },\r\n\r\n  shift: function() {\r\n    this._beforeChange();\r\n    let result;\r\n    let objPrototype = Object.getPrototypeOf(this);\r\n    if (objPrototype.shift) {\r\n        result = objPrototype.shift.apply(this);\r\n    } else {\r\n        result = Array.prototype.shift.apply(this);\r\n    }    \r\n    processRemoves(this, [result]);\r\n    return result;\r\n  },\r\n\r\n  splice: function(...args: any[]) {\r\n    let goodAdds = this._getGoodAdds(core.arraySlice(args, 2));\r\n    let newArgs = core.arraySlice(args, 0, 2).concat(goodAdds);\r\n    this._beforeChange();\r\n    let result;\r\n    let objPrototype = Object.getPrototypeOf(this);\r\n    if (objPrototype.splice) {\r\n        result = objPrototype.splice.apply(this, newArgs);\r\n    } else {\r\n        result = Array.prototype.splice.apply(this, newArgs);\r\n    }\r\n    processRemoves(this, result);\r\n\r\n    if (goodAdds.length) {\r\n      processAdds(this, goodAdds);\r\n    }\r\n    return result;\r\n  },\r\n\r\n  getEntityAspect: function() {\r\n    return this.parent.entityAspect || this.parent.complexAspect.getEntityAspect();\r\n  },\r\n\r\n  _getEventParent: function() {\r\n    return this.getEntityAspect();\r\n  },\r\n\r\n  _getPendingPubs: function () {\r\n    let em = this.getEntityAspect().entityManager;\r\n    return em && em._pendingPubs;\r\n  },\r\n\r\n  _beforeChange:  function () {\r\n    // default is to do nothing\r\n  }\r\n};\r\n\r\nfunction updateEntityState(obsArray: ObservableArray) {\r\n  let entityAspect = obsArray.getEntityAspect();\r\n  if (entityAspect.entityState.isUnchanged()) {\r\n    entityAspect.setModified();\r\n  }\r\n  if (entityAspect.entityState.isModified() && !obsArray._origValues) {\r\n    obsArray._origValues = obsArray.slice(0);\r\n  }\r\n}\r\n\r\nfunction publish(publisher: ObservableArray, eventName: string, eventArgs: any) {\r\n  let pendingPubs = publisher._getPendingPubs();\r\n  if (pendingPubs) {\r\n    if (!publisher._pendingArgs) {\r\n      publisher._pendingArgs = eventArgs;\r\n      pendingPubs.push(function () {\r\n        publisher[eventName].publish(publisher._pendingArgs);\r\n        publisher._pendingArgs = null;\r\n      });\r\n    } else {\r\n      combineArgs(publisher._pendingArgs, eventArgs);\r\n    }\r\n  } else {\r\n    publisher[eventName].publish(eventArgs);\r\n  }\r\n}\r\n\r\nfunction initializeParent(obsArray: any, parent: Object, parentProperty: DataProperty) {\r\n  obsArray.parent = parent;\r\n  obsArray.parentProperty = parentProperty;\r\n}\r\n\r\nfunction processAdds(obsArray: ObservableArray, adds: any[]) {\r\n  obsArray._processAdds(adds);\r\n  // this is referencing the name of the method on the complexArray not the name of the event\r\n  //var args = { added: adds };\r\n  //args[obsArray._typeName] = obsArray;\r\n  publish(obsArray, \"arrayChanged\", { array: obsArray, added: adds });\r\n}\r\n\r\nfunction processRemoves(obsArray: ObservableArray, removes: any[]) {\r\n  obsArray._processRemoves(removes);\r\n  // this is referencing the name of the method on the array not the name of the event\r\n  publish(obsArray, \"arrayChanged\", { array: obsArray, removed: removes });\r\n}\r\n\r\n// TODO: see if this function already exists in core and can be imported.\r\nfunction combineArgs(target: Object, source: Object) {\r\n  for (let key in source) {\r\n    if (key !== \"array\" && target.hasOwnProperty(key)) {\r\n      let sourceValue = source[key];\r\n      let targetValue = target[key];\r\n      if (targetValue) {\r\n        if (!Array.isArray(targetValue)) {\r\n          throw new Error(\"Cannot combine non array args\");\r\n        }\r\n        Array.prototype.push.apply(targetValue, sourceValue);\r\n      } else {\r\n        target[key] = sourceValue;\r\n      }\r\n    }\r\n  }\r\n}\r\n/** @hidden @internal */\r\nexport const observableArray = {\r\n  mixin: mixin,\r\n  updateEntityState: updateEntityState,\r\n  publish: publish,\r\n  initializeParent: initializeParent\r\n};\r\n"]}