breeze-client 2.1.3-mjs → 2.1.4

package/esm5/src/predicate.js

@@ -0,0 +1,1300 @@
+import { __extends, __read, __spread } from "tslib";
+import { core } from './core';
+import { EntityType, DataProperty } from './entity-metadata';
+import { DataType } from './data-type';
+import { EntityAspect } from './entity-aspect';
+/**
+Used to define a 'where' predicate for an [[EntityQuery]].  Predicates are immutable, which means that any
+method that would modify a Predicate actually returns a new Predicate.
+**/
+var Predicate = /** @class */ (function () {
+    /**
+    Predicate constructor
+    >     let p1 = new Predicate("CompanyName", "StartsWith", "B");
+    >     let query = new EntityQuery("Customers").where(p1);
+  
+    or
+    >     let p2 = new Predicate("Region", FilterQueryOp.Equals, null);
+    >     let query = new EntityQuery("Customers").where(p2);
+    @param property - A property name, a nested property name or an expression involving a property name.
+    @param operator -
+    @param value - This will be treated as either a property expression or a literal depending on context.  In general,
+    if the value can be interpreted as a property expression it will be, otherwise it will be treated as a literal.
+    In most cases this works well, but you can also force the interpretation by making the value argument itself an object with a 'value'
+    property and an 'isLiteral' property set to either true or false.  Breeze also tries to infer the dataType of any
+    literal based on context, if this fails you can force this inference by making the value argument an object with a
+    'value' property and a 'dataType' property set to one of the breeze.DataType enumeration instances.
+    **/
+    function Predicate() {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        if (args.length === 0)
+            return;
+        if (!(this instanceof Predicate)) {
+            return new (Predicate.bind.apply(Predicate, __spread([void 0], args)))();
+        }
+        return Predicate.create.apply(Predicate, __spread(args));
+    }
+    /**
+    Same as using the ctor.
+    >      // so
+    >      let p = Predicate.create(a, b, c);
+    >      // is the same as
+    >      let p = new Predicate(a, b, c);
+    @param property -  A property name, a nested property name or an expression involving a property name.
+    @param operator - the filter query operator.
+    @param value - This will be treated as either a property expression or a literal depending on context.  In general,
+    if the value can be interpreted as a property expression it will be, otherwise it will be treated as a literal.
+    In most cases this works well, but you can also force the interpretation by making the value argument itself an object with a 'value'
+    property and an 'isLiteral' property set to either true or false.  Breeze also tries to infer the dataType of any
+    literal based on context, if this fails you can force this inference by making the value argument an object with a
+    'value' property and a 'dataType' property set to one of the breeze.DataType enumeration instances.
+    **/
+    Predicate.create = function () {
+        // can be called from std javascript without new ( legacy )
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        // empty ctor is used by all subclasses.
+        if (args.length === 0)
+            return new Predicate();
+        if (args.length === 1) {
+            // possibilities:
+            //      Predicate([ aPredicate ]) or  Predicate(["freight", ">", 100]) - an array
+            //      Predicate(aPredicate) - a predicate
+            //      Predicate( "freight gt 100" }  // passthru ( i.e. maybe an odata string) - a string
+            //      Predicate( { freight: { ">": 100 } }) - an object
+            var arg = arguments[0];
+            if (Array.isArray(arg)) {
+                if (arg.length === 1) {
+                    // recurse
+                    return new Predicate(arg[0]);
+                }
+                else {
+                    return createPredicateFromArray(arg);
+                }
+            }
+            else if (arg instanceof Predicate) {
+                return arg;
+            }
+            else if (typeof arg === 'string') {
+                return new PassthruPredicate(arg);
+            }
+            else {
+                return createPredicateFromObject(arg);
+            }
+        }
+        else {
+            // 2 possibilities
+            //      Predicate("freight", ">", 100");
+            //      Predicate("orders", "any", "freight",  ">", 950);
+            return createPredicateFromArray(args);
+        }
+    };
+    /** @hidden @internal */
+    Predicate.prototype._validate = function (entityType, usesNameOnServer) {
+        // noop here;
+    };
+    /**
+    Creates a 'composite' Predicate by 'and'ing a set of specified Predicates together.
+    >      let dt = new Date(88, 9, 12);
+    >      let p1 = Predicate.create("OrderDate", "ne", dt);
+    >      let p2 = Predicate.create("ShipCity", "startsWith", "C");
+    >      let p3 = Predicate.create("Freight", ">", 100);
+    >      let newPred = Predicate.and(p1, p2, p3);
+  
+    or
+    >      let preds = [p1, p2, p3];
+    >      let newPred = Predicate.and(preds);
+    @param predicates - multiple Predicates or an array of Predicate.
+    Any null or undefined values passed in will be automatically filtered out before constructing the composite predicate.
+    **/
+    Predicate.and = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var pred = new AndOrPredicate("and", args);
+        // TODO removed below
+        // return undefined if empty
+        // return pred.op && pred;
+        return pred;
+    };
+    /**
+    Creates a 'composite' Predicate by 'or'ing a set of specified Predicates together.
+    >      let dt = new Date(88, 9, 12);
+    >      let p1 = Predicate.create("OrderDate", "ne", dt);
+    >      let p2 = Predicate.create("ShipCity", "startsWith", "C");
+    >      let p3 = Predicate.create("Freight", ">", 100);
+    >      let newPred = Predicate.or(p1, p2, p3);
+  
+    or
+    >      let preds = [p1, p2, p3];
+    >      let newPred = Predicate.or(preds);
+    @param predicates - multiple Predicates or an array of Predicate.
+    Any null or undefined values passed in will be automatically filtered out before constructing the composite predicate.
+    **/
+    Predicate.or = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var pred = new AndOrPredicate("or", args);
+        // return pred.op && pred;
+        return pred;
+    };
+    /**
+    Creates a 'composite' Predicate by 'negating' a specified predicate.
+    >      let p1 = Predicate.create("Freight", "gt", 100);
+    >      let not_p1 = Predicate.not(p1);
+  
+    This can also be accomplished using the 'instance' version of the 'not' method
+    >      let not_p1 = p1.not();
+  
+    Both of which would be the same as
+    >      let not_p1 = Predicate.create("Freight", "le", 100);
+    **/
+    Predicate.not = function (pred) {
+        return pred.not();
+    };
+    // TODO: determine if/where this is used.
+    // static extendBinaryPredicateFn(opMap: IOpMap, visitorFn: any) {
+    //   let baseVisitorFn = toFunctionVisitor.binaryPredicate;
+    //   for (let op in (opMap || {})) {
+    //     let config = opMap[op];
+    //     config.visitorFn = visitorFn;
+    //     updateAliasMap(BinaryPredicate.prototype.aliasMap, op, opMap[op]);
+    //   }
+    //   if (!toFunctionVisitor.isExtended) {
+    //     toFunctionVisitor.binaryPredicate = function (context, expr1Val, expr2Val) {
+    //       let visitorFn = this.aliasMap[this.op.key].visitorFn;
+    //       if (visitorFn) {
+    //         return visitorFn(context, expr1Val, expr2Val);
+    //       } else {
+    //         return baseVisitorFn(context, expr1Val, expr2Val);
+    //       }
+    //     };
+    //     toFunctionVisitor.isExtended = true;
+    //   }
+    // };
+    Predicate.extendFuncMap = function (funcMap) {
+        for (var func in (funcMap || {})) {
+            var config = funcMap[func];
+            FnExpr._funcMap[func] = config;
+        }
+    };
+    ;
+    /**
+    'And's this Predicate with one or more other Predicates and returns a new 'composite' Predicate
+    >      let dt = new Date(88, 9, 12);
+    >      let p1 = Predicate.create("OrderDate", "ne", dt);
+    >      let p2 = Predicate.create("ShipCity", "startsWith", "C");
+    >      let p3 = Predicate.create("Freight", ">", 100);
+    >      let newPred = p1.and(p2, p3);
+  
+    or
+    >      let preds = [p2, p3];
+    >      let newPred = p1.and(preds);
+  
+    The 'and' method is also used to write "fluent" expressions
+    >      let p4 = Predicate.create("ShipCity", "startswith", "F")
+    >        .and("Size", "gt", 2000);
+    @param predicates - multiple Predicates or an array of Predicates.
+    Any null or undefined values passed in will be automatically filtered out before constructing the composite predicate.
+    **/
+    Predicate.prototype.and = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return new AndOrPredicate("and", argsForAndOrPredicates(this, args));
+    };
+    /**
+    'Or's this Predicate with one or more other Predicates and returns a new 'composite' Predicate
+    >      let dt = new Date(88, 9, 12);
+    >      let p1 = Predicate.create("OrderDate", "ne", dt);
+    >      let p2 = Predicate.create("ShipCity", "startsWith", "C");
+    >      let p3 = Predicate.create("Freight", ">", 100);
+    >      let newPred = p1.or(p2, p3);
+  
+    or
+    >      let preds = [p2, p3];
+    >      let newPred = p1.or(preds);
+  
+    The 'or' method is also used to write "fluent" expressions
+    >      let p4 = Predicate.create("ShipCity", "startswith", "F")
+    >        .or("Size", "gt", 2000);
+    @param predicates - multiple Predicates or an array of Predicates.
+    Any null or undefined values passed in will be automatically filtered out before constructing the composite predicate.
+    **/
+    Predicate.prototype.or = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return new AndOrPredicate("or", argsForAndOrPredicates(this, args));
+    };
+    /**
+    Returns the 'negated' version of this Predicate
+    >      let p1 = Predicate.create("Freight", "gt", 100);
+    >      let not_p1 = p1.not();
+  
+    This can also be accomplished using the 'static' version of the 'not' method
+    >      let p1 = Predicate.create("Freight", "gt", 100);
+    >      let not_p1 = Predicate.not(p1);
+  
+    which would be the same as
+    >      let not_p1 = Predicate.create("Freight", "le", 100);
+    **/
+    Predicate.prototype.not = function () {
+        return new UnaryPredicate("not", this);
+    };
+    //
+    Predicate.prototype.toJSON = function () {
+        // toJSON ( part of js standard - takes a single parameter
+        // that is either "" or the name of the property being serialized.
+        return this.toJSONExt({ entityType: this._entityType });
+    };
+    /** For use by breeze plugin authors only. The class is for use in building a [[IUriBuilderAdapter]] implementation.
+    @adapter (see [[IUriBuilderAdapter]])
+    @hidden @internal
+    */
+    Predicate.prototype.toJSONExt = function (context) {
+        return this.visit(context, toJSONVisitor);
+    };
+    /** For use by breeze plugin authors only. The class is for use in building a [[IUriBuilderAdapter]] implementation.
+    @adapter (see [[IUriBuilderAdapter]])
+    @hidden @internal
+    */
+    Predicate.prototype.toFunction = function (context) {
+        return this.visit(context, toFunctionVisitor);
+    };
+    Predicate.prototype.toString = function () {
+        return JSON.stringify(this);
+    };
+    /** For use by breeze plugin authors only. The class is for use in building a [[IUriBuilderAdapter]] implementation.
+    @adapter (see [[IUriBuilderAdapter]])
+    @hidden @internal
+    */
+    Predicate.prototype.visit = function (context, visitor) {
+        if (core.isEmpty(context)) {
+            context = { entityType: undefined };
+        }
+        else if (context instanceof EntityType) {
+            context = { entityType: context };
+        }
+        else if (!core.hasOwnProperty(context, "entityType")) {
+            throw new Error("All visitor methods must be called with a context object containing at least an 'entityType' property");
+        }
+        if (visitor) {
+            context.visitor = visitor;
+        }
+        var tVisitor = visitor || context.visitor;
+        var fn = tVisitor[this.visitorMethodName];
+        if (fn == null) {
+            throw new Error("Unable to locate method: " + this.visitorMethodName + " on visitor");
+        }
+        var entityType = context.entityType;
+        // don't bother validating if already done so ( or if no _validate method
+        if (this._validate && (entityType == null || this._entityType !== entityType)) {
+            // don't need to capture return value because validation fn doesn't have one.
+            // TODO: this was old code
+            // this._validate(entityType, context.usesNameOnServer);
+            this._validate(entityType, context.toNameOnServer);
+            this._entityType = entityType;
+        }
+        return fn.call(this, context);
+    };
+    /** @hidden @internal */
+    Predicate.prototype._initialize = function (visitorMethodName, opMap) {
+        if (opMap === void 0) { opMap = {}; }
+        this.visitorMethodName = visitorMethodName;
+        var aliasMap = this.aliasMap = {};
+        for (var op in opMap) {
+            updateAliasMap(aliasMap, op, opMap[op]);
+        }
+    };
+    /** @hidden @internal */
+    Predicate.prototype._resolveOp = function (op, okIfNotFound) {
+        var opStr = (typeof op === "string") ? op : op.operator;
+        var result = this.aliasMap[opStr.toLowerCase()];
+        if (!result && !okIfNotFound) {
+            throw new Error("Unable to resolve operator: " + opStr);
+        }
+        return result;
+    };
+    return Predicate;
+}());
+export { Predicate };
+function createPredicateFromArray(arr) {
+    // TODO: assert that length of the array should be > 3
+    // Needs to handle:
+    //      [ "freight", ">", 100"];
+    //      [ "orders", "any", "freight",  ">", 950 ]
+    //      [ "orders", "and", anotherPred ]
+    //      [ "orders", "and", [ "freight, ">", 950 ]]
+    var json = {};
+    var value = {};
+    json[arr[0]] = value;
+    var op = arr[1];
+    op = op.operator || op; // incoming op will be either a string or a FilterQueryOp
+    if (arr.length === 3) {
+        value[op] = arr[2];
+    }
+    else {
+        value[op] = createPredicateFromArray(arr.splice(2));
+    }
+    return createPredicateFromObject(json);
+}
+function createPredicateFromObject(obj) {
+    if (obj instanceof Predicate)
+        return obj;
+    if (typeof obj !== 'object') {
+        throw new Error("Unable to convert to a Predicate: " + obj);
+    }
+    var keys = Object.keys(obj);
+    var preds = keys.map(function (key) {
+        return createPredicateFromKeyValue(key, obj[key]);
+    });
+    return (preds.length === 1) ? preds[0] : new AndOrPredicate("and", preds);
+}
+function createPredicateFromKeyValue(key, value) {
+    // { and: [a,b] } key='and', value = [a,b]
+    if (AndOrPredicate.prototype._resolveOp(key, true)) {
+        return new AndOrPredicate(key, value);
+    }
+    // { not: a }  key= 'not', value = a
+    if (UnaryPredicate.prototype._resolveOp(key, true)) {
+        return new UnaryPredicate(key, value);
+    }
+    if ((typeof value !== 'object') || value == null || core.isDate(value)) {
+        // { foo: bar } key='foo', value = bar ( where bar is a literal i.e. a string, a number, a boolean or a date.
+        return new BinaryPredicate("eq", key, value);
+    }
+    else if (core.hasOwnProperty(value, 'value')) {
+        // { foo: { value: bar, dataType: xxx} } key='foo', value = bar ( where bar is an object representing a literal
+        return new BinaryPredicate("eq", key, value);
+    }
+    if (Array.isArray(value)) {
+        throw new Error("Unable to resolve predicate after the phrase: " + key);
+    }
+    var expr = key;
+    var keys = Object.keys(value);
+    var preds = keys.map(function (op) {
+        // { a: { any: b } op = 'any', expr=a, value[op] = b
+        if (AnyAllPredicate.prototype._resolveOp(op, true)) {
+            return new AnyAllPredicate(op, expr, value[op]);
+        }
+        if (BinaryPredicate.prototype._resolveOp(op, true)) {
+            // { a: { ">": b }} op = ">", expr=a, value[op] = b
+            return new BinaryPredicate(op, expr, value[op]);
+        }
+        else if (core.hasOwnProperty(value[op], 'value')) {
+            // { a: { ">": { value: b, dataType: 'Int32' }} expr = a value[op] = { value: b, dataType: 'Int32' }
+            return new BinaryPredicate("eq", expr, value[op]);
+        }
+        var msg = core.formatString("Unable to resolve predicate after the phrase: '%1' for operator: '%2'  and value: '%3'", expr, op, value[op]);
+        throw new Error(msg);
+    });
+    return (preds.length === 1) ? preds[0] : new AndOrPredicate("and", preds);
+}
+function argsForAndOrPredicates(obj, args) {
+    var preds = args[0];
+    if (preds instanceof Predicate) {
+        preds = core.arraySlice(args);
+    }
+    else if (!Array.isArray(preds)) {
+        preds = [new Predicate(core.arraySlice(args))];
+    }
+    return [obj].concat(preds);
+}
+function updateAliasMap(aliasMap, opStr, op) {
+    var key = opStr.toLowerCase();
+    op.key = key;
+    aliasMap[key] = op;
+    op.aliases && op.aliases.forEach(function (alias) {
+        aliasMap[alias.toLowerCase()] = op;
+    });
+}
+/** For use by breeze plugin authors only. The class is for use in building a [[IUriBuilderAdapter]] implementation.
+@adapter (see [[IUriBuilderAdapter]])
+@hidden @internal
+*/
+var PassthruPredicate = /** @class */ (function (_super) {
+    __extends(PassthruPredicate, _super);
+    function PassthruPredicate(value) {
+        var _this = _super.call(this) || this;
+        _this.value = value;
+        return _this;
+    }
+    return PassthruPredicate;
+}(Predicate));
+Error['x'] = PassthruPredicate.prototype._initialize('passthruPredicate');
+/** For use by breeze plugin authors only. The class is for use in building a [[IUriBuilderAdapter]] implementation.
+@adapter (see [[IUriBuilderAdapter]])
+@hidden
+*/
+var UnaryPredicate = /** @class */ (function (_super) {
+    __extends(UnaryPredicate, _super);
+    function UnaryPredicate(op) {
+        var args = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            args[_i - 1] = arguments[_i];
+        }
+        var _this = _super.call(this) || this;
+        _this.op = _this._resolveOp(op);
+        _this.pred = new Predicate(args);
+        return _this;
+    }
+    UnaryPredicate.prototype._validate = function (entityType, usesNameOnServer) {
+        this.pred._validate(entityType, usesNameOnServer);
+    };
+    return UnaryPredicate;
+}(Predicate));
+export { UnaryPredicate };
+Error['x'] = UnaryPredicate.prototype._initialize('unaryPredicate', {
+    'not': { aliases: ['!', '~'] },
+});
+/** For use by breeze plugin authors only. The class is for use in building a [[IUriBuilderAdapter]] implementation.
+@adapter (see [[IUriBuilderAdapter]])
+@hidden
+*/
+var BinaryPredicate = /** @class */ (function (_super) {
+    __extends(BinaryPredicate, _super);
+    function BinaryPredicate(op, expr1, expr2) {
+        var _this = _super.call(this) || this;
+        // 5 public props op, expr1Source, expr2Source, expr1, expr2
+        _this.op = _this._resolveOp(op);
+        _this.expr1Source = expr1;
+        _this.expr2Source = expr2;
+        return _this;
+        // this.expr1 and this.expr2 won't be
+        // determined until validate is run
+    }
+    BinaryPredicate.prototype._validate = function (entityType, usesNameOnServer) {
+        var expr1Context = { entityType: entityType, usesNameOnServer: usesNameOnServer };
+        this.expr1 = createExpr(this.expr1Source, expr1Context);
+        if (this.expr1 == null) {
+            throw new Error("Unable to validate 1st expression: " + this.expr1Source);
+        }
+        if (this.expr1 instanceof LitExpr) {
+            // lhs must be either a property or a function.
+            throw new Error("The left hand side of a binary predicate cannot be a literal expression, it must be a valid property or functional predicate expression: " + this.expr1Source);
+        }
+        if (this.op.key === 'in' && !Array.isArray(this.expr2Source)) {
+            throw new Error("The 'in' operator requires that its right hand argument be an array");
+        }
+        var expr2Context = core.extend(expr1Context, { isRHS: true, dataType: this.expr1.dataType });
+        this.expr2 = createExpr(this.expr2Source, expr2Context);
+        if (this.expr2 == null) {
+            throw new Error("Unable to validate 2nd expression: " + this.expr2Source);
+        }
+        if (this.expr1.dataType == null) {
+            this.expr1.dataType = this.expr2.dataType;
+        }
+    };
+    return BinaryPredicate;
+}(Predicate));
+export { BinaryPredicate };
+Error['x'] = BinaryPredicate.prototype._initialize('binaryPredicate', {
+    'eq': {
+        aliases: ["==", "equals"]
+    },
+    'ne': {
+        aliases: ["!=", "~=", "notequals"]
+    },
+    'lt': {
+        aliases: ["<", "lessthan"]
+    },
+    'le': {
+        aliases: ["<=", "lessthanorequal"]
+    },
+    'gt': {
+        aliases: [">", "greaterthan"]
+    },
+    'ge': {
+        aliases: [">=", "greaterthanorequal"]
+    },
+    'startswith': {
+        isFunction: true
+    },
+    'endswith': {
+        isFunction: true
+    },
+    'contains': {
+        aliases: ["substringof"],
+        isFunction: true
+    },
+    'in': {}
+});
+/** For use by breeze plugin authors only. The class is for use in building a [[IUriBuilderAdapter]] implementation.
+@adapter (see [[IUriBuilderAdapter]])
+@hidden
+*/
+var AndOrPredicate = /** @class */ (function (_super) {
+    __extends(AndOrPredicate, _super);
+    function AndOrPredicate(op, preds) {
+        var _this = _super.call(this) || this;
+        _this.op = _this._resolveOp(op);
+        if (preds.length === 1 && Array.isArray(preds[0])) {
+            preds = preds[0];
+        }
+        _this.preds = preds.filter(function (pred) {
+            return pred != null;
+        }).map(function (pred) {
+            return new Predicate(pred);
+        });
+        // TODO: this was removed - test if really needed.
+        // if (this.preds.length === 0) {
+        //   // marker for an empty predicate
+        //   this.op = null;
+        // }
+        if (_this.preds.length === 1) {
+            return _this.preds[0]; // HACK: this.preds[0] is actually NOT a AndOrPredicate but some other kind of pred.
+        }
+        return _this;
+    }
+    AndOrPredicate.prototype._validate = function (entityType, usesNameOnServer) {
+        this.preds.forEach(function (pred) {
+            pred._validate(entityType, usesNameOnServer);
+        });
+    };
+    return AndOrPredicate;
+}(Predicate));
+export { AndOrPredicate };
+Error['x'] = AndOrPredicate.prototype._initialize("andOrPredicate", {
+    'and': { aliases: ['&&'] },
+    'or': { aliases: ['||'] }
+});
+/** For use by breeze plugin authors only. The class is for use in building a [[IUriBuilderAdapter]] implementation.
+@adapter (see [[IUriBuilderAdapter]])
+@hidden
+*/
+var AnyAllPredicate = /** @class */ (function (_super) {
+    __extends(AnyAllPredicate, _super);
+    // 4 public props: op, exprSource, expr, pred
+    function AnyAllPredicate(op, expr, pred) {
+        var _this = _super.call(this) || this;
+        _this.op = _this._resolveOp(op);
+        _this.exprSource = expr;
+        // this.expr will not be resolved until validate is called
+        _this.pred = new Predicate(pred);
+        return _this;
+    }
+    AnyAllPredicate.prototype._validate = function (entityType, usesNameOnServer) {
+        this.expr = createExpr(this.exprSource, { entityType: entityType, usesNameOnServer: usesNameOnServer });
+        // can't really know the predicateEntityType unless the original entity type was known.
+        if (entityType == null || entityType.isAnonymous) {
+            this.expr.dataType = undefined;
+        }
+        this.pred._validate(this.expr.dataType, usesNameOnServer);
+    };
+    return AnyAllPredicate;
+}(Predicate));
+export { AnyAllPredicate };
+Error['x'] = AnyAllPredicate.prototype._initialize("anyAllPredicate", {
+    'any': { aliases: ['some'] },
+    'all': { aliases: ["every"] }
+});
+/** @hidden */
+var PredicateExpression = /** @class */ (function () {
+    function PredicateExpression(visitorMethodName) {
+        this.visitorMethodName = visitorMethodName;
+        // give expressions the Predicate prototype method
+        this.visit = Predicate.prototype.visit;
+    }
+    // default impls - may/will be overridden be subclass expressions
+    PredicateExpression.prototype._validate = function (entityType, usesNameOnServer) {
+        // noop;
+    };
+    return PredicateExpression;
+}());
+export { PredicateExpression };
+/** For use by breeze plugin authors only. The class is for use in building a [[IUriBuilderAdapter]] implementation.
+@adapter (see [[IUriBuilderAdapter]])
+@hidden
+*/
+var LitExpr = /** @class */ (function (_super) {
+    __extends(LitExpr, _super);
+    // 2 public props: value, dataType
+    function LitExpr(value, dataType, hasExplicitDataType) {
+        var _this = _super.call(this, "litExpr") || this;
+        // dataType may come is an a string
+        var dt1 = resolveDataType(dataType);
+        // if the DataType comes in as Undefined this means
+        // that we should NOT attempt to parse it but just leave it alone
+        // for now - this is usually because it is part of a Func expr.
+        // TODO: cast as DataType seems to be needed by early version of TypeDoc - may be able to remove later
+        var dt2 = (dt1 || DataType.fromValue(value));
+        if (dt2.parse) {
+            if (Array.isArray(value)) {
+                _this.value = value.map(function (v) { return dt2.parse(v, typeof v); });
+            }
+            else {
+                _this.value = dt2.parse(value, typeof value);
+            }
+        }
+        else {
+            _this.value = value;
+        }
+        _this.dataType = dt2;
+        _this.hasExplicitDataType = !!hasExplicitDataType;
+        return _this;
+    }
+    LitExpr.prototype.toString = function () {
+        return " LitExpr - value: " + this.value.toString() + " dataType: " + this.dataType.toString();
+    };
+    return LitExpr;
+}(PredicateExpression));
+export { LitExpr };
+function resolveDataType(dataType) {
+    if (dataType == null)
+        return dataType;
+    // if (DataType.contains(dataType)) {
+    if (dataType instanceof DataType) {
+        return dataType;
+    }
+    if (typeof dataType === 'string') {
+        var dt = DataType.fromName(dataType);
+        if (dt)
+            return dt;
+        throw new Error("Unable to resolve a dataType named: " + dataType);
+    }
+    throw new Error("The dataType parameter passed into this literal expression is not a 'DataType'" + dataType);
+}
+/** For use by breeze plugin authors only. The class is for use in building a [[IUriBuilderAdapter]] implementation.
+@adapter (see [[IUriBuilderAdapter]])
+@hidden
+*/
+var PropExpr = /** @class */ (function (_super) {
+    __extends(PropExpr, _super);
+    // two public props: propertyPath, dateType
+    function PropExpr(propertyPath) {
+        var _this = _super.call(this, 'propExpr') || this;
+        _this.propertyPath = propertyPath;
+        return _this;
+        //this.dataType = DataType.Undefined;
+        // this.dataType resolved after validate ( if not on an anon type }
+    }
+    PropExpr.prototype.toString = function () {
+        return " PropExpr - " + this.propertyPath;
+    };
+    PropExpr.prototype._validate = function (entityType, usesNameOnServer) {
+        if (entityType == null || entityType.isAnonymous)
+            return;
+        var props = entityType.getPropertiesOnPath(this.propertyPath, null, false);
+        if (!props) {
+            var msg = core.formatString("Unable to resolve propertyPath.  EntityType: '%1'   PropertyPath: '%2'", entityType.name, this.propertyPath);
+            throw new Error(msg);
+        }
+        // get the last property
+        var prop = props[props.length - 1];
+        if (prop instanceof DataProperty) {
+            this.dataType = prop.dataType;
+        }
+        else {
+            this.dataType = prop.entityType;
+        }
+    };
+    return PropExpr;
+}(PredicateExpression));
+export { PropExpr };
+/** For use by breeze plugin authors only. The class is for use in building a [[IUriBuilderAdapter]] implementation.
+@adapter (see [[IUriBuilderAdapter]])
+@hidden @dynamic
+*/
+var FnExpr = /** @class */ (function (_super) {
+    __extends(FnExpr, _super);
+    function FnExpr(fnName, exprs) {
+        var _this = _super.call(this, 'fnExpr') || this;
+        // 4 public props: fnName, exprs, localFn, dataType
+        _this.fnName = fnName;
+        _this.exprs = exprs;
+        var qf = FnExpr._funcMap[fnName];
+        if (qf == null) {
+            throw new Error("Unknown function: " + fnName);
+        }
+        _this.localFn = qf.fn;
+        _this.dataType = qf.dataType;
+        return _this;
+    }
+    FnExpr.prototype.toString = function () {
+        var exprStr = this.exprs.map(function (expr) {
+            expr.toString();
+        }).toString();
+        return "FnExpr - " + this.fnName + "(" + exprStr + ")";
+    };
+    FnExpr.prototype._validate = function (entityType, usesNameOnServer) {
+        this.exprs.forEach(function (expr) {
+            expr._validate(entityType, usesNameOnServer);
+        });
+    };
+    FnExpr._funcMap = {
+        toupper: {
+            fn: function (source) {
+                return source.toUpperCase();
+            }, dataType: DataType.String
+        },
+        tolower: {
+            fn: function (source) {
+                return source.toLowerCase();
+            }, dataType: DataType.String
+        },
+        substring: {
+            fn: function (source, pos, length) {
+                return source.substring(pos, length);
+            }, dataType: DataType.String
+        },
+        substringof: {
+            fn: function (find, source) {
+                return source.indexOf(find) >= 0;
+            }, dataType: DataType.Boolean
+        },
+        length: {
+            fn: function (source) {
+                return source.length;
+            }, dataType: DataType.Int32
+        },
+        trim: {
+            fn: function (source) {
+                return source.trim();
+            }, dataType: DataType.String
+        },
+        concat: {
+            fn: function (s1, s2) {
+                return s1.concat(s2);
+            }, dataType: DataType.String
+        },
+        replace: {
+            fn: function (source, find, replace) {
+                return source.replace(find, replace);
+            }, dataType: DataType.String
+        },
+        startswith: {
+            fn: function (source, find) {
+                return core.stringStartsWith(source, find);
+            }, dataType: DataType.Boolean
+        },
+        endswith: {
+            fn: function (source, find) {
+                return core.stringEndsWith(source, find);
+            }, dataType: DataType.Boolean
+        },
+        indexof: {
+            fn: function (source, find) {
+                return source.indexOf(find);
+            }, dataType: DataType.Int32
+        },
+        round: {
+            fn: function (source) {
+                return Math.round(source);
+            }, dataType: DataType.Int32
+        },
+        ceiling: {
+            fn: function (source) {
+                return Math.ceil(source);
+            }, dataType: DataType.Int32
+        },
+        floor: {
+            fn: function (source) {
+                return Math.floor(source);
+            }, dataType: DataType.Int32
+        },
+        second: {
+            fn: function (source) {
+                return source.getSeconds();
+            }, dataType: DataType.Int32
+        },
+        minute: {
+            fn: function (source) {
+                return source.getMinutes();
+            }, dataType: DataType.Int32
+        },
+        day: {
+            fn: function (source) {
+                return source.getDate();
+            }, dataType: DataType.Int32
+        },
+        month: {
+            fn: function (source) {
+                return source.getMonth() + 1;
+            }, dataType: DataType.Int32
+        },
+        year: {
+            fn: function (source) {
+                return source.getFullYear();
+            }, dataType: DataType.Int32
+        }
+    };
+    return FnExpr;
+}(PredicateExpression));
+export { FnExpr };
+// TODO: add dataTypes for the args next - will help to infer other dataTypes.
+var RX_IDENTIFIER = /^[a-z_][\w.$]*$/i;
+// comma delimited expressions ignoring commas inside of both single and double quotes.
+var RX_COMMA_DELIM1 = /('[^']*'|[^,]+)/g;
+var RX_COMMA_DELIM2 = /("[^"]*"|[^,]+)/g;
+var DELIM = String.fromCharCode(191);
+function createExpr(source, exprContext) {
+    var entityType = exprContext.entityType;
+    // the right hand side of an 'in' clause
+    if (Array.isArray(source)) {
+        if (!exprContext.isRHS) {
+            throw new Error("Array expressions are only permitted on the right hand side of a BinaryPredicate");
+        }
+        return new LitExpr(source, exprContext.dataType);
+    }
+    if (!(typeof source === 'string')) {
+        if (source != null && typeof source === 'object' && !source.toISOString) {
+            // source is an object but not a Date-like thing such as a JS or MomentJS Date
+            if (source.value === undefined) {
+                throw new Error("Unable to resolve an expression for: " + source + " on entityType: " + (entityType ? entityType.name : 'null'));
+            }
+            if (source.isProperty) {
+                return new PropExpr(source.value);
+            }
+            else {
+                // we want to insure that any LitExpr created this way is tagged with 'hasExplicitDataType: true'
+                // because we want to insure that if we roundtrip thru toJSON that we don't
+                // accidentally reinterpret this node as a PropExpr.
+                // return new LitExpr(source.value, source.dataType || context.dataType, !!source.dataType);
+                return new LitExpr(source.value, source.dataType || exprContext.dataType, true);
+            }
+        }
+        else {
+            return new LitExpr(source, exprContext.dataType);
+        }
+    }
+    if (exprContext.isRHS) {
+        if (entityType == null || entityType.isAnonymous) {
+            // if entityType is unknown then assume that the rhs is a literal
+            return new LitExpr(source, exprContext.dataType);
+        }
+        else {
+            return parseLitOrPropExpr(source, exprContext);
+        }
+    }
+    else {
+        var regex = /\([^()]*\)/;
+        var m = void 0;
+        var tokens = [];
+        var i = 0;
+        while (m = regex.exec(source)) {
+            var token = m[0];
+            tokens.push(token);
+            var repl = DELIM + i++;
+            source = source.replace(token, repl);
+        }
+        var expr = parseExpr(source, tokens, exprContext);
+        expr._validate(entityType, exprContext.usesNameOnServer);
+        return expr;
+    }
+}
+function parseExpr(source, tokens, exprContext) {
+    var parts = source.split(DELIM);
+    if (parts.length === 1) {
+        return parseLitOrPropExpr(parts[0], exprContext);
+    }
+    else {
+        return parseFnExpr(source, parts, tokens, exprContext);
+    }
+}
+function parseLitOrPropExpr(value, exprContext) {
+    value = value.trim();
+    // value is either a string, a quoted string, a number, a bool value, or a date
+    // if a string ( not a quoted string) then this represents a property name ( 1st ) or a lit string ( 2nd)
+    var firstChar = value.substr(0, 1);
+    var isQuoted = (firstChar === "'" || firstChar === '"') && value.length > 1 && value.substr(value.length - 1) === firstChar;
+    if (isQuoted) {
+        var unquotedValue = value.substr(1, value.length - 2);
+        return new LitExpr(unquotedValue, exprContext.dataType || DataType.String);
+    }
+    else {
+        var entityType = exprContext.entityType;
+        // TODO: get rid of isAnonymous below when we get the chance.
+        if (entityType == null || entityType.isAnonymous) {
+            // this fork will only be reached on the LHS of an BinaryPredicate -
+            // a RHS expr cannot get here with an anon type
+            return new PropExpr(value);
+        }
+        else {
+            var mayBeIdentifier = RX_IDENTIFIER.test(value);
+            if (mayBeIdentifier) {
+                // if (entityType.getProperty(value, false) != null) {
+                if (entityType.getPropertiesOnPath(value, null, false) != null) {
+                    return new PropExpr(value);
+                }
+            }
+        }
+        // we don't really know the datatype here because even though it comes in as a string
+        // its usually a string BUT it might be a number  i.e. the "1" or the "2" from an expr
+        // like "toUpper(substring(companyName, 1, 2))"
+        return new LitExpr(value, exprContext.dataType);
+    }
+}
+function parseFnExpr(source, parts, tokens, exprContext) {
+    try {
+        var fnName = parts[0].trim().toLowerCase();
+        var argSource = tokens[parts[1]].trim();
+        if (argSource.substr(0, 1) === "(") {
+            argSource = argSource.substr(1, argSource.length - 2);
+        }
+        var commaMatchStr = source.indexOf("'") >= 0 ? RX_COMMA_DELIM1 : RX_COMMA_DELIM2;
+        var args = argSource.match(commaMatchStr);
+        var newContext_1 = core.extend({}, exprContext);
+        // a dataType of Undefined on a context basically means not to try parsing
+        // the value if the expr is a literal
+        newContext_1.dataType = DataType.Undefined;
+        newContext_1.isFnArg = true;
+        var exprs = args.map(function (a) {
+            return parseExpr(a, tokens, newContext_1);
+        });
+        return new FnExpr(fnName, exprs);
+    }
+    catch (e) {
+        // TODO: removed old code here
+        // return null;
+        // and replaced with 
+        throw e;
+    }
+}
+var ɵ0 = function () {
+    throw new Error("Cannot execute an PassthruPredicate expression against the local cache: " + this.value);
+}, ɵ1 = function (context) {
+    var predFn = this.pred.visit(context);
+    switch (this.op.key) {
+        case "not":
+            return function (entity) {
+                return !predFn(entity);
+            };
+        default:
+            throw new Error("Invalid unary operator:" + this.op.key);
+    }
+}, ɵ2 = function (context) {
+    var expr1Fn = this.expr1.visit(context);
+    var expr2Fn = this.expr2.visit(context);
+    var dataType = this.expr1.dataType || this.expr2.dataType;
+    var lqco = context.entityType.metadataStore.localQueryComparisonOptions;
+    var predFn = getBinaryPredicateFn(this, dataType, lqco);
+    if (predFn == null) {
+        throw new Error("Invalid binaryPredicate operator:" + this.op.key);
+    }
+    return function (entity) {
+        return predFn(expr1Fn(entity), expr2Fn(entity));
+    };
+}, ɵ3 = function (context) {
+    var predFns = this.preds.map(function (pred) {
+        return pred.visit(context);
+    });
+    switch (this.op.key) {
+        case "and":
+            return function (entity) {
+                var result = predFns.reduce(function (prev, cur) {
+                    return prev && cur(entity);
+                }, true);
+                return result;
+            };
+        case "or":
+            return function (entity) {
+                var result = predFns.reduce(function (prev, cur) {
+                    return prev || cur(entity);
+                }, false);
+                return result;
+            };
+        default:
+            throw new Error("Invalid boolean operator:" + this.op.key);
+    }
+}, ɵ4 = function (context) {
+    var exprFn = this.expr.visit(context);
+    var newContext = core.extend({}, context);
+    newContext.entityType = this.expr.dataType;
+    var predFn = this.pred.visit(newContext);
+    var anyAllPredFn = getAnyAllPredicateFn(this.op);
+    return function (entity) {
+        return anyAllPredFn(exprFn(entity), predFn);
+    };
+}, ɵ5 = function () {
+    var value = this.value;
+    return function (entity) {
+        return value;
+    };
+}, ɵ6 = function () {
+    var propertyPath = this.propertyPath;
+    var properties = propertyPath.split('.');
+    if (properties.length === 1) {
+        return function (entity) {
+            return entity.getProperty(propertyPath);
+        };
+    }
+    else {
+        return function (entity) {
+            return EntityAspect.getPropertyPathValue(entity, properties);
+        };
+    }
+}, ɵ7 = function (context) {
+    var exprFns = this.exprs.map(function (expr) {
+        return expr.visit(context);
+    });
+    var that = this;
+    return function (entity) {
+        var values = exprFns.map(function (exprFn) {
+            var value = exprFn(entity);
+            return value;
+        });
+        var result = that.localFn.apply(null, values);
+        return result;
+    };
+};
+// toFunctionVisitor
+var toFunctionVisitor = {
+    isExtended: false,
+    passthruPredicate: ɵ0,
+    unaryPredicate: ɵ1,
+    binaryPredicate: ɵ2,
+    andOrPredicate: ɵ3,
+    anyAllPredicate: ɵ4,
+    litExpr: ɵ5,
+    propExpr: ɵ6,
+    fnExpr: ɵ7
+};
+function getAnyAllPredicateFn(op) {
+    switch (op.key) {
+        case "any":
+            return function (v1, v2) {
+                return v1.some(function (v) {
+                    return v2(v);
+                });
+            };
+        case "all":
+            return function (v1, v2) {
+                return v1.every(function (v) {
+                    return v2(v);
+                });
+            };
+        default:
+            throw new Error("Unknown operator: " + op.key);
+    }
+}
+function getBinaryPredicateFn(binaryPredicate, dataType, lqco) {
+    var op = binaryPredicate.op;
+    var mc = DataType.getComparableFn(dataType);
+    var predFn;
+    switch (op.key) {
+        case 'eq':
+            predFn = function (v1, v2) {
+                if (v1 && typeof v1 === 'string') {
+                    return stringEquals(v1, v2, lqco);
+                }
+                else {
+                    return mc(v1) === mc(v2);
+                }
+            };
+            break;
+        case 'ne':
+            predFn = function (v1, v2) {
+                if (v1 && typeof v1 === 'string') {
+                    return !stringEquals(v1, v2, lqco);
+                }
+                else {
+                    return mc(v1) !== mc(v2);
+                }
+            };
+            break;
+        case 'gt':
+            predFn = function (v1, v2) {
+                return mc(v1) > mc(v2);
+            };
+            break;
+        case 'ge':
+            predFn = function (v1, v2) {
+                return mc(v1) >= mc(v2);
+            };
+            break;
+        case 'lt':
+            predFn = function (v1, v2) {
+                return mc(v1) < mc(v2);
+            };
+            break;
+        case 'le':
+            predFn = function (v1, v2) {
+                return mc(v1) <= mc(v2);
+            };
+            break;
+        case 'startswith':
+            predFn = function (v1, v2) {
+                return stringStartsWith(v1, v2, lqco);
+            };
+            break;
+        case 'endswith':
+            predFn = function (v1, v2) {
+                return stringEndsWith(v1, v2, lqco);
+            };
+            break;
+        case 'contains':
+            predFn = function (v1, v2) {
+                return stringContains(v1, v2, lqco);
+            };
+            break;
+        case 'in':
+            predFn = function (v1, v2) {
+                v1 = mc(v1);
+                v2 = v2.map(function (v) { return mc(v); });
+                return v2.indexOf(v1) >= 0;
+            };
+            break;
+        default:
+            return null;
+    }
+    return predFn;
+}
+function stringEquals(a, b, lqco) {
+    if (b == null)
+        return false;
+    if (typeof b !== 'string') {
+        b = b.toString();
+    }
+    if (lqco.usesSql92CompliantStringComparison) {
+        a = (a || "").trim();
+        b = (b || "").trim();
+    }
+    if (!lqco.isCaseSensitive) {
+        a = (a || "").toLowerCase();
+        b = (b || "").toLowerCase();
+    }
+    return a === b;
+}
+function stringStartsWith(a, b, lqco) {
+    if (!lqco.isCaseSensitive) {
+        a = (a || "").toLowerCase();
+        b = (b || "").toLowerCase();
+    }
+    return core.stringStartsWith(a, b);
+}
+function stringEndsWith(a, b, lqco) {
+    if (!lqco.isCaseSensitive) {
+        a = (a || "").toLowerCase();
+        b = (b || "").toLowerCase();
+    }
+    return core.stringEndsWith(a, b);
+}
+function stringContains(a, b, lqco) {
+    if (!lqco.isCaseSensitive) {
+        a = (a || "").toLowerCase();
+        b = (b || "").toLowerCase();
+    }
+    return a.indexOf(b) >= 0;
+}
+var ɵ8 = function () {
+    return this.value;
+}, ɵ9 = function (context) {
+    var predVal = this.pred.visit(context);
+    var json = {};
+    json[this.op.key] = predVal;
+    return json;
+}, ɵ10 = function (context) {
+    var expr1Val = this.expr1.visit(context);
+    var expr2Val = this.expr2.visit(context);
+    var json = {};
+    if (this.expr2 instanceof PropExpr) {
+        expr2Val = { value: expr2Val, isProperty: true };
+    }
+    if (this.op.key === "eq") {
+        json[expr1Val] = expr2Val;
+    }
+    else {
+        var value = {};
+        json[expr1Val] = value;
+        value[this.op.key] = expr2Val;
+    }
+    return json;
+}, ɵ11 = function (context) {
+    var predVals = this.preds.map(function (pred) {
+        return pred.visit(context);
+    });
+    if (!predVals || !predVals.length) {
+        return {};
+    }
+    var json;
+    // normalizeAnd clauses if possible.
+    // passthru predicate will appear as string and their 'ands' can't be 'normalized'
+    if (this.op.key === 'and' && predVals.length === 2 && !predVals.some(function (v) { return v.or || typeof (v) === 'string'; })) {
+        // normalize 'and' clauses - will return null if can't be combined.
+        json = predVals.reduce(combine);
+    }
+    if (json == null) {
+        json = {};
+        json[this.op.key] = predVals;
+    }
+    return json;
+}, ɵ12 = function (context) {
+    var exprVal = this.expr.visit(context);
+    var newContext = core.extend({}, context);
+    newContext.entityType = this.expr.dataType;
+    var predVal = this.pred.visit(newContext);
+    var json = {};
+    var value = {};
+    value[this.op.key] = predVal;
+    json[exprVal] = value;
+    return json;
+}, ɵ13 = function (context) {
+    if (this.hasExplicitDataType || context.useExplicitDataType) {
+        return { value: this.value, dataType: this.dataType.name };
+    }
+    else {
+        return this.value;
+    }
+}, ɵ14 = function (context) {
+    if (context.toNameOnServer) {
+        if (!context.entityType) {
+            console.warn("No EntityType for propertyPath \"" + this.propertyPath + "\".  " + core.strings.TO_TYPE);
+            return this.propertyPath;
+        }
+        return context.entityType.clientPropertyPathToServer(this.propertyPath);
+    }
+    else {
+        return this.propertyPath;
+    }
+}, ɵ15 = function (context) {
+    var exprVals = this.exprs.map(function (expr) {
+        return expr.visit(context);
+    });
+    return this.fnName + "(" + exprVals.join(",") + ")";
+};
+// toJSONVisitor
+var toJSONVisitor = {
+    passthruPredicate: ɵ8,
+    unaryPredicate: ɵ9,
+    binaryPredicate: ɵ10,
+    andOrPredicate: ɵ11,
+    anyAllPredicate: ɵ12,
+    litExpr: ɵ13,
+    propExpr: ɵ14,
+    fnExpr: ɵ15
+};
+function combine(j1, j2) {
+    var ok = Object.keys(j2).every(function (key) {
+        if (j1.hasOwnProperty(key)) {
+            if (typeof (j2[key]) !== 'object') {
+                // exit and indicate that we can't combine
+                return false;
+            }
+            if (combine(j1[key], j2[key]) == null) {
+                return false;
+            }
+        }
+        else if (typeof (j1) !== 'object') {
+            // cannot assign to j1[key]
+            return false;
+        }
+        else {
+            j1[key] = j2[key];
+        }
+        return true;
+    });
+    return ok ? j1 : null;
+}
+export { ɵ0, ɵ1, ɵ2, ɵ3, ɵ4, ɵ5, ɵ6, ɵ7, ɵ8, ɵ9, ɵ10, ɵ11, ɵ12, ɵ13, ɵ14, ɵ15 };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"predicate.js","sourceRoot":"ng://breeze-client/","sources":["src/predicate.ts"],"names":[],"mappings":"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","sourcesContent":["import { core } from './core';\r\nimport { EntityType, StructuralType, DataProperty  } from './entity-metadata';\r\nimport { QueryOp } from './entity-query';\r\nimport { DataType  } from './data-type';\r\nimport { EntityAspect, Entity } from './entity-aspect';\r\nimport { LocalQueryComparisonOptions } from './local-query-comparison-options';\r\n\r\nexport interface Op {\r\n  key: string;\r\n  aliases?: string[];\r\n  isFunction?: boolean;\r\n}\r\n\r\n/** @hidden @internal */\r\nexport interface OpMap {\r\n  [key: string]: Op;\r\n}\r\n\r\n/** For use by breeze plugin authors only. The class is for use in building a [[IUriBuilderAdapter]] implementation. \r\n@adapter (see [[IUriBuilderAdapter]])    \r\n@hidden \r\n*/\r\nexport interface Visitor {\r\n\r\n}\r\n\r\n/** For use by breeze plugin authors only. The class is for use in building a [[IUriBuilderAdapter]] implementation. \r\n@adapter (see [[IUriBuilderAdapter]])    \r\n@hidden \r\n*/\r\nexport interface VisitContext {\r\n  entityType?: EntityType;\r\n  // usesNameOnServer?: boolean;\r\n  toNameOnServer?: boolean;\r\n  useExplicitDataType?: boolean;\r\n  visitor?: Visitor;\r\n}\r\n\r\n/** For use by breeze plugin authors only. The class is for use in building a [[IUriBuilderAdapter]] implementation. \r\n@adapter (see [[IUriBuilderAdapter]])    \r\n@hidden \r\n*/\r\nexport interface ExpressionContext {\r\n  entityType?: EntityType;\r\n  usesNameOnServer?: boolean;\r\n  dataType?: DataType | string;\r\n  isRHS?: boolean;\r\n  isFnArg?: boolean;\r\n}\r\n\r\n/**\r\nUsed to define a 'where' predicate for an [[EntityQuery]].  Predicates are immutable, which means that any\r\nmethod that would modify a Predicate actually returns a new Predicate.\r\n**/\r\nexport class Predicate {\r\n  op: Op;\r\n  /** @hidden @internal */\r\n  _entityType?: EntityType;\r\n  /** @hidden @internal */\r\n  aliasMap: OpMap;\r\n  visitorMethodName: string;\r\n\r\n\r\n  /**\r\n  Predicate constructor\r\n  >     let p1 = new Predicate(\"CompanyName\", \"StartsWith\", \"B\");\r\n  >     let query = new EntityQuery(\"Customers\").where(p1);\r\n\r\n  or\r\n  >     let p2 = new Predicate(\"Region\", FilterQueryOp.Equals, null);\r\n  >     let query = new EntityQuery(\"Customers\").where(p2);\r\n  @param property - A property name, a nested property name or an expression involving a property name.\r\n  @param operator - \r\n  @param value - This will be treated as either a property expression or a literal depending on context.  In general,\r\n  if the value can be interpreted as a property expression it will be, otherwise it will be treated as a literal.\r\n  In most cases this works well, but you can also force the interpretation by making the value argument itself an object with a 'value'\r\n  property and an 'isLiteral' property set to either true or false.  Breeze also tries to infer the dataType of any\r\n  literal based on context, if this fails you can force this inference by making the value argument an object with a\r\n  'value' property and a 'dataType' property set to one of the breeze.DataType enumeration instances.\r\n  **/\r\n  constructor(...args: any[]) {\r\n    if (args.length === 0) return;\r\n    if (!(this instanceof Predicate)) {\r\n      return new Predicate(...<any>args);\r\n    }\r\n    return Predicate.create(...<any>args);\r\n  }\r\n\r\n  /**\r\n  Same as using the ctor.\r\n  >      // so \r\n  >      let p = Predicate.create(a, b, c);\r\n  >      // is the same as \r\n  >      let p = new Predicate(a, b, c); \r\n  @param property -  A property name, a nested property name or an expression involving a property name.\r\n  @param operator - the filter query operator.\r\n  @param value - This will be treated as either a property expression or a literal depending on context.  In general,\r\n  if the value can be interpreted as a property expression it will be, otherwise it will be treated as a literal.\r\n  In most cases this works well, but you can also force the interpretation by making the value argument itself an object with a 'value'\r\n  property and an 'isLiteral' property set to either true or false.  Breeze also tries to infer the dataType of any\r\n  literal based on context, if this fails you can force this inference by making the value argument an object with a\r\n  'value' property and a 'dataType' property set to one of the breeze.DataType enumeration instances.\r\n  **/\r\n  static create(...args: any[]) {\r\n    // can be called from std javascript without new ( legacy )\r\n\r\n    // empty ctor is used by all subclasses.\r\n    if (args.length === 0) return new Predicate();\r\n    if (args.length === 1) {\r\n      // possibilities:\r\n      //      Predicate([ aPredicate ]) or  Predicate([\"freight\", \">\", 100]) - an array\r\n      //      Predicate(aPredicate) - a predicate\r\n      //      Predicate( \"freight gt 100\" }  // passthru ( i.e. maybe an odata string) - a string\r\n      //      Predicate( { freight: { \">\": 100 } }) - an object\r\n      let arg = arguments[0];\r\n      if (Array.isArray(arg)) {\r\n        if (arg.length === 1) {\r\n          // recurse\r\n          return new Predicate(arg[0]);\r\n        } else {\r\n          return createPredicateFromArray(arg);\r\n        }\r\n      } else if (arg instanceof Predicate) {\r\n        return arg;\r\n      } else if (typeof arg === 'string') {\r\n        return new PassthruPredicate(arg);\r\n      } else {\r\n        return createPredicateFromObject(arg);\r\n      }\r\n    } else {\r\n      // 2 possibilities\r\n      //      Predicate(\"freight\", \">\", 100\");\r\n      //      Predicate(\"orders\", \"any\", \"freight\",  \">\", 950);\r\n      return createPredicateFromArray(args);\r\n    }\r\n  }\r\n\r\n  /** @hidden @internal */\r\n  _validate(entityType: EntityType | undefined, usesNameOnServer?: boolean) {\r\n    // noop here;\r\n  }\r\n\r\n  /**\r\n  Creates a 'composite' Predicate by 'and'ing a set of specified Predicates together.\r\n  >      let dt = new Date(88, 9, 12);\r\n  >      let p1 = Predicate.create(\"OrderDate\", \"ne\", dt);\r\n  >      let p2 = Predicate.create(\"ShipCity\", \"startsWith\", \"C\");\r\n  >      let p3 = Predicate.create(\"Freight\", \">\", 100);\r\n  >      let newPred = Predicate.and(p1, p2, p3);\r\n\r\n  or\r\n  >      let preds = [p1, p2, p3];\r\n  >      let newPred = Predicate.and(preds);\r\n  @param predicates - multiple Predicates or an array of Predicate. \r\n  Any null or undefined values passed in will be automatically filtered out before constructing the composite predicate.\r\n  **/\r\n  static and(...args: any[]) {\r\n    let pred = new AndOrPredicate(\"and\", args);\r\n    // TODO removed below\r\n    // return undefined if empty\r\n    // return pred.op && pred;\r\n    return pred;\r\n  }\r\n\r\n  /**\r\n  Creates a 'composite' Predicate by 'or'ing a set of specified Predicates together.\r\n  >      let dt = new Date(88, 9, 12);\r\n  >      let p1 = Predicate.create(\"OrderDate\", \"ne\", dt);\r\n  >      let p2 = Predicate.create(\"ShipCity\", \"startsWith\", \"C\");\r\n  >      let p3 = Predicate.create(\"Freight\", \">\", 100);\r\n  >      let newPred = Predicate.or(p1, p2, p3);\r\n\r\n  or\r\n  >      let preds = [p1, p2, p3];\r\n  >      let newPred = Predicate.or(preds);\r\n  @param predicates - multiple Predicates or an array of Predicate.\r\n  Any null or undefined values passed in will be automatically filtered out before constructing the composite predicate.\r\n  **/\r\n  static or(...args: any[]) {\r\n    let pred = new AndOrPredicate(\"or\", args);\r\n    // return pred.op && pred;\r\n    return pred;\r\n  }\r\n\r\n  /**\r\n  Creates a 'composite' Predicate by 'negating' a specified predicate.\r\n  >      let p1 = Predicate.create(\"Freight\", \"gt\", 100);\r\n  >      let not_p1 = Predicate.not(p1);\r\n\r\n  This can also be accomplished using the 'instance' version of the 'not' method\r\n  >      let not_p1 = p1.not();\r\n\r\n  Both of which would be the same as\r\n  >      let not_p1 = Predicate.create(\"Freight\", \"le\", 100);\r\n  **/\r\n  static not(pred: Predicate) {\r\n    return pred.not();\r\n  }\r\n\r\n  // TODO: determine if/where this is used.\r\n  // static extendBinaryPredicateFn(opMap: IOpMap, visitorFn: any) {\r\n  //   let baseVisitorFn = toFunctionVisitor.binaryPredicate;\r\n  //   for (let op in (opMap || {})) {\r\n  //     let config = opMap[op];\r\n  //     config.visitorFn = visitorFn;\r\n  //     updateAliasMap(BinaryPredicate.prototype.aliasMap, op, opMap[op]);\r\n  //   }\r\n  //   if (!toFunctionVisitor.isExtended) {\r\n  //     toFunctionVisitor.binaryPredicate = function (context, expr1Val, expr2Val) {\r\n  //       let visitorFn = this.aliasMap[this.op.key].visitorFn;\r\n  //       if (visitorFn) {\r\n  //         return visitorFn(context, expr1Val, expr2Val);\r\n  //       } else {\r\n  //         return baseVisitorFn(context, expr1Val, expr2Val);\r\n  //       }\r\n  //     };\r\n  //     toFunctionVisitor.isExtended = true;\r\n  //   }\r\n  // };\r\n\r\n  static extendFuncMap (funcMap: {[key: string]: {fn: (...args: any[]) => any, dataType: DataType}}): void {\r\n    for (let func in (funcMap || {})) {\r\n      let config = funcMap[func];\r\n      FnExpr._funcMap[func] = config;\r\n    }\r\n  };\r\n\r\n  /**\r\n  'And's this Predicate with one or more other Predicates and returns a new 'composite' Predicate\r\n  >      let dt = new Date(88, 9, 12);\r\n  >      let p1 = Predicate.create(\"OrderDate\", \"ne\", dt);\r\n  >      let p2 = Predicate.create(\"ShipCity\", \"startsWith\", \"C\");\r\n  >      let p3 = Predicate.create(\"Freight\", \">\", 100);\r\n  >      let newPred = p1.and(p2, p3);\r\n\r\n  or\r\n  >      let preds = [p2, p3];\r\n  >      let newPred = p1.and(preds);\r\n\r\n  The 'and' method is also used to write \"fluent\" expressions\r\n  >      let p4 = Predicate.create(\"ShipCity\", \"startswith\", \"F\")\r\n  >        .and(\"Size\", \"gt\", 2000);\r\n  @param predicates - multiple Predicates or an array of Predicates. \r\n  Any null or undefined values passed in will be automatically filtered out before constructing the composite predicate.\r\n  **/\r\n  and(...args: any[]) {\r\n    return new AndOrPredicate(\"and\", argsForAndOrPredicates(this, args));\r\n  }\r\n\r\n  /**\r\n  'Or's this Predicate with one or more other Predicates and returns a new 'composite' Predicate\r\n  >      let dt = new Date(88, 9, 12);\r\n  >      let p1 = Predicate.create(\"OrderDate\", \"ne\", dt);\r\n  >      let p2 = Predicate.create(\"ShipCity\", \"startsWith\", \"C\");\r\n  >      let p3 = Predicate.create(\"Freight\", \">\", 100);\r\n  >      let newPred = p1.or(p2, p3);\r\n\r\n  or\r\n  >      let preds = [p2, p3];\r\n  >      let newPred = p1.or(preds);\r\n\r\n  The 'or' method is also used to write \"fluent\" expressions\r\n  >      let p4 = Predicate.create(\"ShipCity\", \"startswith\", \"F\")\r\n  >        .or(\"Size\", \"gt\", 2000);\r\n  @param predicates - multiple Predicates or an array of Predicates. \r\n  Any null or undefined values passed in will be automatically filtered out before constructing the composite predicate.\r\n  **/\r\n  or(...args: any[]) {\r\n    return new AndOrPredicate(\"or\", argsForAndOrPredicates(this, args));\r\n  }\r\n\r\n  /**\r\n  Returns the 'negated' version of this Predicate\r\n  >      let p1 = Predicate.create(\"Freight\", \"gt\", 100);\r\n  >      let not_p1 = p1.not();\r\n\r\n  This can also be accomplished using the 'static' version of the 'not' method\r\n  >      let p1 = Predicate.create(\"Freight\", \"gt\", 100);\r\n  >      let not_p1 = Predicate.not(p1);\r\n\r\n  which would be the same as\r\n  >      let not_p1 = Predicate.create(\"Freight\", \"le\", 100);\r\n  **/\r\n  not() {\r\n    return new UnaryPredicate(\"not\", this);\r\n  }\r\n\r\n  //\r\n  toJSON() {\r\n    // toJSON ( part of js standard - takes a single parameter\r\n    // that is either \"\" or the name of the property being serialized.\r\n    return this.toJSONExt({ entityType: this._entityType });\r\n  }\r\n\r\n  /** For use by breeze plugin authors only. The class is for use in building a [[IUriBuilderAdapter]] implementation. \r\n  @adapter (see [[IUriBuilderAdapter]])    \r\n  @hidden @internal \r\n  */\r\n  toJSONExt(context: VisitContext) {\r\n    return this.visit(context, toJSONVisitor);\r\n  }\r\n\r\n  /** For use by breeze plugin authors only. The class is for use in building a [[IUriBuilderAdapter]] implementation. \r\n  @adapter (see [[IUriBuilderAdapter]])    \r\n  @hidden @internal \r\n  */\r\n  toFunction(context: VisitContext) {\r\n    return this.visit(context, toFunctionVisitor);\r\n  }\r\n\r\n  toString() {\r\n    return JSON.stringify(this);\r\n  }\r\n\r\n  /** For use by breeze plugin authors only. The class is for use in building a [[IUriBuilderAdapter]] implementation. \r\n  @adapter (see [[IUriBuilderAdapter]])    \r\n  @hidden @internal \r\n  */\r\n  visit(context: VisitContext, visitor?: Visitor) {\r\n    if (core.isEmpty(context)) {\r\n      context = { entityType: undefined };\r\n    } else if (context instanceof EntityType) {\r\n      context = { entityType: context };\r\n    } else if (!core.hasOwnProperty(context, \"entityType\")) {\r\n      throw new Error(\"All visitor methods must be called with a context object containing at least an 'entityType' property\");\r\n    }\r\n\r\n    if (visitor) {\r\n      context.visitor = visitor;\r\n    }\r\n    let tVisitor = visitor || context.visitor!;\r\n    let fn = tVisitor[this.visitorMethodName];\r\n    if (fn == null) {\r\n      throw new Error(\"Unable to locate method: \" + this.visitorMethodName + \" on visitor\");\r\n    }\r\n\r\n    let entityType = context.entityType;\r\n    // don't bother validating if already done so ( or if no _validate method\r\n    if (this._validate && (entityType == null || this._entityType !== entityType)) {\r\n      // don't need to capture return value because validation fn doesn't have one.\r\n      // TODO: this was old code\r\n      // this._validate(entityType, context.usesNameOnServer);\r\n      this._validate(entityType, context.toNameOnServer);\r\n      this._entityType = entityType;\r\n    }\r\n\r\n    return fn.call(this, context);\r\n  }\r\n\r\n  /** @hidden @internal */\r\n  _initialize(visitorMethodName: string, opMap: { [key: string]: { aliases?: string[], isFunction?: boolean }} = {}) {\r\n    this.visitorMethodName = visitorMethodName;\r\n    let aliasMap = this.aliasMap = {};\r\n    for (let op in opMap ) {\r\n      updateAliasMap(aliasMap, op, opMap[op] as Op);\r\n    }\r\n  }\r\n\r\n  /** @hidden @internal */\r\n  _resolveOp(op: string | QueryOp, okIfNotFound?: boolean) {\r\n    let opStr = (typeof op === \"string\") ? op : op.operator;\r\n    let result = this.aliasMap[opStr.toLowerCase()];\r\n    if (!result && !okIfNotFound) {\r\n      throw new Error(\"Unable to resolve operator: \" + opStr);\r\n    }\r\n    return result;\r\n  }\r\n\r\n}\r\n\r\nfunction createPredicateFromArray(arr: any[]) {\r\n  // TODO: assert that length of the array should be > 3\r\n  // Needs to handle:\r\n  //      [ \"freight\", \">\", 100\"];\r\n  //      [ \"orders\", \"any\", \"freight\",  \">\", 950 ]\r\n  //      [ \"orders\", \"and\", anotherPred ]\r\n  //      [ \"orders\", \"and\", [ \"freight, \">\", 950 ]]\r\n  let json = {};\r\n  let value = {};\r\n  json[arr[0]] = value;\r\n  let op = arr[1];\r\n  op = op.operator || op;  // incoming op will be either a string or a FilterQueryOp\r\n  if (arr.length === 3) {\r\n    value[op] = arr[2];\r\n  } else {\r\n    value[op] = createPredicateFromArray(arr.splice(2));\r\n  }\r\n  return createPredicateFromObject(json);\r\n}\r\n\r\nfunction createPredicateFromObject(obj: Object) {\r\n  if (obj instanceof Predicate) return obj;\r\n\r\n  if (typeof obj !== 'object') {\r\n    throw new Error(\"Unable to convert to a Predicate: \" + obj);\r\n  }\r\n  let keys = Object.keys(obj);\r\n  let preds = keys.map(function (key) {\r\n    return createPredicateFromKeyValue(key, obj[key]);\r\n  });\r\n  return (preds.length === 1) ? preds[0] : new AndOrPredicate(\"and\", preds);\r\n}\r\n\r\nfunction createPredicateFromKeyValue(key: string, value: any): Predicate {\r\n  // { and: [a,b] } key='and', value = [a,b]\r\n  if (AndOrPredicate.prototype._resolveOp(key, true)) {\r\n    return new AndOrPredicate(key, value);\r\n  }\r\n\r\n  // { not: a }  key= 'not', value = a\r\n  if (UnaryPredicate.prototype._resolveOp(key, true)) {\r\n    return new UnaryPredicate(key, value);\r\n  }\r\n\r\n  if ((typeof value !== 'object') || value == null || core.isDate(value)) {\r\n    // { foo: bar } key='foo', value = bar ( where bar is a literal i.e. a string, a number, a boolean or a date.\r\n    return new BinaryPredicate(\"eq\", key, value);\r\n  } else if (core.hasOwnProperty(value, 'value')) {\r\n    // { foo: { value: bar, dataType: xxx} } key='foo', value = bar ( where bar is an object representing a literal\r\n    return new BinaryPredicate(\"eq\", key, value);\r\n  }\r\n\r\n  if (Array.isArray(value)) {\r\n    throw new Error(\"Unable to resolve predicate after the phrase: \" + key);\r\n  }\r\n\r\n  let expr = key;\r\n  let keys = Object.keys(value);\r\n  let preds = keys.map(function (op) {\r\n\r\n    // { a: { any: b } op = 'any', expr=a, value[op] = b\r\n    if (AnyAllPredicate.prototype._resolveOp(op, true)) {\r\n      return new AnyAllPredicate(op, expr, value[op]);\r\n    }\r\n\r\n    if (BinaryPredicate.prototype._resolveOp(op, true)) {\r\n      // { a: { \">\": b }} op = \">\", expr=a, value[op] = b\r\n      return new BinaryPredicate(op, expr, value[op]);\r\n    } else if (core.hasOwnProperty(value[op], 'value')) {\r\n      // { a: { \">\": { value: b, dataType: 'Int32' }} expr = a value[op] = { value: b, dataType: 'Int32' }\r\n      return new BinaryPredicate(\"eq\", expr, value[op]);\r\n    }\r\n\r\n    let msg = core.formatString(\"Unable to resolve predicate after the phrase: '%1' for operator: '%2'  and value: '%3'\", expr, op, value[op]);\r\n    throw new Error(msg);\r\n\r\n  });\r\n\r\n  return (preds.length === 1) ? preds[0] : new AndOrPredicate(\"and\", preds);\r\n}\r\n\r\nfunction argsForAndOrPredicates(obj: {}, args: any[]) {\r\n  let preds = args[0];\r\n  if (preds instanceof Predicate) {\r\n    preds = core.arraySlice(args);\r\n  } else if (!Array.isArray(preds)) {\r\n    preds = [new Predicate(core.arraySlice(args))];\r\n  }\r\n  return [obj].concat(preds);\r\n}\r\n\r\nfunction updateAliasMap(aliasMap: OpMap, opStr: string, op: Op) {\r\n  let key = opStr.toLowerCase();\r\n  op.key = key;\r\n  aliasMap[key] = op;\r\n\r\n  op.aliases && op.aliases.forEach((alias: any) => {\r\n    aliasMap[alias.toLowerCase()] = op;\r\n  });\r\n}\r\n\r\n/** For use by breeze plugin authors only. The class is for use in building a [[IUriBuilderAdapter]] implementation. \r\n@adapter (see [[IUriBuilderAdapter]])    \r\n@hidden @internal \r\n*/\r\nclass PassthruPredicate extends Predicate {\r\n  value: any;\r\n  constructor(value: any) {\r\n    super();\r\n    this.value = value;\r\n  }\r\n\r\n  // _validate = core.noop;\r\n}\r\nError['x'] = PassthruPredicate.prototype._initialize('passthruPredicate');\r\n\r\n/** For use by breeze plugin authors only. The class is for use in building a [[IUriBuilderAdapter]] implementation. \r\n@adapter (see [[IUriBuilderAdapter]])    \r\n@hidden \r\n*/\r\nexport class UnaryPredicate extends Predicate {\r\n  op: Op;\r\n  pred: Predicate;\r\n  constructor(op: string | QueryOp, ...args: any[]) {\r\n    super();\r\n    this.op = this._resolveOp(op);\r\n    this.pred = new Predicate(args);\r\n  }\r\n\r\n  _validate(entityType: EntityType, usesNameOnServer?: boolean) {\r\n    this.pred._validate(entityType, usesNameOnServer);\r\n  }\r\n}\r\n\r\nError['x'] = UnaryPredicate.prototype._initialize('unaryPredicate', {\r\n  'not': { aliases: ['!', '~'] },\r\n});\r\n\r\n/** For use by breeze plugin authors only. The class is for use in building a [[IUriBuilderAdapter]] implementation. \r\n@adapter (see [[IUriBuilderAdapter]])    \r\n@hidden \r\n*/\r\nexport class BinaryPredicate extends Predicate {\r\n  op: Op;\r\n  expr1Source: any;\r\n  expr2Source: any;\r\n  expr1?: PredicateExpression;\r\n  expr2?: PredicateExpression;\r\n  constructor(op: string | QueryOp, expr1: any, expr2: any) {\r\n    super();\r\n    // 5 public props op, expr1Source, expr2Source, expr1, expr2\r\n    this.op = this._resolveOp(op);\r\n    this.expr1Source = expr1;\r\n    this.expr2Source = expr2;\r\n    // this.expr1 and this.expr2 won't be\r\n    // determined until validate is run\r\n  }\r\n\r\n\r\n  _validate(entityType: EntityType, usesNameOnServer?: boolean) {\r\n    let expr1Context = { entityType: entityType, usesNameOnServer: usesNameOnServer };\r\n    this.expr1 = createExpr(this.expr1Source, expr1Context);\r\n    if (this.expr1 == null) {\r\n      throw new Error(\"Unable to validate 1st expression: \" + this.expr1Source);\r\n    }\r\n    if (this.expr1 instanceof LitExpr) {\r\n      // lhs must be either a property or a function.\r\n      throw new Error(\"The left hand side of a binary predicate cannot be a literal expression, it must be a valid property or functional predicate expression: \" + this.expr1Source);\r\n    }\r\n\r\n    if (this.op.key === 'in' && !Array.isArray(this.expr2Source)) {\r\n      throw new Error(\"The 'in' operator requires that its right hand argument be an array\");\r\n    }\r\n    let expr2Context = core.extend(expr1Context, { isRHS: true, dataType: this.expr1.dataType });\r\n    this.expr2 = createExpr(this.expr2Source, expr2Context);\r\n    if (this.expr2 == null) {\r\n      throw new Error(\"Unable to validate 2nd expression: \" + this.expr2Source);\r\n    }\r\n\r\n    if (this.expr1.dataType == null) {\r\n      this.expr1.dataType = this.expr2.dataType;\r\n    }\r\n  }\r\n\r\n\r\n}\r\n\r\nError['x'] = BinaryPredicate.prototype._initialize('binaryPredicate', {\r\n  'eq': {\r\n    aliases: [\"==\", \"equals\"]\r\n  },\r\n  'ne': {\r\n    aliases: [\"!=\", \"~=\", \"notequals\"]\r\n  },\r\n  'lt': {\r\n    aliases: [\"<\", \"lessthan\"]\r\n  },\r\n  'le': {\r\n    aliases: [\"<=\", \"lessthanorequal\"]\r\n  },\r\n  'gt': {\r\n    aliases: [\">\", \"greaterthan\"]\r\n  },\r\n  'ge': {\r\n    aliases: [\">=\", \"greaterthanorequal\"]\r\n  },\r\n  'startswith': {\r\n    isFunction: true\r\n  },\r\n  'endswith': {\r\n    isFunction: true\r\n  },\r\n  'contains': {\r\n    aliases: [\"substringof\"],\r\n    isFunction: true\r\n  },\r\n  'in': {\r\n\r\n  }\r\n});\r\n\r\n/** For use by breeze plugin authors only. The class is for use in building a [[IUriBuilderAdapter]] implementation. \r\n@adapter (see [[IUriBuilderAdapter]])    \r\n@hidden\r\n*/\r\nexport class AndOrPredicate extends Predicate {\r\n  op: Op;\r\n  preds: Predicate[];\r\n  constructor(op: string | QueryOp, preds: any[]) {\r\n    super();\r\n    this.op = this._resolveOp(op);\r\n    if (preds.length === 1 && Array.isArray(preds[0])) {\r\n      preds = preds[0];\r\n    }\r\n    this.preds = preds.filter(function (pred) {\r\n      return pred != null;\r\n    }).map(function (pred) {\r\n      return new Predicate(pred);\r\n    });\r\n    // TODO: this was removed - test if really needed.\r\n    // if (this.preds.length === 0) {\r\n    //   // marker for an empty predicate\r\n    //   this.op = null;\r\n    // }\r\n    if (this.preds.length === 1) {\r\n      return this.preds[0] as AndOrPredicate; // HACK: this.preds[0] is actually NOT a AndOrPredicate but some other kind of pred.\r\n    }\r\n  }\r\n\r\n  _validate(entityType: EntityType, usesNameOnServer?: boolean) {\r\n    this.preds.forEach((pred) => {\r\n      pred._validate(entityType, usesNameOnServer);\r\n    });\r\n  }\r\n}\r\n\r\nError['x'] = AndOrPredicate.prototype._initialize(\"andOrPredicate\", {\r\n  'and': { aliases: ['&&'] },\r\n  'or': { aliases: ['||'] }\r\n} );\r\n\r\n/** For use by breeze plugin authors only. The class is for use in building a [[IUriBuilderAdapter]] implementation. \r\n@adapter (see [[IUriBuilderAdapter]])    \r\n@hidden \r\n*/\r\nexport class AnyAllPredicate extends Predicate {\r\n  op: Op;\r\n  /** @internal */\r\n  expr: PredicateExpression;\r\n  exprSource: string;\r\n  pred: Predicate;\r\n  // 4 public props: op, exprSource, expr, pred\r\n  constructor(op: string | QueryOp, expr: string, pred: any) {\r\n    super();\r\n    this.op = this._resolveOp(op);\r\n    this.exprSource = expr;\r\n    // this.expr will not be resolved until validate is called\r\n    this.pred = new Predicate(pred);\r\n  }\r\n\r\n  _validate(entityType: EntityType, usesNameOnServer: boolean) {\r\n    this.expr = createExpr(this.exprSource, { entityType: entityType, usesNameOnServer: usesNameOnServer } as ExpressionContext);\r\n    // can't really know the predicateEntityType unless the original entity type was known.\r\n    if (entityType == null || entityType.isAnonymous) {\r\n      this.expr.dataType = undefined;\r\n    }\r\n    this.pred._validate(this.expr.dataType as EntityType | undefined, usesNameOnServer);\r\n  }\r\n\r\n}\r\n\r\nError['x'] = AnyAllPredicate.prototype._initialize(\"anyAllPredicate\", {\r\n  'any': { aliases: ['some'] },\r\n  'all': { aliases: [\"every\"] }\r\n});\r\n\r\n/** @hidden */\r\nexport class PredicateExpression {\r\n  visitorMethodName: string;\r\n  visit: Function; // TODO\r\n  dataType?: DataType | StructuralType;\r\n  constructor(visitorMethodName: string) {\r\n    this.visitorMethodName = visitorMethodName;\r\n    // give expressions the Predicate prototype method\r\n    this.visit = Predicate.prototype.visit;\r\n  }\r\n\r\n  // default impls - may/will be overridden be subclass expressions\r\n  _validate(entityType: EntityType | undefined, usesNameOnServer?: boolean) {\r\n    // noop;\r\n  }\r\n}\r\n\r\n/** For use by breeze plugin authors only. The class is for use in building a [[IUriBuilderAdapter]] implementation. \r\n@adapter (see [[IUriBuilderAdapter]])    \r\n@hidden \r\n*/\r\nexport class LitExpr extends PredicateExpression {\r\n  value: any;\r\n  dataType: DataType;\r\n  hasExplicitDataType: boolean;\r\n  // 2 public props: value, dataType\r\n  constructor(value: any, dataType: string | DataType | undefined, hasExplicitDataType?: boolean) {\r\n    super(\"litExpr\");\r\n    // dataType may come is an a string\r\n    let dt1 = resolveDataType(dataType);\r\n    // if the DataType comes in as Undefined this means\r\n    // that we should NOT attempt to parse it but just leave it alone\r\n    // for now - this is usually because it is part of a Func expr.\r\n    // TODO: cast as DataType seems to be needed by early version of TypeDoc - may be able to remove later\r\n    let dt2 = (dt1 || DataType.fromValue(value)) as DataType;\r\n\r\n    if (dt2.parse) {\r\n      if (Array.isArray(value)) {\r\n        this.value = value.map((v) => { return dt2.parse!(v, typeof v); });\r\n      } else {\r\n        this.value = dt2.parse(value, typeof value);\r\n      }\r\n    } else {\r\n      this.value = value;\r\n    }\r\n    this.dataType = dt2;\r\n    this.hasExplicitDataType = !!hasExplicitDataType;\r\n  }\r\n\r\n  toString() {\r\n    return \" LitExpr - value: \" + this.value.toString() + \" dataType: \" + this.dataType.toString();\r\n  }\r\n\r\n}\r\n\r\nfunction resolveDataType(dataType?: DataType | string) {\r\n  if (dataType == null) return dataType;\r\n  // if (DataType.contains(dataType)) {\r\n  if (dataType instanceof DataType) {\r\n    return dataType;\r\n  }\r\n  if (typeof dataType === 'string') {\r\n    let dt = DataType.fromName(dataType) as DataType;\r\n    if (dt) return dt;\r\n    throw new Error(\"Unable to resolve a dataType named: \" + dataType);\r\n  }\r\n\r\n  throw new Error(\"The dataType parameter passed into this literal expression is not a 'DataType'\" + dataType);\r\n}\r\n\r\n/** For use by breeze plugin authors only. The class is for use in building a [[IUriBuilderAdapter]] implementation. \r\n@adapter (see [[IUriBuilderAdapter]])    \r\n@hidden \r\n*/\r\nexport class PropExpr extends PredicateExpression {\r\n  propertyPath: string;\r\n  dataType: DataType | StructuralType;\r\n  // two public props: propertyPath, dateType\r\n  constructor(propertyPath: string) {\r\n    super('propExpr');\r\n    this.propertyPath = propertyPath;\r\n    //this.dataType = DataType.Undefined;\r\n    // this.dataType resolved after validate ( if not on an anon type }\r\n  }\r\n\r\n  toString() {\r\n    return \" PropExpr - \" + this.propertyPath;\r\n  }\r\n\r\n  _validate(entityType: EntityType | undefined, usesNameOnServer?: boolean) {\r\n\r\n    if (entityType == null || entityType.isAnonymous) return;\r\n    let props = entityType.getPropertiesOnPath(this.propertyPath, null, false);\r\n\r\n    if (!props) {\r\n      let msg = core.formatString(\"Unable to resolve propertyPath.  EntityType: '%1'   PropertyPath: '%2'\", entityType.name, this.propertyPath);\r\n      throw new Error(msg);\r\n    }\r\n    // get the last property\r\n    let prop = props[props.length - 1];\r\n    if (prop instanceof DataProperty) {\r\n      this.dataType = prop.dataType;\r\n    } else {\r\n      this.dataType = prop.entityType;\r\n    }\r\n  }\r\n\r\n}\r\n\r\n/** For use by breeze plugin authors only. The class is for use in building a [[IUriBuilderAdapter]] implementation. \r\n@adapter (see [[IUriBuilderAdapter]])    \r\n@hidden @dynamic\r\n*/\r\nexport class FnExpr extends PredicateExpression {\r\n  fnName: string;\r\n  exprs: PredicateExpression[];\r\n  localFn: any; // TODO:\r\n  dataType: DataType;\r\n  constructor(fnName: string, exprs: PredicateExpression[]) {\r\n    super('fnExpr');\r\n    // 4 public props: fnName, exprs, localFn, dataType\r\n    this.fnName = fnName;\r\n    this.exprs = exprs;\r\n    let qf = FnExpr._funcMap[fnName];\r\n    if (qf == null) {\r\n      throw new Error(\"Unknown function: \" + fnName);\r\n    }\r\n    this.localFn = qf.fn;\r\n    this.dataType = qf.dataType;\r\n  }\r\n\r\n  toString() {\r\n    let exprStr = this.exprs.map(function (expr) {\r\n      expr.toString();\r\n    }).toString();\r\n    return \"FnExpr - \" + this.fnName + \"(\" + exprStr + \")\";\r\n  }\r\n\r\n  _validate(entityType: EntityType | undefined, usesNameOnServer?: boolean) {\r\n    this.exprs.forEach(function (expr) {\r\n      expr._validate(entityType, usesNameOnServer);\r\n    });\r\n  }\r\n\r\n  static _funcMap = {\r\n    toupper: {\r\n      fn: function (source: string) {\r\n        return source.toUpperCase();\r\n      }, dataType: DataType.String\r\n    },\r\n    tolower: {\r\n      fn: function (source: string) {\r\n        return source.toLowerCase();\r\n      }, dataType: DataType.String\r\n    },\r\n    substring: {\r\n      fn: function (source: string, pos: number, length: number) {\r\n        return source.substring(pos, length);\r\n      }, dataType: DataType.String\r\n    },\r\n    substringof: {\r\n      fn: function (find: string, source: string) {\r\n        return source.indexOf(find) >= 0;\r\n      }, dataType: DataType.Boolean\r\n    },\r\n    length: {\r\n      fn: function (source: any) {\r\n        return source.length;\r\n      }, dataType: DataType.Int32\r\n    },\r\n    trim: {\r\n      fn: function (source: string) {\r\n        return source.trim();\r\n      }, dataType: DataType.String\r\n    },\r\n    concat: {\r\n      fn: function (s1: string, s2: string) {\r\n        return s1.concat(s2);\r\n      }, dataType: DataType.String\r\n    },\r\n    replace: {\r\n      fn: function (source: string, find: string, replace: string) {\r\n        return source.replace(find, replace);\r\n      }, dataType: DataType.String\r\n    },\r\n    startswith: {\r\n      fn: function (source: string, find: string) {\r\n        return core.stringStartsWith(source, find);\r\n      }, dataType: DataType.Boolean\r\n    },\r\n    endswith: {\r\n      fn: function (source: string, find: string) {\r\n        return core.stringEndsWith(source, find);\r\n      }, dataType: DataType.Boolean\r\n    },\r\n    indexof: {\r\n      fn: function (source: any, find: any) {\r\n        return source.indexOf(find);\r\n      }, dataType: DataType.Int32\r\n    },\r\n    round: {\r\n      fn: function (source: number) {\r\n        return Math.round(source);\r\n      }, dataType: DataType.Int32\r\n    },\r\n    ceiling: {\r\n      fn: function (source: number) {\r\n        return Math.ceil(source);\r\n      }, dataType: DataType.Int32\r\n    },\r\n    floor: {\r\n      fn: function (source: number) {\r\n        return Math.floor(source);\r\n      }, dataType: DataType.Int32\r\n    },\r\n    second: {\r\n      fn: function (source: Date) {\r\n        return source.getSeconds();\r\n      }, dataType: DataType.Int32\r\n    },\r\n    minute: {\r\n      fn: function (source: Date) {\r\n        return source.getMinutes();\r\n      }, dataType: DataType.Int32\r\n    },\r\n    day: {\r\n      fn: function (source: Date) {\r\n        return source.getDate();\r\n      }, dataType: DataType.Int32\r\n    },\r\n    month: {\r\n      fn: function (source: Date) {\r\n        return source.getMonth() + 1;\r\n      }, dataType: DataType.Int32\r\n    },\r\n    year: {\r\n      fn: function (source: Date) {\r\n        return source.getFullYear();\r\n      }, dataType: DataType.Int32\r\n    }\r\n  };\r\n\r\n}\r\n\r\n// TODO: add dataTypes for the args next - will help to infer other dataTypes.\r\n\r\n\r\nlet RX_IDENTIFIER = /^[a-z_][\\w.$]*$/i;\r\n// comma delimited expressions ignoring commas inside of both single and double quotes.\r\nlet RX_COMMA_DELIM1 = /('[^']*'|[^,]+)/g;\r\nlet RX_COMMA_DELIM2 = /(\"[^\"]*\"|[^,]+)/g;\r\nlet DELIM = String.fromCharCode(191);\r\n\r\nfunction createExpr(source: any, exprContext: ExpressionContext) {\r\n  let entityType = exprContext.entityType;\r\n\r\n  // the right hand side of an 'in' clause\r\n  if (Array.isArray(source)) {\r\n    if (!exprContext.isRHS) {\r\n      throw new Error(\"Array expressions are only permitted on the right hand side of a BinaryPredicate\");\r\n    }\r\n    return new LitExpr(source, exprContext.dataType!);\r\n  }\r\n\r\n  if (!(typeof source === 'string')) {\r\n    if (source != null && typeof source === 'object' && !source.toISOString) {\r\n      // source is an object but not a Date-like thing such as a JS or MomentJS Date\r\n      if (source.value === undefined) {\r\n        throw new Error(\"Unable to resolve an expression for: \" + source + \" on entityType: \" + (entityType ? entityType.name : 'null'));\r\n      }\r\n      if (source.isProperty) {\r\n        return new PropExpr(source.value);\r\n      } else {\r\n        // we want to insure that any LitExpr created this way is tagged with 'hasExplicitDataType: true'\r\n        // because we want to insure that if we roundtrip thru toJSON that we don't\r\n        // accidentally reinterpret this node as a PropExpr.\r\n        // return new LitExpr(source.value, source.dataType || context.dataType, !!source.dataType);\r\n        return new LitExpr(source.value, source.dataType || exprContext.dataType, true);\r\n      }\r\n    } else {\r\n      return new LitExpr(source, exprContext.dataType);\r\n    }\r\n  }\r\n\r\n  if (exprContext.isRHS) {\r\n    if (entityType == null || entityType.isAnonymous) {\r\n      // if entityType is unknown then assume that the rhs is a literal\r\n      return new LitExpr(source, exprContext.dataType);\r\n    } else {\r\n      return parseLitOrPropExpr(source, exprContext);\r\n    }\r\n  } else {\r\n    let regex = /\\([^()]*\\)/;\r\n    let m: RegExpExecArray | null;\r\n    let tokens: string[] = [];\r\n    let i = 0;\r\n    while (m = regex.exec(source)) {\r\n      let token = m[0];\r\n      tokens.push(token);\r\n      let repl = DELIM + i++;\r\n      source = source.replace(token, repl);\r\n    }\r\n\r\n    let expr = parseExpr(source, tokens, exprContext);\r\n    expr._validate(entityType, exprContext.usesNameOnServer);\r\n    return expr;\r\n  }\r\n}\r\n\r\nfunction parseExpr(source: string, tokens: string[], exprContext: ExpressionContext): PredicateExpression {\r\n  let parts = source.split(DELIM);\r\n  if (parts.length === 1) {\r\n    return parseLitOrPropExpr(parts[0], exprContext);\r\n  } else {\r\n    return parseFnExpr(source, parts, tokens, exprContext);\r\n  }\r\n}\r\n\r\nfunction parseLitOrPropExpr(value: string, exprContext: ExpressionContext): PredicateExpression {\r\n  value = value.trim();\r\n  // value is either a string, a quoted string, a number, a bool value, or a date\r\n  // if a string ( not a quoted string) then this represents a property name ( 1st ) or a lit string ( 2nd)\r\n  let firstChar = value.substr(0, 1);\r\n  let isQuoted = (firstChar === \"'\" || firstChar === '\"') && value.length > 1 && value.substr(value.length - 1) === firstChar;\r\n  if (isQuoted) {\r\n    let unquotedValue = value.substr(1, value.length - 2);\r\n    return new LitExpr(unquotedValue, exprContext.dataType || DataType.String);\r\n  } else {\r\n    let entityType = exprContext.entityType;\r\n    // TODO: get rid of isAnonymous below when we get the chance.\r\n    if (entityType == null || entityType.isAnonymous) {\r\n      // this fork will only be reached on the LHS of an BinaryPredicate -\r\n      // a RHS expr cannot get here with an anon type\r\n      return new PropExpr(value);\r\n    } else {\r\n      let mayBeIdentifier = RX_IDENTIFIER.test(value);\r\n      if (mayBeIdentifier) {\r\n        // if (entityType.getProperty(value, false) != null) {\r\n        if (entityType.getPropertiesOnPath(value, null, false) != null) {\r\n          return new PropExpr(value);\r\n        }\r\n      }\r\n    }\r\n    // we don't really know the datatype here because even though it comes in as a string\r\n    // its usually a string BUT it might be a number  i.e. the \"1\" or the \"2\" from an expr\r\n    // like \"toUpper(substring(companyName, 1, 2))\"\r\n    return new LitExpr(value, exprContext.dataType);\r\n  }\r\n}\r\n\r\nfunction parseFnExpr(source: string, parts: string[], tokens: string[], exprContext: ExpressionContext) {\r\n  try {\r\n    let fnName = parts[0].trim().toLowerCase();\r\n\r\n    let argSource = tokens[parts[1]].trim() as string;\r\n    if (argSource.substr(0, 1) === \"(\") {\r\n      argSource = argSource.substr(1, argSource.length - 2);\r\n    }\r\n    let commaMatchStr = source.indexOf(\"'\") >= 0 ? RX_COMMA_DELIM1 : RX_COMMA_DELIM2;\r\n    let args = argSource.match(commaMatchStr);\r\n    let newContext = core.extend({}, exprContext) as ExpressionContext;\r\n    // a dataType of Undefined on a context basically means not to try parsing\r\n    // the value if the expr is a literal\r\n    newContext.dataType = DataType.Undefined;\r\n    newContext.isFnArg = true;\r\n    let exprs = args!.map(function (a) {\r\n      return parseExpr(a, tokens, newContext);\r\n    });\r\n    return new FnExpr(fnName, exprs);\r\n  } catch (e) {\r\n    // TODO: removed old code here\r\n    // return null;\r\n    // and replaced with \r\n    throw e;\r\n  }\r\n}\r\n\r\n// toFunctionVisitor\r\n\r\nlet toFunctionVisitor = {\r\n\r\n  isExtended: false,\r\n\r\n  passthruPredicate: function (this: PassthruPredicate) {\r\n    throw new Error(\"Cannot execute an PassthruPredicate expression against the local cache: \" + this.value);\r\n  },\r\n\r\n  unaryPredicate: function (this: UnaryPredicate, context: VisitContext) {\r\n    let predFn = this.pred.visit(context);\r\n    switch (this.op.key) {\r\n      case \"not\":\r\n        return function (entity: any) {\r\n          return !predFn(entity);\r\n        };\r\n      default:\r\n        throw new Error(\"Invalid unary operator:\" + this.op.key);\r\n    }\r\n  },\r\n\r\n  binaryPredicate: function (this: BinaryPredicate, context: VisitContext) {\r\n    let expr1Fn = this.expr1!.visit(context);\r\n    let expr2Fn = this.expr2!.visit(context);\r\n    let dataType = this.expr1!.dataType || this.expr2!.dataType;\r\n    let lqco = context.entityType!.metadataStore.localQueryComparisonOptions;\r\n    let predFn = getBinaryPredicateFn(this, dataType as DataType, lqco);\r\n    if (predFn == null) {\r\n      throw new Error(\"Invalid binaryPredicate operator:\" + this.op.key);\r\n    }\r\n    return function (entity: Entity) {\r\n      return predFn!(expr1Fn(entity), expr2Fn(entity));\r\n    };\r\n  },\r\n\r\n  andOrPredicate: function (this: AndOrPredicate, context: VisitContext) {\r\n    let predFns = this.preds.map((pred) => {\r\n      return pred.visit(context);\r\n    });\r\n    switch (this.op!.key) {\r\n      case \"and\":\r\n        return function (entity: any) {\r\n          let result = predFns.reduce(function (prev, cur) {\r\n            return prev && cur(entity);\r\n          }, true);\r\n          return result;\r\n        };\r\n      case \"or\":\r\n        return function (entity: any) {\r\n          let result = predFns.reduce(function (prev, cur) {\r\n            return prev || cur(entity);\r\n          }, false);\r\n          return result;\r\n        };\r\n      default:\r\n        throw new Error(\"Invalid boolean operator:\" + this.op!.key);\r\n    }\r\n  },\r\n\r\n  anyAllPredicate: function (this: AnyAllPredicate, context: VisitContext) {\r\n    let exprFn = this.expr.visit(context);\r\n    let newContext = core.extend({}, context) as VisitContext;\r\n    newContext.entityType = this.expr.dataType as EntityType;\r\n    let predFn = this.pred.visit(newContext);\r\n    let anyAllPredFn = getAnyAllPredicateFn(this.op);\r\n    return function (entity: any) {\r\n      return anyAllPredFn(exprFn(entity), predFn);\r\n    };\r\n  },\r\n\r\n  litExpr: function (this: LitExpr) {\r\n    let value = this.value;\r\n    return function (entity: any) {\r\n      return value;\r\n    };\r\n  },\r\n\r\n  propExpr: function (this: PropExpr) {\r\n    let propertyPath = this.propertyPath;\r\n    let properties = propertyPath.split('.');\r\n    if (properties.length === 1) {\r\n      return function (entity: any) {\r\n        return entity.getProperty(propertyPath);\r\n      };\r\n    } else {\r\n      return function (entity: Entity) {\r\n        return EntityAspect.getPropertyPathValue(entity, properties);\r\n      };\r\n    }\r\n  },\r\n\r\n  fnExpr: function (this: FnExpr, context: ExpressionContext) {\r\n    let exprFns = this.exprs.map(function (expr) {\r\n      return expr.visit(context);\r\n    });\r\n    let that = this;\r\n    return function (entity: any) {\r\n      let values = exprFns.map(function (exprFn) {\r\n        let value = exprFn(entity);\r\n        return value;\r\n      });\r\n      let result = that.localFn.apply(null, values);\r\n      return result;\r\n    };\r\n  }\r\n\r\n};\r\n\r\nfunction getAnyAllPredicateFn(op: Op): (v1: any[], v2: any) => boolean {\r\n  switch (op.key) {\r\n    case \"any\":\r\n      return function (v1, v2) {\r\n        return v1.some(function (v) {\r\n          return v2(v);\r\n        });\r\n      };\r\n    case \"all\":\r\n      return function (v1, v2) {\r\n        return v1.every(function (v) {\r\n          return v2(v);\r\n        });\r\n      };\r\n    default:\r\n      throw new Error(\"Unknown operator: \" + op.key);\r\n  }\r\n}\r\n\r\nfunction getBinaryPredicateFn(binaryPredicate: BinaryPredicate, dataType: DataType, lqco: LocalQueryComparisonOptions) {\r\n  let op = binaryPredicate.op;\r\n  let mc = DataType.getComparableFn(dataType);\r\n  let predFn: (v1: any, v2: any) => boolean;\r\n  switch (op.key) {\r\n    case 'eq':\r\n      predFn = function (v1, v2) {\r\n        if (v1 && typeof v1 === 'string') {\r\n          return stringEquals(v1, v2, lqco);\r\n        } else {\r\n          return mc(v1) === mc(v2);\r\n        }\r\n      };\r\n      break;\r\n    case 'ne':\r\n      predFn = function (v1, v2) {\r\n        if (v1 && typeof v1 === 'string') {\r\n          return !stringEquals(v1, v2, lqco);\r\n        } else {\r\n          return mc(v1) !== mc(v2);\r\n        }\r\n      };\r\n      break;\r\n    case 'gt':\r\n      predFn = function (v1, v2) {\r\n        return mc(v1) > mc(v2);\r\n      };\r\n      break;\r\n    case 'ge':\r\n      predFn = function (v1, v2) {\r\n        return mc(v1) >= mc(v2);\r\n      };\r\n      break;\r\n    case 'lt':\r\n      predFn = function (v1, v2) {\r\n        return mc(v1) < mc(v2);\r\n      };\r\n      break;\r\n    case 'le':\r\n      predFn = function (v1, v2) {\r\n        return mc(v1) <= mc(v2);\r\n      };\r\n      break;\r\n    case 'startswith':\r\n      predFn = function (v1, v2) {\r\n        return stringStartsWith(v1, v2, lqco);\r\n      };\r\n      break;\r\n    case 'endswith':\r\n      predFn = function (v1, v2) {\r\n        return stringEndsWith(v1, v2, lqco);\r\n      };\r\n      break;\r\n    case 'contains':\r\n      predFn = function (v1, v2) {\r\n        return stringContains(v1, v2, lqco);\r\n      };\r\n      break;\r\n    case 'in':\r\n      predFn = function (v1: any, v2: any[]) {\r\n        v1 = mc(v1);\r\n        v2 = v2.map(function (v) { return mc(v); });\r\n        return v2.indexOf(v1) >= 0;\r\n      };\r\n      break;\r\n    default:\r\n      return null;\r\n  }\r\n  return predFn;\r\n}\r\n\r\nfunction stringEquals(a: any, b: any, lqco: LocalQueryComparisonOptions) {\r\n  if (b == null) return false;\r\n  if (typeof b !== 'string') {\r\n    b = b.toString();\r\n  }\r\n  if (lqco.usesSql92CompliantStringComparison) {\r\n    a = (a || \"\").trim();\r\n    b = (b || \"\").trim();\r\n  }\r\n  if (!lqco.isCaseSensitive) {\r\n    a = (a || \"\").toLowerCase();\r\n    b = (b || \"\").toLowerCase();\r\n  }\r\n  return a === b;\r\n}\r\n\r\nfunction stringStartsWith(a: any, b: any, lqco: LocalQueryComparisonOptions) {\r\n  if (!lqco.isCaseSensitive) {\r\n    a = (a || \"\").toLowerCase();\r\n    b = (b || \"\").toLowerCase();\r\n  }\r\n  return core.stringStartsWith(a, b);\r\n}\r\n\r\nfunction stringEndsWith(a: any, b: any, lqco: LocalQueryComparisonOptions) {\r\n  if (!lqco.isCaseSensitive) {\r\n    a = (a || \"\").toLowerCase();\r\n    b = (b || \"\").toLowerCase();\r\n  }\r\n  return core.stringEndsWith(a, b);\r\n}\r\n\r\nfunction stringContains(a: any, b: any, lqco: LocalQueryComparisonOptions) {\r\n  if (!lqco.isCaseSensitive) {\r\n    a = (a || \"\").toLowerCase();\r\n    b = (b || \"\").toLowerCase();\r\n  }\r\n  return a.indexOf(b) >= 0;\r\n}\r\n\r\n// toJSONVisitor\r\n\r\nlet toJSONVisitor = {\r\n\r\n  passthruPredicate: function (this: PassthruPredicate) {\r\n    return this.value;\r\n  },\r\n\r\n  unaryPredicate: function (this: UnaryPredicate, context: VisitContext) {\r\n    let predVal = this.pred.visit(context);\r\n    let json = {};\r\n    json[this.op.key] = predVal;\r\n    return json;\r\n  },\r\n\r\n  binaryPredicate: function (this: BinaryPredicate, context: VisitContext) {\r\n    let expr1Val = this.expr1!.visit(context);\r\n    let expr2Val = this.expr2!.visit(context);\r\n    let json = {};\r\n    if (this.expr2 instanceof PropExpr) {\r\n      expr2Val = { value: expr2Val, isProperty: true };\r\n    }\r\n    if (this.op.key === \"eq\") {\r\n      json[expr1Val] = expr2Val;\r\n    } else {\r\n      let value = {};\r\n      json[expr1Val] = value;\r\n      value[this.op.key] = expr2Val;\r\n    }\r\n    return json;\r\n  },\r\n\r\n  andOrPredicate: function (this: AndOrPredicate, context: VisitContext) {\r\n    let predVals = this.preds.map(function (pred) {\r\n      return pred.visit(context);\r\n    });\r\n    if (!predVals || !predVals.length) {\r\n      return {};\r\n    }\r\n    let json: Object | undefined;\r\n    // normalizeAnd clauses if possible.\r\n    // passthru predicate will appear as string and their 'ands' can't be 'normalized'\r\n    if (this.op!.key === 'and' && predVals.length === 2 && !predVals.some((v) => v.or || typeof(v) === 'string')) {\r\n      // normalize 'and' clauses - will return null if can't be combined.\r\n      json = predVals.reduce(combine);\r\n    }\r\n    if (json == null) {\r\n      json = {};\r\n      json[this.op!.key!] = predVals;\r\n    }\r\n    return json;\r\n  },\r\n\r\n  anyAllPredicate: function (this: AnyAllPredicate, context: VisitContext) {\r\n    let exprVal = this.expr.visit(context);\r\n    let newContext = core.extend({}, context) as VisitContext;\r\n    newContext.entityType = this.expr.dataType as EntityType;\r\n    let predVal = this.pred.visit(newContext);\r\n    let json = {};\r\n    let value = {};\r\n    value[this.op.key] = predVal;\r\n    json[exprVal] = value;\r\n    return json;\r\n  },\r\n\r\n  litExpr: function (this: LitExpr, context: VisitContext) {\r\n    if (this.hasExplicitDataType || context.useExplicitDataType) {\r\n      return { value: this.value, dataType: this.dataType.name };\r\n    } else {\r\n      return this.value;\r\n    }\r\n  },\r\n\r\n  propExpr: function (this: PropExpr, context: VisitContext) {\r\n    if (context.toNameOnServer) {\r\n      if (!context.entityType) {\r\n        console.warn(`No EntityType for propertyPath \"${this.propertyPath}\".  ${core.strings.TO_TYPE}`);\r\n        return this.propertyPath;\r\n      }\r\n      return context.entityType!.clientPropertyPathToServer(this.propertyPath);\r\n    } else {\r\n      return this.propertyPath;\r\n    }\r\n  },\r\n\r\n  fnExpr: function (this: FnExpr, context: VisitContext) {\r\n    let exprVals = this.exprs.map(function (expr) {\r\n      return expr.visit(context);\r\n    });\r\n    return this.fnName + \"(\" + exprVals.join(\",\") + \")\";\r\n  }\r\n\r\n};\r\n\r\nfunction combine(j1: Object, j2: Object) {\r\n  let ok = Object.keys(j2).every(function (key) {\r\n    if (j1.hasOwnProperty(key)) {\r\n      if (typeof (j2[key]) !== 'object') {\r\n        // exit and indicate that we can't combine\r\n        return false;\r\n      }\r\n      if (combine(j1[key], j2[key]) == null) {\r\n        return false;\r\n      }\r\n    } else if (typeof (j1) !== 'object') {\r\n      // cannot assign to j1[key]\r\n      return false;\r\n    } else {\r\n      j1[key] = j2[key];\r\n    }\r\n    return true;\r\n  });\r\n  return ok ? j1 : null;\r\n}\r\n\r\n\r\n\r\n\r\n"]}