breeze-client 2.2.0 → 2.2.1-cjs

package/esm2015/src/assert-param.js

@@ -0,0 +1,312 @@
+import { core } from './core';
+/** @hidden @internal */
+export class Param {
+    constructor(v, name) {
+        /** @hidden @internal */
+        this._applyOne = function (instance) {
+            if (this.v !== undefined) {
+                instance[this.name] = this.v;
+            }
+            else {
+                if (this.defaultValue !== undefined) {
+                    instance[this.name] = this.defaultValue;
+                }
+            }
+        };
+        this.MESSAGE_PREFIX = "The '%1' parameter ";
+        this.v = v;
+        this.name = name;
+        this._contexts = [null];
+    }
+    isObject() {
+        return this.isTypeOf('object');
+    }
+    isBoolean() {
+        return this.isTypeOf('boolean');
+    }
+    isString() {
+        return this.isTypeOf('string');
+    }
+    isNumber() {
+        return this.isTypeOf('number');
+    }
+    isFunction() {
+        return this.isTypeOf('function');
+    }
+    isNonEmptyString() {
+        return addContext(this, {
+            fn: isNonEmptyString,
+            msg: "must be a nonEmpty string"
+        });
+    }
+    isTypeOf(typeName) {
+        return addContext(this, {
+            fn: isTypeOf,
+            typeName: typeName,
+            msg: "must be a '" + typeName + "'"
+        });
+    }
+    isInstanceOf(type, typeName) {
+        typeName = typeName || type.prototype._$typeName;
+        return addContext(this, {
+            fn: isInstanceOf,
+            type: type,
+            typeName: typeName,
+            msg: "must be an instance of '" + typeName + "'"
+        });
+    }
+    hasProperty(propertyName) {
+        return addContext(this, {
+            fn: hasProperty,
+            propertyName: propertyName,
+            msg: "must have a '" + propertyName + "' property"
+        });
+    }
+    isEnumOf(enumType) {
+        return addContext(this, {
+            fn: isEnumOf,
+            enumType: enumType,
+            msg: "must be an instance of the '" + (enumType.name || 'unknown') + "' enumeration"
+        });
+    }
+    isRequired(allowNull = false) {
+        return addContext(this, {
+            fn: isRequired,
+            allowNull: allowNull,
+            msg: "is required"
+        });
+    }
+    isOptional() {
+        let context = {
+            fn: isOptional,
+            prevContext: null,
+            msg: isOptionalMessage
+        };
+        return addContext(this, context);
+    }
+    isNonEmptyArray() {
+        return this.isArray(true);
+    }
+    isArray(mustNotBeEmpty) {
+        let context = {
+            fn: isArray,
+            mustNotBeEmpty: mustNotBeEmpty,
+            prevContext: null,
+            msg: isArrayMessage
+        };
+        return addContext(this, context);
+    }
+    or() {
+        this._contexts.push(null);
+        this._context = null;
+        return this;
+    }
+    check(defaultValue) {
+        let ok = exec(this);
+        if (ok === undefined)
+            return;
+        if (!ok) {
+            throw new Error(this.getMessage());
+        }
+        if (this.v !== undefined) {
+            return this.v;
+        }
+        else {
+            return defaultValue;
+        }
+    }
+    /** @hidden @internal */
+    // called from outside this file.
+    _addContext(context) {
+        return addContext(this, context);
+    }
+    getMessage() {
+        let that = this;
+        let message = this._contexts.map(function (context) {
+            return getMessage(context, that.v);
+        }).join(", or it ");
+        return core.formatString(this.MESSAGE_PREFIX, this.name) + " " + message;
+    }
+    withDefault(defaultValue) {
+        this.defaultValue = defaultValue;
+        return this;
+    }
+    whereParam(propName) {
+        return this.parent.whereParam(propName);
+    }
+    applyAll(instance, checkOnly = false) {
+        let parentTypeName = instance._$typeName;
+        let allowUnknownProperty = (parentTypeName && this.parent.config._$typeName === parentTypeName);
+        let clone = core.extend({}, this.parent.config);
+        this.parent.params.forEach(function (p) {
+            if (!allowUnknownProperty)
+                delete clone[p.name];
+            try {
+                p.check();
+            }
+            catch (e) {
+                throwConfigError(instance, e.message);
+            }
+            (!checkOnly) && p._applyOne(instance);
+        });
+        // should be no properties left in the clone
+        if (!allowUnknownProperty) {
+            for (let key in clone) {
+                // allow props with an undefined value
+                if (clone[key] !== undefined) {
+                    throwConfigError(instance, core.formatString("Unknown property: '%1'.", key));
+                }
+            }
+        }
+    }
+}
+/** @hidden @internal */
+export let assertParam = function (v, name) {
+    return new Param(v, name);
+};
+function isTypeOf(context, v) {
+    if (v == null)
+        return false;
+    if (typeof (v) === context.typeName)
+        return true;
+    return false;
+}
+function isNonEmptyString(context, v) {
+    if (v == null)
+        return false;
+    return (typeof (v) === 'string') && v.length > 0;
+}
+function isInstanceOf(context, v) {
+    if (v == null || context.type == null)
+        return false;
+    return (v instanceof context.type);
+}
+function isEnumOf(context, v) {
+    if (v == null || context.enumType == null)
+        return false;
+    return context.enumType.contains(v);
+}
+function hasProperty(context, v) {
+    if (v == null || context.propertyName == null)
+        return false;
+    return (v[context.propertyName] !== undefined);
+}
+function isRequired(context, v) {
+    if (context.allowNull) {
+        return v !== undefined;
+    }
+    else {
+        return v != null;
+    }
+}
+function isOptional(context, v) {
+    if (v == null)
+        return true;
+    let prevContext = context.prevContext;
+    if (prevContext && prevContext.fn) {
+        return prevContext.fn(prevContext, v);
+    }
+    else {
+        return true;
+    }
+}
+function isOptionalMessage(context, v) {
+    let prevContext = context.prevContext;
+    let element = prevContext ? " or it " + getMessage(prevContext, v) : "";
+    return "is optional" + element;
+}
+function isArray(context, v) {
+    if (!Array.isArray(v)) {
+        return false;
+    }
+    if (context.mustNotBeEmpty) {
+        if (v.length === 0)
+            return false;
+    }
+    // allow standalone is array call.
+    let prevContext = context.prevContext;
+    if (!prevContext)
+        return true;
+    let pc = prevContext;
+    return v.every(function (v1) {
+        return pc.fn && pc.fn(pc, v1);
+    });
+}
+function isArrayMessage(context, v) {
+    let arrayDescr = context.mustNotBeEmpty ? "a nonEmpty array" : "an array";
+    let prevContext = context.prevContext;
+    let element = prevContext ? " where each element " + getMessage(prevContext, v) : "";
+    return " must be " + arrayDescr + element;
+}
+function getMessage(context, v) {
+    let msg = context.msg;
+    if (typeof (msg) === "function") {
+        msg = msg(context, v);
+    }
+    return msg;
+}
+function addContext(that, context) {
+    if (that._context) {
+        let curContext = that._context;
+        while (curContext.prevContext != null) {
+            curContext = curContext.prevContext;
+        }
+        if (curContext.prevContext === null) {
+            curContext.prevContext = context;
+            // just update the prevContext but don't change the curContext.
+            return that;
+        }
+        else if (context.prevContext == null) {
+            context.prevContext = that._context;
+        }
+        else {
+            throw new Error("Illegal construction - use 'or' to combine checks");
+        }
+    }
+    return setContext(that, context);
+}
+function setContext(that, context) {
+    that._contexts[that._contexts.length - 1] = context;
+    that._context = context;
+    return that;
+}
+function exec(self) {
+    // clear off last one if null
+    let contexts = self._contexts;
+    if (contexts[contexts.length - 1] == null) {
+        contexts.pop();
+    }
+    if (contexts.length === 0) {
+        return undefined;
+    }
+    return contexts.some(function (context) {
+        return context.fn ? context.fn(context, self.v) : false;
+    });
+}
+function throwConfigError(instance, message) {
+    throw new Error(core.formatString("Error configuring an instance of '%1'. %2", (instance && instance._$typeName) || "object", message));
+}
+class ConfigParam {
+    constructor(config) {
+        if (typeof (config) !== "object") {
+            throw new Error("Configuration parameter should be an object, instead it is a: " + typeof (config));
+        }
+        this.config = config;
+        this.params = [];
+    }
+    whereParam(propName) {
+        let param = new Param(this.config[propName], propName);
+        param.parent = this;
+        this.params.push(param);
+        return param;
+    }
+}
+/** @hidden @internal */
+export let assertConfig = function (config) {
+    return new ConfigParam(config);
+};
+// Param is exposed so that additional 'is' methods can be added to the prototype.
+core.Param = Param;
+core.assertParam = assertParam;
+core.assertConfig = assertConfig;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"assert-param.js","sourceRoot":"ng://breeze-client/","sources":["src/assert-param.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAG,MAAM,QAAQ,CAAC;AAsB/B,wBAAwB;AACxB,MAAM,OAAO,KAAK;IAmBd,YAAY,CAAM,EAAE,IAAY;QA0KhC,wBAAwB;QACxB,cAAS,GAAG,UAAuB,QAAa;YAC5C,IAAI,IAAI,CAAC,CAAC,KAAK,SAAS,EAAE;gBACtB,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC;aAChC;iBAAM;gBACH,IAAI,IAAI,CAAC,YAAY,KAAK,SAAS,EAAE;oBACjC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,YAAY,CAAC;iBAC3C;aACJ;QACL,CAAC,CAAC;QAEF,mBAAc,GAAG,qBAAqB,CAAC;QApLnC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC;QACX,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACjB,IAAI,CAAC,SAAS,GAAG,CAAM,IAAI,CAAC,CAAC;IACjC,CAAC;IAED,QAAQ;QACJ,OAAO,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;IACnC,CAAC;IAED,SAAS;QACL,OAAO,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC;IACpC,CAAC;IAED,QAAQ;QACJ,OAAO,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;IACnC,CAAC;IAED,QAAQ;QACJ,OAAO,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;IACnC,CAAC;IAED,UAAU;QACN,OAAO,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC;IACrC,CAAC;IAED,gBAAgB;QACZ,OAAO,UAAU,CAAC,IAAI,EAAE;YACpB,EAAE,EAAE,gBAAgB;YACpB,GAAG,EAAE,2BAA2B;SACnC,CAAC,CAAC;IACP,CAAC;IAGD,QAAQ,CAAC,QAAgB;QACrB,OAAO,UAAU,CAAC,IAAI,EAAE;YACpB,EAAE,EAAE,QAAQ;YACZ,QAAQ,EAAE,QAAQ;YAClB,GAAG,EAAE,aAAa,GAAG,QAAQ,GAAG,GAAG;SACtC,CAAC,CAAC;IACP,CAAC;IAGD,YAAY,CAAC,IAAc,EAAE,QAAiB;QAC1C,QAAQ,GAAG,QAAQ,IAAI,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC;QACjD,OAAO,UAAU,CAAC,IAAI,EAAE;YACpB,EAAE,EAAE,YAAY;YAChB,IAAI,EAAE,IAAI;YACV,QAAQ,EAAE,QAAQ;YAClB,GAAG,EAAE,0BAA0B,GAAG,QAAQ,GAAG,GAAG;SACnD,CAAC,CAAC;IACP,CAAC;IAGD,WAAW,CAAC,YAAoB;QAC5B,OAAO,UAAU,CAAC,IAAI,EAAE;YACpB,EAAE,EAAE,WAAW;YACf,YAAY,EAAE,YAAY;YAC1B,GAAG,EAAE,eAAe,GAAG,YAAY,GAAG,YAAY;SACrD,CAAC,CAAC;IACP,CAAC;IAGD,QAAQ,CAAC,QAAa;QAClB,OAAO,UAAU,CAAC,IAAI,EAAE;YACpB,EAAE,EAAE,QAAQ;YACZ,QAAQ,EAAE,QAAQ;YAClB,GAAG,EAAE,8BAA8B,GAAG,CAAC,QAAQ,CAAC,IAAI,IAAI,SAAS,CAAC,GAAG,eAAe;SACvF,CAAC,CAAC;IACP,CAAC;IAED,UAAU,CAAC,YAAqB,KAAK;QACjC,OAAO,UAAU,CAAC,IAAI,EAAE;YACpB,EAAE,EAAE,UAAU;YACd,SAAS,EAAE,SAAS;YACpB,GAAG,EAAE,aAAa;SACrB,CAAC,CAAC;IACP,CAAC;IAED,UAAU;QACN,IAAI,OAAO,GAAG;YACV,EAAE,EAAE,UAAU;YACd,WAAW,EAAO,IAAI;YACtB,GAAG,EAAE,iBAAiB;SACzB,CAAC;QACF,OAAO,UAAU,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;IACrC,CAAC;IAED,eAAe;QACX,OAAO,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;IAC9B,CAAC;IAED,OAAO,CAAC,cAAwB;QAC5B,IAAI,OAAO,GAAG;YACV,EAAE,EAAE,OAAO;YACX,cAAc,EAAE,cAAc;YAC9B,WAAW,EAAO,IAAI;YACtB,GAAG,EAAE,cAAc;SACtB,CAAC;QACF,OAAO,UAAU,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;IACrC,CAAC;IAED,EAAE;QACE,IAAI,CAAC,SAAS,CAAC,IAAI,CAAM,IAAI,CAAC,CAAC;QAC/B,IAAI,CAAC,QAAQ,GAAQ,IAAI,CAAC;QAC1B,OAAO,IAAI,CAAC;IAChB,CAAC;IAED,KAAK,CAAC,YAAkB;QACpB,IAAI,EAAE,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC;QACpB,IAAI,EAAE,KAAK,SAAS;YAAE,OAAO;QAC7B,IAAI,CAAC,EAAE,EAAE;YACL,MAAM,IAAI,KAAK,CAAC,IAAI,CAAC,UAAU,EAAE,CAAC,CAAC;SACtC;QAED,IAAI,IAAI,CAAC,CAAC,KAAK,SAAS,EAAE;YACtB,OAAO,IAAI,CAAC,CAAC,CAAC;SACjB;aAAM;YACH,OAAO,YAAY,CAAC;SACvB;IACL,CAAC;IAED,wBAAwB;IACxB,iCAAiC;IACjC,WAAW,CAAC,OAAsB;QAC9B,OAAO,UAAU,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;IACrC,CAAC;IAED,UAAU;QACN,IAAI,IAAI,GAAG,IAAI,CAAC;QAChB,IAAI,OAAO,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,UAAU,OAAO;YAC9C,OAAO,UAAU,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC;QACvC,CAAC,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;QACpB,OAAO,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,cAAc,EAAE,IAAI,CAAC,IAAI,CAAC,GAAG,GAAG,GAAG,OAAO,CAAC;IAC7E,CAAC;IAED,WAAW,CAAC,YAAiB;QACzB,IAAI,CAAC,YAAY,GAAG,YAAY,CAAC;QACjC,OAAO,IAAI,CAAC;IAChB,CAAC;IAED,UAAU,CAAC,QAAgB;QACvB,OAAO,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC;IAC5C,CAAC;IAED,QAAQ,CAAC,QAAa,EAAE,YAAqB,KAAK;QAC9C,IAAI,cAAc,GAAG,QAAQ,CAAC,UAAU,CAAC;QACzC,IAAI,oBAAoB,GAAG,CAAC,cAAc,IAAI,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,UAAU,KAAK,cAAc,CAAC,CAAC;QAEhG,IAAI,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,EAAE,EAAE,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;QAChD,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,UAAU,CAAC;YAClC,IAAI,CAAC,oBAAoB;gBAAE,OAAO,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;YAChD,IAAI;gBACA,CAAC,CAAC,KAAK,EAAE,CAAC;aACb;YAAC,OAAO,CAAC,EAAE;gBACR,gBAAgB,CAAC,QAAQ,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC;aACzC;YACD,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC;QAC1C,CAAC,CAAC,CAAC;QACH,4CAA4C;QAC5C,IAAI,CAAC,oBAAoB,EAAE;YACvB,KAAK,IAAI,GAAG,IAAI,KAAK,EAAE;gBACnB,sCAAsC;gBACtC,IAAI,KAAK,CAAC,GAAG,CAAC,KAAK,SAAS,EAAE;oBAC1B,gBAAgB,CAAC,QAAQ,EAAE,IAAI,CAAC,YAAY,CAAC,yBAAyB,EAAE,GAAG,CAAC,CAAC,CAAC;iBACjF;aACJ;SACJ;IACL,CAAC;CAeJ;AAED,wBAAwB;AACxB,MAAM,CAAC,IAAI,WAAW,GAAG,UAAU,CAAM,EAAE,IAAY;IACnD,OAAO,IAAI,KAAK,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC;AAC9B,CAAC,CAAC;AAEF,SAAS,QAAQ,CAAC,OAAsB,EAAE,CAAM;IAC5C,IAAI,CAAC,IAAI,IAAI;QAAE,OAAO,KAAK,CAAC;IAC5B,IAAI,OAAO,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC,QAAQ;QAAE,OAAO,IAAI,CAAC;IACjD,OAAO,KAAK,CAAC;AACjB,CAAC;AAED,SAAS,gBAAgB,CAAC,OAAsB,EAAE,CAAM;IACpD,IAAI,CAAC,IAAI,IAAI;QAAE,OAAO,KAAK,CAAC;IAC5B,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,KAAK,QAAQ,CAAC,IAAI,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC;AACrD,CAAC;AAED,SAAS,YAAY,CAAC,OAAsB,EAAE,CAAM;IAChD,IAAI,CAAC,IAAI,IAAI,IAAI,OAAO,CAAC,IAAI,IAAI,IAAI;QAAE,OAAO,KAAK,CAAC;IACpD,OAAO,CAAC,CAAC,YAAY,OAAO,CAAC,IAAI,CAAC,CAAC;AACvC,CAAC;AAED,SAAS,QAAQ,CAAC,OAAsB,EAAE,CAAM;IAC5C,IAAI,CAAC,IAAI,IAAI,IAAI,OAAO,CAAC,QAAQ,IAAI,IAAI;QAAG,OAAO,KAAK,CAAC;IACzD,OAAQ,OAAO,CAAC,QAAgB,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;AACjD,CAAC;AAED,SAAS,WAAW,CAAC,OAAsB,EAAE,CAAM;IAC/C,IAAI,CAAC,IAAI,IAAI,IAAI,OAAO,CAAC,YAAY,IAAI,IAAI;QAAE,OAAO,KAAK,CAAC;IAC5D,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC,YAAY,CAAC,KAAK,SAAS,CAAC,CAAC;AACnD,CAAC;AAED,SAAS,UAAU,CAAC,OAAsB,EAAE,CAAM;IAC9C,IAAI,OAAO,CAAC,SAAS,EAAE;QACnB,OAAO,CAAC,KAAK,SAAS,CAAC;KAC1B;SAAM;QACH,OAAO,CAAC,IAAI,IAAI,CAAC;KACpB;AACL,CAAC;AAED,SAAS,UAAU,CAAC,OAAsB,EAAE,CAAM;IAC9C,IAAI,CAAC,IAAI,IAAI;QAAE,OAAO,IAAI,CAAC;IAC3B,IAAI,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC;IACtC,IAAI,WAAW,IAAI,WAAW,CAAC,EAAE,EAAE;QAC/B,OAAO,WAAW,CAAC,EAAE,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC;KACzC;SAAM;QACH,OAAO,IAAI,CAAC;KACf;AACL,CAAC;AAED,SAAS,iBAAiB,CAAC,OAAsB,EAAE,CAAM;IACrD,IAAI,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC;IACtC,IAAI,OAAO,GAAG,WAAW,CAAC,CAAC,CAAC,SAAS,GAAG,UAAU,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;IACxE,OAAO,aAAa,GAAG,OAAO,CAAC;AACnC,CAAC;AAED,SAAS,OAAO,CAAC,OAAsB,EAAE,CAAM;IAC3C,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE;QACnB,OAAO,KAAK,CAAC;KAChB;IACD,IAAI,OAAO,CAAC,cAAc,EAAE;QACxB,IAAI,CAAC,CAAC,MAAM,KAAK,CAAC;YAAE,OAAO,KAAK,CAAC;KACpC;IACD,kCAAkC;IAClC,IAAI,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC;IACtC,IAAI,CAAC,WAAW;QAAE,OAAO,IAAI,CAAC;IAE9B,IAAI,EAAE,GAAQ,WAAW,CAAC;IAC1B,OAAO,CAAC,CAAC,KAAK,CAAC,UAAU,EAAO;QAC5B,OAAO,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;IAClC,CAAC,CAAC,CAAC;AACP,CAAC;AAED,SAAS,cAAc,CAAC,OAAsB,EAAE,CAAM;IAClD,IAAI,UAAU,GAAG,OAAO,CAAC,cAAc,CAAC,CAAC,CAAC,kBAAkB,CAAC,CAAC,CAAC,UAAU,CAAC;IAC1E,IAAI,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC;IACtC,IAAI,OAAO,GAAG,WAAW,CAAC,CAAC,CAAC,sBAAsB,GAAG,UAAU,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;IACrF,OAAO,WAAW,GAAG,UAAU,GAAG,OAAO,CAAC;AAC9C,CAAC;AAED,SAAS,UAAU,CAAC,OAAsB,EAAE,CAAM;IAC9C,IAAI,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC;IACtB,IAAI,OAAO,CAAC,GAAG,CAAC,KAAK,UAAU,EAAE;QAC7B,GAAG,GAAS,GAAI,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC;KAChC;IACD,OAAO,GAAG,CAAC;AACf,CAAC;AAED,SAAS,UAAU,CAAC,IAAW,EAAE,OAAsB;IACnD,IAAI,IAAI,CAAC,QAAQ,EAAE;QACf,IAAI,UAAU,GAAG,IAAI,CAAC,QAAQ,CAAC;QAE/B,OAAO,UAAU,CAAC,WAAW,IAAI,IAAI,EAAE;YACnC,UAAU,GAAG,UAAU,CAAC,WAAW,CAAC;SACvC;QAED,IAAI,UAAU,CAAC,WAAW,KAAK,IAAI,EAAE;YACjC,UAAU,CAAC,WAAW,GAAG,OAAO,CAAC;YACjC,+DAA+D;YAC/D,OAAO,IAAI,CAAC;SACf;aAAM,IAAI,OAAO,CAAC,WAAW,IAAI,IAAI,EAAE;YACpC,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC,QAAQ,CAAC;SACvC;aAAM;YACH,MAAM,IAAI,KAAK,CAAC,mDAAmD,CAAC,CAAC;SACxE;KACJ;IACD,OAAO,UAAU,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;AACrC,CAAC;AAED,SAAS,UAAU,CAAC,IAAW,EAAE,OAAsB;IACnD,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,GAAG,CAAC,CAAC,GAAG,OAAO,CAAC;IACpD,IAAI,CAAC,QAAQ,GAAG,OAAO,CAAC;IACxB,OAAO,IAAI,CAAC;AAChB,CAAC;AAGD,SAAS,IAAI,CAAC,IAAW;IACrB,6BAA6B;IAC7B,IAAI,QAAQ,GAAG,IAAI,CAAC,SAAS,CAAC;IAC9B,IAAI,QAAQ,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,CAAC,IAAI,IAAI,EAAE;QACvC,QAAQ,CAAC,GAAG,EAAE,CAAC;KAClB;IACD,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC,EAAE;QACvB,OAAO,SAAS,CAAC;KACpB;IACD,OAAO,QAAQ,CAAC,IAAI,CAAC,UAAU,OAAsB;QACjD,OAAO,OAAO,CAAC,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;IAC5D,CAAC,CAAC,CAAC;AACP,CAAC;AAED,SAAS,gBAAgB,CAAC,QAAa,EAAE,OAAe;IACpD,MAAM,IAAI,KAAK,CAAC,IAAI,CAAC,YAAY,CAAC,2CAA2C,EAAE,CAAC,QAAQ,IAAI,QAAQ,CAAC,UAAU,CAAC,IAAI,QAAQ,EAAE,OAAO,CAAC,CAAC,CAAC;AAC5I,CAAC;AAED,MAAM,WAAW;IAGb,YAAY,MAAc;QACtB,IAAI,OAAO,CAAC,MAAM,CAAC,KAAK,QAAQ,EAAE;YAC9B,MAAM,IAAI,KAAK,CAAC,gEAAgE,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC;SACvG;QACD,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,IAAI,CAAC,MAAM,GAAG,EAAE,CAAC;IACrB,CAAC;IAED,UAAU,CAAC,QAAgB;QACvB,IAAI,KAAK,GAAG,IAAI,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,QAAQ,CAAC,CAAC;QACvD,KAAK,CAAC,MAAM,GAAG,IAAI,CAAC;QACpB,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACxB,OAAO,KAAK,CAAC;IACjB,CAAC;CACJ;AAED,wBAAwB;AACxB,MAAM,CAAC,IAAI,YAAY,GAAG,UAAU,MAAc;IAC9C,OAAO,IAAI,WAAW,CAAC,MAAM,CAAiB,CAAC;AACnD,CAAC,CAAC;AAGF,kFAAkF;AACjF,IAAY,CAAC,KAAK,GAAG,KAAK,CAAC;AAC3B,IAAY,CAAC,WAAW,GAAG,WAAW,CAAC;AACvC,IAAY,CAAC,YAAY,GAAG,YAAY,CAAC","sourcesContent":["import { BreezeEnum } from './enum';\r\nimport { core  } from './core';\r\n\r\n/** @hidden @internal */\r\nexport interface IParamContext {\r\n    typeName?: string;\r\n    type?: Function;\r\n    prevContext?: IParamContext;\r\n    msg?: string | ((context: IParamContext, v: any) => string);\r\n    mustNotBeEmpty?: boolean;\r\n    enumType?: BreezeEnum;\r\n    propertyName?: string;\r\n    allowNull?: boolean;\r\n    fn?(context: IParamContext, v: any): boolean;\r\n}\r\n\r\n/** @hidden @internal */\r\nexport interface IConfigParam {\r\n    config: any;\r\n    params: Param[];\r\n    whereParam: (propName: string) => Param;\r\n}\r\n\r\n/** @hidden @internal */\r\nexport class Param {\r\n    // The %1 parameter\r\n    // is required\r\n    // must be a %2\r\n    // must be an instance of %2\r\n    // must be an instance of the %2 enumeration\r\n    // must have a %2 property\r\n    // must be an array where each element\r\n    // is optional or\r\n\r\n    v: any;\r\n    name: string;\r\n    defaultValue: any;\r\n    parent: IConfigParam;\r\n    /** @hidden @internal */\r\n    _context: IParamContext;\r\n    /** @hidden @internal */\r\n    _contexts: IParamContext[];\r\n\r\n    constructor(v: any, name: string) {\r\n        this.v = v;\r\n        this.name = name;\r\n        this._contexts = [<any>null];\r\n    }\r\n\r\n    isObject(): Param {\r\n        return this.isTypeOf('object');\r\n    }\r\n\r\n    isBoolean(): Param {\r\n        return this.isTypeOf('boolean');\r\n    }\r\n\r\n    isString(): Param {\r\n        return this.isTypeOf('string');\r\n    }\r\n\r\n    isNumber(): Param {\r\n        return this.isTypeOf('number');\r\n    }\r\n\r\n    isFunction(): Param {\r\n        return this.isTypeOf('function');\r\n    }\r\n\r\n    isNonEmptyString(): Param {\r\n        return addContext(this, {\r\n            fn: isNonEmptyString,\r\n            msg: \"must be a nonEmpty string\"\r\n        });\r\n    }\r\n\r\n\r\n    isTypeOf(typeName: string): Param {\r\n        return addContext(this, {\r\n            fn: isTypeOf,\r\n            typeName: typeName,\r\n            msg: \"must be a '\" + typeName + \"'\"\r\n        });\r\n    }\r\n\r\n\r\n    isInstanceOf(type: Function, typeName?: string): Param {\r\n        typeName = typeName || type.prototype._$typeName;\r\n        return addContext(this, {\r\n            fn: isInstanceOf,\r\n            type: type,\r\n            typeName: typeName,\r\n            msg: \"must be an instance of '\" + typeName + \"'\"\r\n        });\r\n    }\r\n\r\n\r\n    hasProperty(propertyName: string): Param {\r\n        return addContext(this, {\r\n            fn: hasProperty,\r\n            propertyName: propertyName,\r\n            msg: \"must have a '\" + propertyName + \"' property\"\r\n        });\r\n    }\r\n\r\n\r\n    isEnumOf(enumType: any): Param {\r\n        return addContext(this, {\r\n            fn: isEnumOf,\r\n            enumType: enumType,\r\n            msg: \"must be an instance of the '\" + (enumType.name || 'unknown') + \"' enumeration\"\r\n        });\r\n    }\r\n\r\n    isRequired(allowNull: boolean = false): Param {\r\n        return addContext(this, {\r\n            fn: isRequired,\r\n            allowNull: allowNull,\r\n            msg: \"is required\"\r\n        });\r\n    }\r\n\r\n    isOptional(): Param {\r\n        let context = {\r\n            fn: isOptional,\r\n            prevContext: <any>null,\r\n            msg: isOptionalMessage\r\n        };\r\n        return addContext(this, context);\r\n    }\r\n\r\n    isNonEmptyArray(): Param {\r\n        return this.isArray(true);\r\n    }\r\n\r\n    isArray(mustNotBeEmpty?: boolean): Param {\r\n        let context = {\r\n            fn: isArray,\r\n            mustNotBeEmpty: mustNotBeEmpty,\r\n            prevContext: <any>null,\r\n            msg: isArrayMessage\r\n        };\r\n        return addContext(this, context);\r\n    }\r\n\r\n    or() {\r\n        this._contexts.push(<any>null);\r\n        this._context = <any>null;\r\n        return this;\r\n    }\r\n\r\n    check(defaultValue?: any) {\r\n        let ok = exec(this);\r\n        if (ok === undefined) return;\r\n        if (!ok) {\r\n            throw new Error(this.getMessage());\r\n        }\r\n\r\n        if (this.v !== undefined) {\r\n            return this.v;\r\n        } else {\r\n            return defaultValue;\r\n        }\r\n    }\r\n\r\n    /** @hidden @internal */\r\n    // called from outside this file.\r\n    _addContext(context: IParamContext) {\r\n        return addContext(this, context);\r\n    }\r\n\r\n    getMessage() {\r\n        let that = this;\r\n        let message = this._contexts.map(function (context) {\r\n            return getMessage(context, that.v);\r\n        }).join(\", or it \");\r\n        return core.formatString(this.MESSAGE_PREFIX, this.name) + \" \" + message;\r\n    }\r\n\r\n    withDefault(defaultValue: any) {\r\n        this.defaultValue = defaultValue;\r\n        return this;\r\n    }\r\n\r\n    whereParam(propName: string) {\r\n        return this.parent.whereParam(propName);\r\n    }\r\n\r\n    applyAll(instance: any, checkOnly: boolean = false) {\r\n        let parentTypeName = instance._$typeName;\r\n        let allowUnknownProperty = (parentTypeName && this.parent.config._$typeName === parentTypeName);\r\n\r\n        let clone = core.extend({}, this.parent.config);\r\n        this.parent.params.forEach(function (p) {\r\n            if (!allowUnknownProperty) delete clone[p.name];\r\n            try {\r\n                p.check();\r\n            } catch (e) {\r\n                throwConfigError(instance, e.message);\r\n            }\r\n            (!checkOnly) && p._applyOne(instance);\r\n        });\r\n        // should be no properties left in the clone\r\n        if (!allowUnknownProperty) {\r\n            for (let key in clone) {\r\n                // allow props with an undefined value\r\n                if (clone[key] !== undefined) {\r\n                    throwConfigError(instance, core.formatString(\"Unknown property: '%1'.\", key));\r\n                }\r\n            }\r\n        }\r\n    }\r\n\r\n    /** @hidden @internal */\r\n    _applyOne = function (this: Param, instance: any) {\r\n        if (this.v !== undefined) {\r\n            instance[this.name] = this.v;\r\n        } else {\r\n            if (this.defaultValue !== undefined) {\r\n                instance[this.name] = this.defaultValue;\r\n            }\r\n        }\r\n    };\r\n\r\n    MESSAGE_PREFIX = \"The '%1' parameter \";\r\n\r\n}\r\n\r\n/** @hidden @internal */\r\nexport let assertParam = function (v: any, name: string) {\r\n    return new Param(v, name);\r\n};\r\n\r\nfunction isTypeOf(context: IParamContext, v: any) {\r\n    if (v == null) return false;\r\n    if (typeof (v) === context.typeName) return true;\r\n    return false;\r\n}\r\n\r\nfunction isNonEmptyString(context: IParamContext, v: any) {\r\n    if (v == null) return false;\r\n    return (typeof (v) === 'string') && v.length > 0;\r\n}\r\n\r\nfunction isInstanceOf(context: IParamContext, v: any) {\r\n    if (v == null || context.type == null) return false;\r\n    return (v instanceof context.type);\r\n}\r\n\r\nfunction isEnumOf(context: IParamContext, v: any) {\r\n    if (v == null || context.enumType == null ) return false;\r\n    return (context.enumType as any).contains(v);\r\n}\r\n\r\nfunction hasProperty(context: IParamContext, v: any) {\r\n    if (v == null || context.propertyName == null) return false;\r\n    return (v[context.propertyName] !== undefined);\r\n}\r\n\r\nfunction isRequired(context: IParamContext, v: any) {\r\n    if (context.allowNull) {\r\n        return v !== undefined;\r\n    } else {\r\n        return v != null;\r\n    }\r\n}\r\n\r\nfunction isOptional(context: IParamContext, v: any) {\r\n    if (v == null) return true;\r\n    let prevContext = context.prevContext;\r\n    if (prevContext && prevContext.fn) {\r\n        return prevContext.fn(prevContext, v);\r\n    } else {\r\n        return true;\r\n    }\r\n}\r\n\r\nfunction isOptionalMessage(context: IParamContext, v: any) {\r\n    let prevContext = context.prevContext;\r\n    let element = prevContext ? \" or it \" + getMessage(prevContext, v) : \"\";\r\n    return \"is optional\" + element;\r\n}\r\n\r\nfunction isArray(context: IParamContext, v: any) {\r\n    if (!Array.isArray(v)) {\r\n        return false;\r\n    }\r\n    if (context.mustNotBeEmpty) {\r\n        if (v.length === 0) return false;\r\n    }\r\n    // allow standalone is array call.\r\n    let prevContext = context.prevContext;\r\n    if (!prevContext) return true;\r\n\r\n    let pc = <any>prevContext;\r\n    return v.every(function (v1: any) {\r\n        return pc.fn && pc.fn(pc, v1);\r\n    });\r\n}\r\n\r\nfunction isArrayMessage(context: IParamContext, v: any) {\r\n    let arrayDescr = context.mustNotBeEmpty ? \"a nonEmpty array\" : \"an array\";\r\n    let prevContext = context.prevContext;\r\n    let element = prevContext ? \" where each element \" + getMessage(prevContext, v) : \"\";\r\n    return \" must be \" + arrayDescr + element;\r\n}\r\n\r\nfunction getMessage(context: IParamContext, v: any) {\r\n    let msg = context.msg;\r\n    if (typeof (msg) === \"function\") {\r\n        msg = (<any>msg)(context, v);\r\n    }\r\n    return msg;\r\n}\r\n\r\nfunction addContext(that: Param, context: IParamContext) {\r\n    if (that._context) {\r\n        let curContext = that._context;\r\n\r\n        while (curContext.prevContext != null) {\r\n            curContext = curContext.prevContext;\r\n        }\r\n\r\n        if (curContext.prevContext === null) {\r\n            curContext.prevContext = context;\r\n            // just update the prevContext but don't change the curContext.\r\n            return that;\r\n        } else if (context.prevContext == null) {\r\n            context.prevContext = that._context;\r\n        } else {\r\n            throw new Error(\"Illegal construction - use 'or' to combine checks\");\r\n        }\r\n    }\r\n    return setContext(that, context);\r\n}\r\n\r\nfunction setContext(that: Param, context: IParamContext) {\r\n    that._contexts[that._contexts.length - 1] = context;\r\n    that._context = context;\r\n    return that;\r\n}\r\n\r\n\r\nfunction exec(self: Param) {\r\n    // clear off last one if null\r\n    let contexts = self._contexts;\r\n    if (contexts[contexts.length - 1] == null) {\r\n        contexts.pop();\r\n    }\r\n    if (contexts.length === 0) {\r\n        return undefined;\r\n    }\r\n    return contexts.some(function (context: IParamContext) {\r\n        return context.fn ? context.fn(context, self.v) : false;\r\n    });\r\n}\r\n\r\nfunction throwConfigError(instance: any, message: string) {\r\n    throw new Error(core.formatString(\"Error configuring an instance of '%1'. %2\", (instance && instance._$typeName) || \"object\", message));\r\n}\r\n\r\nclass ConfigParam {\r\n    config: any;\r\n    params: Param[];\r\n    constructor(config: Object) {\r\n        if (typeof (config) !== \"object\") {\r\n            throw new Error(\"Configuration parameter should be an object, instead it is a: \" + typeof (config));\r\n        }\r\n        this.config = config;\r\n        this.params = [];\r\n    }\r\n\r\n    whereParam(propName: string) {\r\n        let param = new Param(this.config[propName], propName);\r\n        param.parent = this;\r\n        this.params.push(param);\r\n        return param;\r\n    }\r\n}\r\n\r\n/** @hidden @internal */\r\nexport let assertConfig = function (config: Object) {\r\n    return new ConfigParam(config) as IConfigParam;\r\n};\r\n\r\n\r\n// Param is exposed so that additional 'is' methods can be added to the prototype.\r\n(core as any).Param = Param;\r\n(core as any).assertParam = assertParam;\r\n(core as any).assertConfig = assertConfig;\r\n"]}

package/esm2015/src/breeze.js

@@ -0,0 +1,85 @@
+import { AbstractDataServiceAdapter } from './abstract-data-service-adapter';
+import { assertParam, assertConfig, Param } from './assert-param';
+import { BreezeConfig } from './config';
+import { BreezeEnum } from './enum';
+import { BreezeEvent } from './event';
+import { DataService, JsonResultsAdapter } from './data-service';
+import { DataType } from './data-type';
+import { EntityAction } from './entity-action';
+import { EntityAspect, ComplexAspect } from './entity-aspect';
+import { EntityKey } from './entity-key';
+import { EntityManager } from './entity-manager';
+import { EntityQuery, FilterQueryOp, BooleanQueryOp, OrderByClause, ExpandClause, SelectClause } from './entity-query';
+import { EntityState } from './entity-state';
+import { InterfaceRegistry } from './interface-registry';
+import { KeyGenerator } from './key-generator';
+import { LocalQueryComparisonOptions } from './local-query-comparison-options';
+import { MappingContext } from './mapping-context';
+import { MetadataStore, EntityType, ComplexType, DataProperty, NavigationProperty, AutoGeneratedKeyType } from './entity-metadata';
+import { NamingConvention } from './naming-convention';
+import { Predicate, UnaryPredicate, BinaryPredicate, AnyAllPredicate, AndOrPredicate, LitExpr, FnExpr, PropExpr } from './predicate';
+import { QueryOptions, FetchStrategy, MergeStrategy } from './query-options';
+import { SaveOptions } from './save-options';
+import { ValidationError, Validator } from './validate';
+import { ValidationOptions } from './validation-options';
+import { config } from './config';
+import { core } from './core';
+import { makeRelationArray, makePrimitiveArray, makeComplexArray } from './array';
+export { BreezeConfig };
+export { AbstractDataServiceAdapter, AndOrPredicate, AnyAllPredicate, assertConfig, assertParam, AutoGeneratedKeyType, BinaryPredicate, BreezeEnum, BreezeEvent, ComplexAspect, ComplexType, config, core, DataProperty, DataService, DataType, EntityAction, EntityAspect, EntityKey, EntityManager, EntityQuery, EntityState, EntityType, ExpandClause, FetchStrategy, FilterQueryOp, FnExpr, InterfaceRegistry, JsonResultsAdapter, KeyGenerator, LitExpr, LocalQueryComparisonOptions, makeComplexArray, makePrimitiveArray, makeRelationArray, MappingContext, MergeStrategy, MetadataStore, NamingConvention, NavigationProperty, OrderByClause, Predicate, PropExpr, QueryOptions, SaveOptions, SelectClause, UnaryPredicate, ValidationError, ValidationOptions, Validator, };
+// create a breeze variable here
+export const breeze = {
+    AbstractDataServiceAdapter: AbstractDataServiceAdapter,
+    assertConfig: null,
+    assertParam: null,
+    AutoGeneratedKeyType: AutoGeneratedKeyType,
+    BooleanQueryOp: BooleanQueryOp,
+    ComplexAspect: ComplexAspect,
+    ComplexType: ComplexType,
+    config: config,
+    core: core,
+    DataProperty: DataProperty,
+    DataService: DataService,
+    DataType: DataType,
+    EntityAction: EntityAction,
+    EntityAspect: EntityAspect,
+    EntityKey: EntityKey,
+    EntityManager: EntityManager,
+    EntityQuery: EntityQuery,
+    EntityState: EntityState,
+    EntityType: EntityType,
+    Event: BreezeEvent,
+    FetchStrategy: FetchStrategy,
+    FilterQueryOp: FilterQueryOp,
+    InterfaceRegistry: InterfaceRegistry,
+    JsonResultsAdapter: JsonResultsAdapter,
+    KeyGenerator: KeyGenerator,
+    LocalQueryComparisonOptions: LocalQueryComparisonOptions,
+    makeComplexArray: makeComplexArray,
+    makePrimitiveArray: makePrimitiveArray,
+    makeRelationArray: makeRelationArray,
+    MergeStrategy: MergeStrategy,
+    MetadataStore: MetadataStore,
+    NamingConvention: NamingConvention,
+    NavigationProperty: NavigationProperty,
+    OrderByClause: OrderByClause,
+    Param,
+    Predicate: Predicate,
+    QueryOptions: QueryOptions,
+    SaveOptions: SaveOptions,
+    ValidationError: ValidationError,
+    ValidationOptions: ValidationOptions,
+    Validator: Validator,
+    version: "2.1.5"
+};
+/** @hidden @internal */
+let win;
+try {
+    win = window ? window : (global ? global.window : undefined);
+}
+catch (e) {
+}
+if (win) {
+    win.breeze = breeze;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"breeze.js","sourceRoot":"ng://breeze-client/","sources":["src/breeze.ts"],"names":[],"mappings":"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","sourcesContent":["\r\nimport { AbstractDataServiceAdapter} from './abstract-data-service-adapter';\r\nimport { assertParam, assertConfig, Param } from './assert-param';\r\nimport { BreezeConfig } from './config';\r\nimport { BreezeEnum} from './enum';\r\nimport { BreezeEvent } from './event';\r\nimport { ComplexArray } from './complex-array';\r\nimport { DataService, DataServiceConfig, JsonResultsAdapter, JsonResultsAdapterConfig, NodeContext, NodeMeta } from './data-service';\r\nimport { DataType  } from './data-type';\r\nimport { EntityAction } from './entity-action';\r\nimport { EntityAspect, ComplexAspect, Entity, ComplexObject, StructuralObject, PropertyChangedEventArgs } from './entity-aspect';\r\nimport { EntityKey } from './entity-key';\r\nimport { EntityManager, EntityManagerConfig, EntityError, EntityChangedEventArgs, SaveContext, SaveBundle, HttpResponse, KeyMapping, ServerError, SaveResult, QueryResult, ValidationErrorsChangedEventArgs, HasChangesChangedEventArgs } from './entity-manager';\r\nimport { EntityQuery, FilterQueryOp, BooleanQueryOp, OrderByClause, ExpandClause, SelectClause } from './entity-query';\r\nimport { EntityState } from './entity-state';\r\nimport { InterfaceRegistry, AjaxAdapter, AjaxConfig, DataServiceAdapter, ModelLibraryAdapter, ChangeRequestInterceptor, UriBuilderAdapter, InterfaceRegistryConfig, AjaxRequestInterceptor } from './interface-registry';\r\nimport { KeyGenerator } from './key-generator';\r\nimport { LocalQueryComparisonOptions } from './local-query-comparison-options';\r\nimport { MappingContext } from './mapping-context';\r\nimport { MetadataStore, EntityType, ComplexType, StructuralType, DataProperty, EntityProperty, NavigationProperty, AutoGeneratedKeyType   } from './entity-metadata';\r\nimport { NamingConvention } from './naming-convention';\r\nimport { Predicate, VisitContext, Visitor, ExpressionContext, UnaryPredicate, BinaryPredicate, AnyAllPredicate, AndOrPredicate, LitExpr, FnExpr, PropExpr } from './predicate';\r\nimport { QueryOptions,  FetchStrategy, MergeStrategy } from './query-options';\r\nimport { SaveOptions } from './save-options';\r\nimport { ValidationError, Validator } from './validate';\r\nimport { ValidationOptions } from './validation-options';\r\n\r\nimport { config, BaseAdapter } from './config';\r\nimport { core, Callback, ErrorCallback } from './core';\r\nimport { makeRelationArray, makePrimitiveArray, makeComplexArray } from './array';\r\n\r\nimport { RelationArray } from './relation-array';\r\nimport { ArrayChangedArgs } from './observable-array';\r\nexport { BreezeConfig, ComplexArray, RelationArray };\r\n\r\nexport {\r\n  AbstractDataServiceAdapter,\r\n  AjaxAdapter,\r\n  AjaxConfig,\r\n  AjaxRequestInterceptor,\r\n  AndOrPredicate,\r\n  AnyAllPredicate,\r\n  ArrayChangedArgs,\r\n  assertConfig,\r\n  assertParam,\r\n  AutoGeneratedKeyType,\r\n  BaseAdapter,\r\n  BinaryPredicate,\r\n  BreezeEnum,\r\n  BreezeEvent, \r\n  Callback,\r\n  ChangeRequestInterceptor,\r\n  ComplexAspect,\r\n  ComplexObject,\r\n  ComplexType,\r\n  config,\r\n  core,\r\n  DataProperty,\r\n  DataService,\r\n  DataServiceAdapter,\r\n  DataServiceConfig,\r\n  DataType,\r\n  Entity,\r\n  EntityAction,\r\n  EntityAspect,\r\n  EntityChangedEventArgs,\r\n  EntityError,\r\n  EntityKey,\r\n  EntityManager,\r\n  EntityManagerConfig,\r\n  EntityProperty,\r\n  EntityQuery,\r\n  EntityState,\r\n  EntityType,\r\n  ErrorCallback,\r\n  ExpandClause,\r\n  ExpressionContext,\r\n  FetchStrategy,\r\n  FilterQueryOp,\r\n  FnExpr,\r\n  HasChangesChangedEventArgs,\r\n  HttpResponse,\r\n  InterfaceRegistry,\r\n  InterfaceRegistryConfig,\r\n  JsonResultsAdapter,\r\n  JsonResultsAdapterConfig,\r\n  KeyGenerator,\r\n  KeyMapping,\r\n  LitExpr,\r\n  LocalQueryComparisonOptions,\r\n  makeComplexArray,\r\n  makePrimitiveArray,\r\n  makeRelationArray,\r\n  MappingContext,\r\n  MergeStrategy,\r\n  MetadataStore,\r\n  ModelLibraryAdapter,\r\n  NamingConvention,\r\n  NavigationProperty,\r\n  NodeContext,\r\n  NodeMeta,\r\n  OrderByClause,\r\n  Predicate,\r\n  PropertyChangedEventArgs,\r\n  PropExpr,\r\n  QueryOptions,\r\n  QueryResult,\r\n  SaveBundle,\r\n  SaveContext,\r\n  SaveOptions,\r\n  SaveResult,\r\n  SelectClause,\r\n  ServerError,\r\n  StructuralObject,\r\n  StructuralType,\r\n  UnaryPredicate,\r\n  UriBuilderAdapter,\r\n  ValidationErrorsChangedEventArgs,\r\n  ValidationError,\r\n  ValidationOptions,\r\n  Validator,\r\n  VisitContext,\r\n  Visitor,\r\n};\r\n\r\n// create a breeze variable here\r\nexport const breeze = {\r\n  AbstractDataServiceAdapter: AbstractDataServiceAdapter,\r\n  assertConfig: null as any,\r\n  assertParam: null as any,\r\n  AutoGeneratedKeyType: AutoGeneratedKeyType,\r\n  BooleanQueryOp: BooleanQueryOp,\r\n  ComplexAspect: ComplexAspect,\r\n  ComplexType: ComplexType,\r\n  config: config,\r\n  core: core,\r\n  DataProperty: DataProperty,\r\n  DataService: DataService,\r\n  DataType: DataType,\r\n  EntityAction: EntityAction,\r\n  EntityAspect: EntityAspect,\r\n  EntityKey: EntityKey,\r\n  EntityManager: EntityManager,\r\n  EntityQuery: EntityQuery,\r\n  EntityState: EntityState,\r\n  EntityType: EntityType,\r\n  Event: BreezeEvent,\r\n  FetchStrategy: FetchStrategy,\r\n  FilterQueryOp: FilterQueryOp,\r\n  InterfaceRegistry: InterfaceRegistry,\r\n  JsonResultsAdapter: JsonResultsAdapter,\r\n  KeyGenerator: KeyGenerator,\r\n  LocalQueryComparisonOptions: LocalQueryComparisonOptions,\r\n  makeComplexArray: makeComplexArray,\r\n  makePrimitiveArray: makePrimitiveArray,\r\n  makeRelationArray: makeRelationArray,\r\n  MergeStrategy: MergeStrategy,\r\n  MetadataStore: MetadataStore,\r\n  NamingConvention: NamingConvention,\r\n  NavigationProperty: NavigationProperty,\r\n  OrderByClause: OrderByClause, // for testing only\r\n  Param,\r\n  Predicate: Predicate,\r\n  QueryOptions: QueryOptions,\r\n  SaveOptions: SaveOptions,\r\n  ValidationError: ValidationError,\r\n  ValidationOptions: ValidationOptions,\r\n  Validator: Validator,\r\n  version: \"2.1.5\"\r\n};\r\n\r\n// breeze.assertConfig = assertConfig as any;\r\n// breeze.assertParam = assertParam as any;\r\n\r\nexport namespace promises {\r\n  /** no-op for backward compatibility with breeze-bridge2-angular */\r\n  export interface IPromiseService {}\r\n}\r\n\r\n/** @hidden @internal */\r\ndeclare var window: any;\r\n\r\n/** @hidden @internal */\r\ndeclare var global: any;\r\n\r\n/** @hidden @internal */\r\nlet win: any;\r\ntry {\r\n  win = window ? window : (global ? global.window : undefined);\r\n} catch (e) {\r\n\r\n}\r\nif (win) {\r\n  win.breeze = breeze;\r\n}\r\n"]}

package/esm2015/src/complex-array.js

@@ -0,0 +1,119 @@
+import { core } from './core';
+import { observableArray } from './observable-array';
+import { BreezeEvent } from './event';
+const ɵ0 = function (adds) {
+    return getGoodAdds(this, adds);
+}, ɵ1 = function () {
+    observableArray.updateEntityState(this);
+}, ɵ2 = function (adds) {
+    processAdds(this, adds);
+}, ɵ3 = function (removes) {
+    processRemoves(this, removes);
+}, ɵ4 = function () {
+    if (!this._origValues)
+        return;
+    let that = this;
+    this.forEach(function (co) {
+        clearAspect(co, that);
+    });
+    this.length = 0;
+    this._origValues.forEach(function (co) {
+        that.push(co);
+    });
+}, ɵ5 = function () {
+    this._origValues = null;
+};
+let complexArrayMixin = {
+    // complexArray will have the following props
+    //    parent
+    //    propertyPath
+    //    parentProperty
+    //    addedItems  - only if modified
+    //    removedItems  - only if modified
+    //  each complexAspect of any entity within a complexArray
+    //  will have its own _complexState = "A/M";
+    /**
+     Complex arrays are not actually classes, they are objects that mimic arrays. A complex array is collection of
+     complexTypes associated with a data property on a single entity or other complex object. i.e. customer.orders or order.orderDetails.
+     This collection looks like an array in that the basic methods on arrays such as 'push', 'pop', 'shift', 'unshift', 'splice'
+     are all provided as well as several special purpose methods.
+     @class {complexArray}
+     **/
+    /**
+    An [[Event]] that fires whenever the contents of this array changed.  This event
+    is fired any time a new entity is attached or added to the EntityManager and happens to belong to this collection.
+    Adds that occur as a result of query or import operations are batched so that all of the adds or removes to any individual
+    collections are collected into a single notification event for each relation array.
+    @example
+        // assume order is an order entity attached to an EntityManager.
+        orders.arrayChanged.subscribe(
+        function (arrayChangedArgs) {
+            var addedEntities = arrayChangedArgs.added;
+            var removedEntities = arrayChanged.removed;
+        });
+    @event arrayChanged
+    @param added {Array of Entity} An array of all of the entities added to this collection.
+    @param removed {Array of Entity} An array of all of the removed from this collection.
+    @readOnly
+    **/
+    // virtual impls
+    _getGoodAdds: ɵ0,
+    _beforeChange: ɵ1,
+    _processAdds: ɵ2,
+    _processRemoves: ɵ3,
+    _rejectChanges: ɵ4,
+    _acceptChanges: ɵ5
+};
+// local functions
+function getGoodAdds(complexArray, adds) {
+    // remove any that are already added here
+    return adds.filter(function (a) {
+        // return a.parent !== complexArray.parent;  // TODO: check if this is actually a bug in original breezejs ???
+        return a.complexAspect == null || a.complexAspect.parent !== complexArray.parent;
+    });
+}
+function processAdds(complexArray, adds) {
+    adds.forEach(function (a) {
+        // if (a.parent != null) { // TODO: check if this is actually a bug in original breezejs ???
+        if (a.complexAspect && a.complexAspect.parent != null) {
+            throw new Error("The complexObject is already attached. Either clone it or remove it from its current owner");
+        }
+        setAspect(a, complexArray);
+    });
+}
+function processRemoves(complexArray, removes) {
+    removes.forEach(function (a) {
+        clearAspect(a, complexArray);
+    });
+}
+function clearAspect(co, arr) {
+    let coAspect = co.complexAspect;
+    // if not already attached - exit
+    if (coAspect.parent !== arr.parent)
+        return null;
+    coAspect.parent = undefined;
+    coAspect.parentProperty = undefined;
+    return coAspect;
+}
+function setAspect(co, arr) {
+    let coAspect = co.complexAspect;
+    // if already attached - exit
+    if (coAspect.parent === arr.parent)
+        return null;
+    coAspect.parent = arr.parent;
+    coAspect.parentProperty = arr.parentProperty;
+    return coAspect;
+}
+/** For use by breeze plugin authors only. The class is for use in building a [[IModelLibraryAdapter]] implementation.
+@adapter (see [[IModelLibraryAdapter]])
+@hidden
+*/
+export function makeComplexArray(arr, parent, parentProperty) {
+    let arrX = arr;
+    observableArray.initializeParent(arrX, parent, parentProperty);
+    arrX.arrayChanged = new BreezeEvent("arrayChanged", arrX);
+    core.extend(arrX, observableArray.mixin);
+    return core.extend(arrX, complexArrayMixin);
+}
+export { ɵ0, ɵ1, ɵ2, ɵ3, ɵ4, ɵ5 };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"complex-array.js","sourceRoot":"ng://breeze-client/","sources":["src/complex-array.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAG,MAAM,QAAQ,CAAC;AAC/B,OAAO,EAAmB,eAAe,EAAE,MAAM,oBAAoB,CAAC;AACtE,OAAO,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;WAkDtB,UAAS,IAAW;IAChC,OAAO,WAAW,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;AACjC,CAAC,OAEc;IACb,eAAe,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC;AAC1C,CAAC,OAEa,UAAS,IAAW;IAChC,WAAW,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;AAC1B,CAAC,OAEgB,UAAS,OAAc;IACtC,cAAc,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;AAChC,CAAC,OAEe;IACd,IAAI,CAAC,IAAI,CAAC,WAAW;QAAE,OAAO;IAC9B,IAAI,IAAI,GAAG,IAAI,CAAC;IAChB,IAAI,CAAC,OAAO,CAAC,UAAU,EAAiB;QACtC,WAAW,CAAC,EAAE,EAAE,IAAI,CAAC,CAAC;IACxB,CAAC,CAAC,CAAC;IACH,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC;IAChB,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,UAAU,EAAiB;QAClD,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IAChB,CAAC,CAAC,CAAC;AACL,CAAC,OAEe;IACd,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC;AAC1B,CAAC;AApEH,IAAI,iBAAiB,GAAG;IAEtB,6CAA6C;IAC7C,YAAY;IACZ,kBAAkB;IAClB,oBAAoB;IACpB,oCAAoC;IACpC,sCAAsC;IACtC,0DAA0D;IAC1D,4CAA4C;IAE5C;;;;;;QAMI;IAEJ;;;;;;;;;;;;;;;;OAgBG;IAED,gBAAgB;IAClB,YAAY,IAEX;IAED,aAAa,IAEZ;IAED,YAAY,IAEX;IAED,eAAe,IAEd;IAED,cAAc,IAUb;IAED,cAAc,IAEb;CACF,CAAC;AAEF,kBAAkB;AAGlB,SAAS,WAAW,CAAC,YAA0B,EAAE,IAAqB;IACpE,yCAAyC;IACzC,OAAO,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC;QAC5B,8GAA8G;QAC9G,OAAO,CAAC,CAAC,aAAa,IAAI,IAAI,IAAI,CAAC,CAAC,aAAa,CAAC,MAAM,KAAK,YAAY,CAAC,MAAM,CAAC;IACnF,CAAC,CAAC,CAAC;AACL,CAAC;AAED,SAAS,WAAW,CAAC,YAA0B,EAAE,IAAqB;IACpE,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC;QACtB,4FAA4F;QAC5F,IAAI,CAAC,CAAC,aAAa,IAAI,CAAC,CAAC,aAAa,CAAC,MAAM,IAAI,IAAI,EAAE;YACrD,MAAM,IAAI,KAAK,CAAC,4FAA4F,CAAC,CAAC;SAC/G;QACD,SAAS,CAAC,CAAC,EAAE,YAAY,CAAC,CAAC;IAC7B,CAAC,CAAC,CAAC;AACL,CAAC;AAED,SAAS,cAAc,CAAC,YAA0B,EAAE,OAAwB;IAC1E,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC;QACzB,WAAW,CAAC,CAAC,EAAE,YAAY,CAAC,CAAC;IAC/B,CAAC,CAAC,CAAC;AACL,CAAC;AAED,SAAS,WAAW,CAAC,EAAiB,EAAE,GAAiB;IACvD,IAAI,QAAQ,GAAG,EAAE,CAAC,aAAa,CAAC;IAChC,iCAAiC;IACjC,IAAI,QAAQ,CAAC,MAAM,KAAK,GAAG,CAAC,MAAM;QAAE,OAAO,IAAI,CAAC;IAEhD,QAAQ,CAAC,MAAM,GAAG,SAAS,CAAC;IAC5B,QAAQ,CAAC,cAAc,GAAG,SAAS,CAAC;IACpC,OAAO,QAAQ,CAAC;AAClB,CAAC;AAED,SAAS,SAAS,CAAC,EAAiB,EAAE,GAAiB;IACrD,IAAI,QAAQ,GAAG,EAAE,CAAC,aAAa,CAAC;IAChC,6BAA6B;IAC7B,IAAI,QAAQ,CAAC,MAAM,KAAK,GAAG,CAAC,MAAM;QAAE,OAAO,IAAI,CAAC;IAChD,QAAQ,CAAC,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC;IAC7B,QAAQ,CAAC,cAAc,GAAG,GAAG,CAAC,cAAc,CAAC;IAE7C,OAAO,QAAQ,CAAC;AAClB,CAAC;AAGD;;;EAGE;AACF,MAAM,UAAU,gBAAgB,CAAC,GAAU,EAAE,MAAwB,EAAE,cAA4B;IACjG,IAAI,IAAI,GAAG,GAAU,CAAC;IACtB,eAAe,CAAC,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,cAAc,CAAC,CAAC;IAC/D,IAAI,CAAC,YAAY,GAAG,IAAI,WAAW,CAAC,cAAc,EAAE,IAAI,CAAC,CAAC;IAC1D,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,eAAe,CAAC,KAAK,CAAC,CAAC;IACzC,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,iBAAiB,CAAiB,CAAC;AAC9D,CAAC","sourcesContent":["import { core  } from './core';\r\nimport { ObservableArray, observableArray } from './observable-array';\r\nimport { BreezeEvent } from './event';\r\nimport { ComplexObject, StructuralObject } from './entity-aspect';\r\nimport { DataProperty } from './entity-metadata';\r\n\r\n// TODO: mixin impl is not very typesafe\r\n\r\nexport interface ComplexArray extends ObservableArray {\r\n  [index: number]: ComplexObject;\r\n  parent?: StructuralObject;\r\n  parentProperty?: DataProperty;\r\n}\r\n\r\nlet complexArrayMixin = {\r\n\r\n  // complexArray will have the following props\r\n  //    parent\r\n  //    propertyPath\r\n  //    parentProperty\r\n  //    addedItems  - only if modified\r\n  //    removedItems  - only if modified\r\n  //  each complexAspect of any entity within a complexArray\r\n  //  will have its own _complexState = \"A/M\";\r\n\r\n  /**\r\n   Complex arrays are not actually classes, they are objects that mimic arrays. A complex array is collection of\r\n   complexTypes associated with a data property on a single entity or other complex object. i.e. customer.orders or order.orderDetails.\r\n   This collection looks like an array in that the basic methods on arrays such as 'push', 'pop', 'shift', 'unshift', 'splice'\r\n   are all provided as well as several special purpose methods.\r\n   @class {complexArray}\r\n   **/\r\n\r\n  /**\r\n  An [[Event]] that fires whenever the contents of this array changed.  This event\r\n  is fired any time a new entity is attached or added to the EntityManager and happens to belong to this collection.\r\n  Adds that occur as a result of query or import operations are batched so that all of the adds or removes to any individual\r\n  collections are collected into a single notification event for each relation array.\r\n  @example\r\n      // assume order is an order entity attached to an EntityManager.\r\n      orders.arrayChanged.subscribe(\r\n      function (arrayChangedArgs) {\r\n          var addedEntities = arrayChangedArgs.added;\r\n          var removedEntities = arrayChanged.removed;\r\n      });\r\n  @event arrayChanged\r\n  @param added {Array of Entity} An array of all of the entities added to this collection.\r\n  @param removed {Array of Entity} An array of all of the removed from this collection.\r\n  @readOnly\r\n  **/\r\n\r\n    // virtual impls\r\n  _getGoodAdds: function(adds: any[]) {\r\n    return getGoodAdds(this, adds);\r\n  },\r\n\r\n  _beforeChange: function() {\r\n    observableArray.updateEntityState(this);\r\n  },\r\n\r\n  _processAdds: function(adds: any[]) {\r\n    processAdds(this, adds);\r\n  },\r\n\r\n  _processRemoves: function(removes: any[]) {\r\n    processRemoves(this, removes);\r\n  },\r\n\r\n  _rejectChanges: function() {\r\n    if (!this._origValues) return;\r\n    let that = this;\r\n    this.forEach(function (co: ComplexObject) {\r\n      clearAspect(co, that);\r\n    });\r\n    this.length = 0;\r\n    this._origValues.forEach(function (co: ComplexObject) {\r\n      that.push(co);\r\n    });\r\n  },\r\n\r\n  _acceptChanges: function() {\r\n    this._origValues = null;\r\n  }\r\n};\r\n\r\n// local functions\r\n\r\n\r\nfunction getGoodAdds(complexArray: ComplexArray, adds: ComplexObject[]) {\r\n  // remove any that are already added here\r\n  return adds.filter(function (a) {\r\n    // return a.parent !== complexArray.parent;  // TODO: check if this is actually a bug in original breezejs ???\r\n    return a.complexAspect == null || a.complexAspect.parent !== complexArray.parent;\r\n  });\r\n}\r\n\r\nfunction processAdds(complexArray: ComplexArray, adds: ComplexObject[]) {\r\n  adds.forEach(function (a) {\r\n    // if (a.parent != null) { // TODO: check if this is actually a bug in original breezejs ???\r\n    if (a.complexAspect && a.complexAspect.parent != null) {\r\n      throw new Error(\"The complexObject is already attached. Either clone it or remove it from its current owner\");\r\n    }\r\n    setAspect(a, complexArray);\r\n  });\r\n}\r\n\r\nfunction processRemoves(complexArray: ComplexArray, removes: ComplexObject[]) {\r\n  removes.forEach(function (a) {\r\n    clearAspect(a, complexArray);\r\n  });\r\n}\r\n\r\nfunction clearAspect(co: ComplexObject, arr: ComplexArray) {\r\n  let coAspect = co.complexAspect;\r\n  // if not already attached - exit\r\n  if (coAspect.parent !== arr.parent) return null;\r\n\r\n  coAspect.parent = undefined;\r\n  coAspect.parentProperty = undefined;\r\n  return coAspect;\r\n}\r\n\r\nfunction setAspect(co: ComplexObject, arr: ComplexArray) {\r\n  let coAspect = co.complexAspect;\r\n  // if already attached - exit\r\n  if (coAspect.parent === arr.parent) return null;\r\n  coAspect.parent = arr.parent;\r\n  coAspect.parentProperty = arr.parentProperty;\r\n\r\n  return coAspect;\r\n}\r\n\r\n\r\n/** For use by breeze plugin authors only. The class is for use in building a [[IModelLibraryAdapter]] implementation. \r\n@adapter (see [[IModelLibraryAdapter]])    \r\n@hidden \r\n*/\r\nexport function makeComplexArray(arr: any[], parent: StructuralObject, parentProperty: DataProperty) {\r\n  let arrX = arr as any;\r\n  observableArray.initializeParent(arrX, parent, parentProperty);\r\n  arrX.arrayChanged = new BreezeEvent(\"arrayChanged\", arrX);\r\n  core.extend(arrX, observableArray.mixin);\r\n  return core.extend(arrX, complexArrayMixin) as ComplexArray;\r\n}\r\n\r\n"]}