breeze-client 2.1.3-mjs → 2.1.4

package/esm5/src/data-type.js

@@ -0,0 +1,451 @@
+import { __extends } from "tslib";
+import { core } from './core';
+import { BreezeEnum } from './enum';
+import { Validator } from './validate';
+var _localTimeRegex = /.\d{3}$/;
+/**
+DataType is an 'Enum' containing all of the supported data types.
+@dynamic
+**/
+var DataType = /** @class */ (function (_super) {
+    __extends(DataType, _super);
+    function DataType() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    DataType.getComparableFn = function (dataType) {
+        if (dataType && dataType.normalize) {
+            return dataType.normalize;
+        }
+        else if (dataType === DataType.Time) {
+            // durations must be converted to compare them
+            return function (value) {
+                return value && core.durationToSeconds(value);
+            };
+        }
+        else {
+            // TODO: __identity
+            return function (value) {
+                return value;
+            };
+        }
+    };
+    /** Returns the DataType for a specified EDM type name.
+    **/
+    DataType.fromEdmDataType = function (typeName) {
+        var dt;
+        var parts = typeName.split(".");
+        if (parts.length > 1) {
+            var simpleName = parts[1];
+            if (simpleName === "image") {
+                // hack
+                dt = DataType.Byte;
+            }
+            else if (parts.length === 2) {
+                dt = DataType.fromName(simpleName) || DataType.Undefined;
+            }
+            else {
+                // enum
+                // dt = DataType.Int32;
+                dt = DataType.String;
+            }
+        }
+        return dt;
+    };
+    /** Returns the DataType for a specified input. */
+    DataType.fromValue = function (val) {
+        if (core.isDate(val))
+            return DataType.DateTime;
+        switch (typeof val) {
+            case "string":
+                if (core.isGuid(val))
+                    return DataType.Guid;
+                // the >3 below is a hack to insure that if we are inferring datatypes that
+                // very short strings that are valid but unlikely ISO encoded Time's are treated as strings instead.
+                else if (core.isDuration(val) && val.length > 3)
+                    return DataType.Time;
+                else if (core.isDateString(val))
+                    return DataType.DateTime;
+                return DataType.String;
+            case "boolean":
+                return DataType.Boolean;
+            case "number":
+                return DataType.Double;
+        }
+        return DataType.Undefined;
+    };
+    DataType.parseTimeFromServer = function (source) {
+        if (typeof source === 'string') {
+            return source;
+        }
+        // ODATA v3 format
+        if (source && source.__edmType === 'Edm.Time') {
+            var seconds = Math.floor(source.ms / 1000);
+            return 'PT' + seconds + 'S';
+        }
+        return source;
+    };
+    DataType.parseDateAsUTC = function (source) {
+        if (typeof source === 'string') {
+            // convert to UTC string if no time zone specifier.
+            var isLocalTime = _localTimeRegex.test(source);
+            // var isLocalTime = !hasTimeZone(source);
+            source = isLocalTime ? source + 'Z' : source;
+        }
+        source = new Date(Date.parse(source));
+        return source;
+    };
+    /** Returns a raw value converted to the specified DataType */
+    DataType.parseRawValue = function (val, dataType) {
+        // undefined values will be the default for most unmapped properties EXCEPT when they are set
+        // in a jsonResultsAdapter ( an unusual use case).
+        if (val === undefined)
+            return undefined;
+        if (!val)
+            return val;
+        if (dataType && dataType.parseRawValue) {
+            val = dataType.parseRawValue(val);
+        }
+        return val;
+    };
+    /** @hidden @internal */
+    // used during initialization; visible on instance for testing purposes.
+    DataType._resetConstants = function () {
+        DataType.constants = {
+            stringPrefix: "K_",
+            nextNumber: -1,
+            nextNumberIncrement: -1
+        };
+    };
+    DataType.parseDateFromServer = function (value) { return DataType.parseDateAsUTC(value); };
+    DataType.String = new DataType({
+        defaultValue: "",
+        parse: coerceToString,
+        fmtOData: fmtString,
+        getNext: getNextString
+    });
+    DataType.Int64 = new DataType({
+        defaultValue: 0,
+        isNumeric: true,
+        isInteger: true,
+        quoteJsonOData: true,
+        parse: coerceToInt,
+        fmtOData: makeFloatFmt("L"),
+        getNext: getNextNumber
+    });
+    DataType.Int32 = new DataType({
+        defaultValue: 0,
+        isNumeric: true,
+        isInteger: true,
+        parse: coerceToInt,
+        fmtOData: fmtInt,
+        getNext: getNextNumber
+    });
+    DataType.Int16 = new DataType({
+        defaultValue: 0,
+        isNumeric: true,
+        isInteger: true,
+        parse: coerceToInt,
+        fmtOData: fmtInt,
+        getNext: getNextNumber
+    });
+    DataType.Byte = new DataType({
+        defaultValue: 0,
+        isNumeric: true,
+        isInteger: true,
+        parse: coerceToInt,
+        fmtOData: fmtInt
+    });
+    DataType.Decimal = new DataType({
+        defaultValue: 0,
+        isNumeric: true,
+        quoteJsonOData: true,
+        isFloat: true,
+        parse: coerceToFloat,
+        fmtOData: makeFloatFmt("m"),
+        getNext: getNextNumber
+    });
+    DataType.Double = new DataType({
+        defaultValue: 0,
+        isNumeric: true,
+        isFloat: true,
+        parse: coerceToFloat,
+        fmtOData: makeFloatFmt("d"),
+        getNext: getNextNumber
+    });
+    DataType.Single = new DataType({
+        defaultValue: 0,
+        isNumeric: true,
+        isFloat: true,
+        parse: coerceToFloat,
+        fmtOData: makeFloatFmt("f"),
+        getNext: getNextNumber
+    });
+    DataType.DateTime = new DataType({
+        defaultValue: new Date(1900, 0, 1),
+        isDate: true,
+        parse: coerceToDate,
+        parseRawValue: parseRawDate,
+        normalize: function (value) { return value && value.getTime && value.getTime(); },
+        fmtOData: fmtDateTime,
+        getNext: getNextDateTime,
+        getConcurrencyValue: getConcurrencyDateTime
+    });
+    DataType.DateTimeOffset = new DataType({
+        defaultValue: new Date(1900, 0, 1),
+        isDate: true,
+        parse: coerceToDate,
+        parseRawValue: parseRawDate,
+        normalize: function (value) { return value && value.getTime && value.getTime(); },
+        fmtOData: fmtDateTimeOffset,
+        getNext: getNextDateTime,
+        getConcurrencyValue: getConcurrencyDateTime
+    });
+    DataType.Time = new DataType({
+        defaultValue: "PT0S",
+        fmtOData: fmtTime,
+        parseRawValue: DataType.parseTimeFromServer
+    });
+    DataType.Boolean = new DataType({
+        defaultValue: false,
+        parse: coerceToBool,
+        fmtOData: fmtBoolean
+    });
+    DataType.Guid = new DataType({
+        defaultValue: "00000000-0000-0000-0000-000000000000",
+        parse: coerceToGuid,
+        fmtOData: fmtGuid,
+        getNext: getNextGuid,
+        parseRawValue: function (val) { return val.toLowerCase(); },
+        getConcurrencyValue: core.getUuid
+    });
+    DataType.Binary = new DataType({
+        defaultValue: null,
+        fmtOData: fmtBinary,
+        parseRawValue: parseRawBinary
+    });
+    DataType.Undefined = new DataType({
+        defaultValue: undefined,
+        fmtOData: fmtUndefined
+    });
+    return DataType;
+}(BreezeEnum));
+export { DataType };
+DataType.prototype._$typeName = "DataType";
+Error['x'] = DataType._resetConstants();
+Error['x'] = DataType.resolveSymbols();
+Error['x'] = DataType.getSymbols().forEach(function (sym) { return sym.validatorCtor = getValidatorCtor(sym); });
+// private functions;
+function getValidatorCtor(dataType) {
+    switch (dataType) {
+        case DataType.String:
+            return Validator.string;
+        case DataType.Int64:
+            return Validator.int64;
+        case DataType.Int32:
+            return Validator.int32;
+        case DataType.Int16:
+            return Validator.int16;
+        case DataType.Decimal:
+            return Validator.number;
+        case DataType.Double:
+            return Validator.number;
+        case DataType.Single:
+            return Validator.number;
+        case DataType.DateTime:
+            return Validator.date;
+        case DataType.DateTimeOffset:
+            return Validator.date;
+        case DataType.Boolean:
+            return Validator.bool;
+        case DataType.Guid:
+            return Validator.guid;
+        case DataType.Byte:
+            return Validator.byte;
+        case DataType.Binary:
+            // TODO: don't quite know how to validate this yet.
+            return Validator.none;
+        case DataType.Time:
+            return Validator.duration;
+        case DataType.Undefined:
+            return Validator.none;
+    }
+}
+function getNextString() {
+    return DataType.constants.stringPrefix + getNextNumber().toString();
+}
+function getNextNumber() {
+    var result = DataType.constants.nextNumber;
+    DataType.constants.nextNumber += DataType.constants.nextNumberIncrement;
+    return result;
+}
+function getNextGuid() {
+    return core.getUuid();
+}
+function getNextDateTime() {
+    return new Date();
+}
+function getConcurrencyDateTime(val) {
+    // use the current datetime but insure that it is different from previous call.
+    var dt = new Date();
+    var dt2 = new Date();
+    while (dt.getTime() === dt2.getTime()) {
+        dt2 = new Date();
+    }
+    return dt2;
+}
+function coerceToString(source, sourceTypeName) {
+    return (source == null) ? source : source.toString();
+}
+function coerceToGuid(source, sourceTypeName) {
+    if (sourceTypeName === "string") {
+        return source.trim().toLowerCase();
+    }
+    return source;
+}
+function coerceToInt(source, sourceTypeName) {
+    if (sourceTypeName === "string") {
+        var src = source.trim();
+        if (src === "")
+            return null;
+        var val = parseInt(src, 10);
+        return isNaN(val) ? source : val;
+    }
+    else if (sourceTypeName === "number") {
+        return Math.round(source);
+    }
+    // do we want to coerce floats -> ints
+    return source;
+}
+function coerceToFloat(source, sourceTypeName) {
+    if (sourceTypeName === "string") {
+        var src = source.trim();
+        if (src === "")
+            return null;
+        var val = parseFloat(src);
+        return isNaN(val) ? source : val;
+    }
+    return source;
+}
+function coerceToDate(source, sourceTypeName) {
+    var val;
+    if (sourceTypeName === "string") {
+        var src = source.trim();
+        if (src === "")
+            return null;
+        val = new Date(Date.parse(src));
+        return core.isDate(val) ? val : source;
+    }
+    else if (sourceTypeName === "number") {
+        val = new Date(source);
+        return core.isDate(val) ? val : source;
+    }
+    return source;
+}
+function coerceToBool(source, sourceTypeName) {
+    if (sourceTypeName === "string") {
+        var src = source.trim().toLowerCase();
+        if (src === "false" || src === "") {
+            return false;
+        }
+        else if (src === "true") {
+            return true;
+        }
+        else {
+            return source;
+        }
+    }
+    return source;
+}
+function fmtString(val) {
+    return val == null ? null : "'" + val.replace(/'/g, "''") + "'";
+}
+function fmtInt(val) {
+    return val == null ? null : ((typeof val === "string") ? parseInt(val, 10) : val);
+}
+function makeFloatFmt(fmtSuffix) {
+    return function (val) {
+        if (val == null)
+            return null;
+        if (typeof val === "string") {
+            val = parseFloat(val);
+        }
+        return val + fmtSuffix;
+    };
+}
+function fmtDateTime(val) {
+    if (val == null)
+        return null;
+    try {
+        return "datetime'" + val.toISOString() + "'";
+    }
+    catch (e) {
+        throwError("'%1' is not a valid dateTime", val);
+    }
+}
+function fmtDateTimeOffset(val) {
+    if (val == null)
+        return null;
+    try {
+        return "datetimeoffset'" + val.toISOString() + "'";
+    }
+    catch (e) {
+        throwError("'%1' is not a valid dateTime", val);
+    }
+}
+function fmtTime(val) {
+    if (val == null)
+        return null;
+    if (!core.isDuration(val)) {
+        throwError("'%1' is not a valid ISO 8601 duration", val);
+    }
+    return "time'" + val + "'";
+}
+function fmtGuid(val) {
+    if (val == null)
+        return null;
+    if (!core.isGuid(val)) {
+        throwError("'%1' is not a valid guid", val);
+    }
+    return "guid'" + val + "'";
+}
+function fmtBoolean(val) {
+    if (val == null)
+        return null;
+    if (typeof val === "string") {
+        return val.trim().toLowerCase() === "true";
+    }
+    else {
+        return !!val;
+    }
+}
+function fmtBinary(val) {
+    if (val == null)
+        return val;
+    return "binary'" + val + "'";
+}
+// TODO: use __identity instead;
+function fmtUndefined(val) {
+    return val;
+}
+function throwError(msg, val) {
+    msg = core.formatString(msg, val);
+    throw new Error(msg);
+}
+function parseRawDate(val) {
+    if (!core.isDate(val)) {
+        val = DataType.parseDateFromServer(val);
+    }
+    return val;
+}
+function parseRawBinary(val) {
+    if (val && val.$value !== undefined) {
+        val = val.$value; // this will be a byte[] encoded as a string
+    }
+    return val;
+}
+//function hasTimeZone(source) {
+//  var ix = source.indexOf("T");
+//  var timePart = source.substring(ix+1);
+//  return  timePart.indexOf("-") >= 0 || timePart.indexOf("+") >= 0 || timePart.indexOf("Z");
+//}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"data-type.js","sourceRoot":"ng://breeze-client/","sources":["src/data-type.ts"],"names":[],"mappings":"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","sourcesContent":["import { core } from './core';\r\nimport { BreezeEnum } from './enum';\r\nimport { Validator } from './validate';\r\n\r\nlet _localTimeRegex = /.\\d{3}$/;\r\n\r\n/**  \r\nDataType is an 'Enum' containing all of the supported data types.\r\n@dynamic\r\n**/\r\nexport class DataType extends BreezeEnum {\r\n  /** The default value of this DataType. __Read Only__ **/\r\n  defaultValue?: any;\r\n  /** Whether this is a 'numeric' DataType. __Read Only__ **/\r\n  isNumeric?: boolean;\r\n  /** Whether this is an 'integer' DataType. __Read Only__ **/\r\n  isInteger?: boolean;\r\n  /** Whether to quote the json value when formatting this DataType for OData. */\r\n  quoteJsonOData?: boolean;\r\n  /** The constructor function to create a [[Validator]] to be used in validating instances of this DataType. */\r\n  validatorCtor?(context?: any): Validator;\r\n  /** \r\n  Optional function to normalize a data value for comparison, if its value cannot be used directly. \r\n  Note that this will be called each time a property is changed, so make it fast.\r\n  @return value appropriate for this DataType\r\n  **/\r\n  normalize?(value: any): any;\r\n  /**\r\n  Optional function to convert a raw (server) value from string to this DataType.\r\n  @return value appropriate for this DataType\r\n  **/\r\n  parseRawValue?(value: any): any;\r\n  /**\r\n  Optional function to convert a value from string to this DataType.  Note that this will be called each time a property is changed, so make it fast.\r\n  @return value appropriate for this DataType \r\n  **/\r\n  parse?(source: any, sourceTypeName: string): any;\r\n  /** \r\n  Optional function to format this DataType for OData queries.\r\n  @return value appropriate for OData query   \r\n  **/\r\n  fmtOData?(value: any): any;\r\n  /** \r\n  Optional function to get the next value for key generation, if this datatype is used as a key.  Uses an internal table of previous values.\r\n  @return value appropriate for this DataType \r\n  **/\r\n  getNext?(): any;\r\n  /**\r\n  Optional function to get the next value when the datatype is used as a concurrency property.\r\n  @param previousValue\r\n  @return the next concurrency value, which may be a function of the previousValue.\r\n  **/\r\n  getConcurrencyValue?(previousValue?: any): any;\r\n\r\n  static parseDateFromServer = (value: any) => DataType.parseDateAsUTC(value);\r\n  // same effect as above but doesn't give right TSDOC.\r\n  // static parseDateFromServer = DataType.parseDateAsUTC;\r\n\r\n  /** @hidden @internal */\r\n  static constants: { stringPrefix: string, nextNumber: number, nextNumberIncrement: number };\r\n\r\n  static String = new DataType({\r\n    defaultValue: \"\",\r\n    parse: coerceToString,\r\n    fmtOData: fmtString,\r\n    getNext: getNextString\r\n  });\r\n\r\n  static Int64 = new DataType({\r\n    defaultValue: 0,\r\n    isNumeric: true,\r\n    isInteger: true,\r\n    quoteJsonOData: true,\r\n    parse: coerceToInt,\r\n    fmtOData: makeFloatFmt(\"L\"),\r\n    getNext: getNextNumber\r\n  });\r\n\r\n  static Int32 = new DataType({\r\n    defaultValue: 0,\r\n    isNumeric: true,\r\n    isInteger: true,\r\n    parse: coerceToInt,\r\n    fmtOData: fmtInt,\r\n    getNext: getNextNumber\r\n  });\r\n\r\n  static Int16 = new DataType({\r\n    defaultValue: 0,\r\n    isNumeric: true,\r\n    isInteger: true,\r\n    parse: coerceToInt,\r\n    fmtOData: fmtInt,\r\n    getNext: getNextNumber\r\n  });\r\n\r\n  static Byte = new DataType({\r\n    defaultValue: 0,\r\n    isNumeric: true,\r\n    isInteger: true,\r\n    parse: coerceToInt,\r\n    fmtOData: fmtInt\r\n  });\r\n\r\n  static Decimal = new DataType({\r\n    defaultValue: 0,\r\n    isNumeric: true,\r\n    quoteJsonOData: true,\r\n    isFloat: true,\r\n    parse: coerceToFloat,\r\n    fmtOData: makeFloatFmt(\"m\"),\r\n    getNext: getNextNumber\r\n  });\r\n\r\n  static Double = new DataType({\r\n    defaultValue: 0,\r\n    isNumeric: true,\r\n    isFloat: true,\r\n    parse: coerceToFloat,\r\n    fmtOData: makeFloatFmt(\"d\"),\r\n    getNext: getNextNumber\r\n  });\r\n\r\n  static Single = new DataType({\r\n    defaultValue: 0,\r\n    isNumeric: true,\r\n    isFloat: true,\r\n    parse: coerceToFloat,\r\n    fmtOData: makeFloatFmt(\"f\"),\r\n    getNext: getNextNumber\r\n  });\r\n\r\n  static DateTime = new DataType({\r\n    defaultValue: new Date(1900, 0, 1),\r\n    isDate: true,\r\n    parse: coerceToDate,\r\n    parseRawValue: parseRawDate,\r\n    normalize: function (value: any) { return value && value.getTime && value.getTime(); }, // dates don't perform equality comparisons properly\r\n    fmtOData: fmtDateTime,\r\n    getNext: getNextDateTime,\r\n    getConcurrencyValue: getConcurrencyDateTime\r\n  });\r\n\r\n  static DateTimeOffset = new DataType({\r\n    defaultValue: new Date(1900, 0, 1),\r\n    isDate: true,\r\n    parse: coerceToDate,\r\n    parseRawValue: parseRawDate,\r\n    normalize: function (value: any) { return value && value.getTime && value.getTime(); }, // dates don't perform equality comparisons properly\r\n    fmtOData: fmtDateTimeOffset,\r\n    getNext: getNextDateTime,\r\n    getConcurrencyValue: getConcurrencyDateTime\r\n  });\r\n\r\n  static Time = new DataType({\r\n    defaultValue: \"PT0S\",\r\n    fmtOData: fmtTime,\r\n    parseRawValue: DataType.parseTimeFromServer\r\n  });\r\n\r\n  static Boolean = new DataType({\r\n    defaultValue: false,\r\n    parse: coerceToBool,\r\n    fmtOData: fmtBoolean\r\n  });\r\n\r\n  static Guid = new DataType({\r\n    defaultValue: \"00000000-0000-0000-0000-000000000000\",\r\n    parse: coerceToGuid,\r\n    fmtOData: fmtGuid,\r\n    getNext: getNextGuid,\r\n    parseRawValue: function (val: string) { return val.toLowerCase(); },\r\n    getConcurrencyValue: core.getUuid\r\n  });\r\n\r\n  static Binary = new DataType({\r\n    defaultValue: null,\r\n    fmtOData: fmtBinary,\r\n    parseRawValue: parseRawBinary\r\n  });\r\n\r\n  static Undefined = new DataType({\r\n    defaultValue: undefined,\r\n    fmtOData: fmtUndefined\r\n  });\r\n\r\n  static getComparableFn(dataType?: DataType) {\r\n    if (dataType && dataType.normalize) {\r\n      return dataType.normalize;\r\n    } else if (dataType === DataType.Time) {\r\n      // durations must be converted to compare them\r\n      return function (value: any) {\r\n        return value && core.durationToSeconds(value);\r\n      };\r\n    } else {\r\n      // TODO: __identity\r\n      return function (value: any) {\r\n        return value;\r\n      };\r\n    }\r\n  }\r\n\r\n  /** Returns the DataType for a specified EDM type name.\r\n  **/\r\n  static fromEdmDataType(typeName: string) {\r\n    let dt: DataType | undefined;\r\n    let parts = typeName.split(\".\");\r\n    if (parts.length > 1) {\r\n      let simpleName = parts[1];\r\n      if (simpleName === \"image\") {\r\n        // hack\r\n        dt = DataType.Byte;\r\n      } else if (parts.length === 2) {\r\n        dt = DataType.fromName(simpleName) || DataType.Undefined;\r\n      } else {\r\n        // enum\r\n        // dt = DataType.Int32;\r\n        dt = DataType.String;\r\n      }\r\n    }\r\n\r\n    return dt;\r\n  }\r\n\r\n  /** Returns the DataType for a specified input. */\r\n  static fromValue(val: any) {\r\n    if (core.isDate(val)) return DataType.DateTime;\r\n    switch (typeof val) {\r\n      case \"string\":\r\n        if (core.isGuid(val)) return DataType.Guid;\r\n        // the >3 below is a hack to insure that if we are inferring datatypes that\r\n        // very short strings that are valid but unlikely ISO encoded Time's are treated as strings instead.\r\n        else if (core.isDuration(val) && val.length > 3) return DataType.Time;\r\n        else if (core.isDateString(val)) return DataType.DateTime;\r\n        return DataType.String;\r\n      case \"boolean\":\r\n        return DataType.Boolean;\r\n      case \"number\":\r\n        return DataType.Double;\r\n    }\r\n    return DataType.Undefined;\r\n  }\r\n\r\n  static parseTimeFromServer(source: any) {\r\n    if (typeof source === 'string') {\r\n      return source;\r\n    }\r\n    // ODATA v3 format\r\n    if (source && source.__edmType === 'Edm.Time') {\r\n      let seconds = Math.floor(source.ms / 1000);\r\n      return 'PT' + seconds + 'S';\r\n    }\r\n    return source;\r\n  }\r\n\r\n  static parseDateAsUTC(source: any) {\r\n    if (typeof source === 'string') {\r\n      // convert to UTC string if no time zone specifier.\r\n      let isLocalTime = _localTimeRegex.test(source);\r\n      // var isLocalTime = !hasTimeZone(source);\r\n      source = isLocalTime ? source + 'Z' : source;\r\n    }\r\n    source = new Date(Date.parse(source));\r\n    return source;\r\n  }\r\n\r\n\r\n  /** Returns a raw value converted to the specified DataType */\r\n  static parseRawValue(val: any, dataType?: DataType) {\r\n    // undefined values will be the default for most unmapped properties EXCEPT when they are set\r\n    // in a jsonResultsAdapter ( an unusual use case).\r\n    if (val === undefined) return undefined;\r\n    if (!val) return val;\r\n    if (dataType && dataType.parseRawValue) {\r\n      val = dataType.parseRawValue(val);\r\n    }\r\n    return val;\r\n  }\r\n\r\n  /** @hidden @internal */\r\n  // used during initialization; visible on instance for testing purposes.\r\n  static _resetConstants() {\r\n    DataType.constants = {\r\n      stringPrefix: \"K_\",\r\n      nextNumber: -1,\r\n      nextNumberIncrement: -1\r\n    };\r\n  }\r\n\r\n  // NOT YET NEEDED --------------------------------------------------\r\n  // var _utcOffsetMs = (new Date()).getTimezoneOffset() * 60000;\r\n\r\n  //DataType.parseDateAsLocal = function (source) {\r\n  //    var dt = DataType.parseDatesAsUTC(source);\r\n  //    if (__isDate(dt)) {\r\n  //        dt = new Date(dt.getTime() + _utcOffsetMs);\r\n  //    }\r\n  //    return dt;\r\n  //};\r\n}\r\nDataType.prototype._$typeName = \"DataType\";\r\nError['x'] = DataType._resetConstants();\r\nError['x'] = DataType.resolveSymbols();\r\nError['x'] = DataType.getSymbols().forEach((sym: DataType) => sym.validatorCtor = getValidatorCtor(sym));\r\n\r\n// private functions;\r\n\r\n\r\nfunction getValidatorCtor(dataType: DataType) {\r\n  switch (dataType) {\r\n    case DataType.String:\r\n      return Validator.string;\r\n    case DataType.Int64:\r\n      return Validator.int64;\r\n    case DataType.Int32:\r\n      return Validator.int32;\r\n    case DataType.Int16:\r\n      return Validator.int16;\r\n    case DataType.Decimal:\r\n      return Validator.number;\r\n    case DataType.Double:\r\n      return Validator.number;\r\n    case DataType.Single:\r\n      return Validator.number;\r\n    case DataType.DateTime:\r\n      return Validator.date;\r\n    case DataType.DateTimeOffset:\r\n      return Validator.date;\r\n    case DataType.Boolean:\r\n      return Validator.bool;\r\n    case DataType.Guid:\r\n      return Validator.guid;\r\n    case DataType.Byte:\r\n      return Validator.byte;\r\n    case DataType.Binary:\r\n      // TODO: don't quite know how to validate this yet.\r\n      return Validator.none;\r\n    case DataType.Time:\r\n      return Validator.duration;\r\n    case DataType.Undefined:\r\n      return Validator.none;\r\n  }\r\n}\r\n\r\nfunction getNextString() {\r\n  return DataType.constants.stringPrefix + getNextNumber().toString();\r\n}\r\n\r\nfunction getNextNumber() {\r\n  let result = DataType.constants.nextNumber;\r\n  DataType.constants.nextNumber += DataType.constants.nextNumberIncrement;\r\n  return result;\r\n}\r\n\r\nfunction getNextGuid() {\r\n  return core.getUuid();\r\n}\r\n\r\nfunction getNextDateTime() {\r\n  return new Date();\r\n}\r\n\r\nfunction getConcurrencyDateTime(val: any) {\r\n  // use the current datetime but insure that it is different from previous call.\r\n  let dt = new Date();\r\n  let dt2 = new Date();\r\n  while (dt.getTime() === dt2.getTime()) {\r\n    dt2 = new Date();\r\n  }\r\n  return dt2;\r\n}\r\n\r\nfunction coerceToString(source: any, sourceTypeName?: string) {\r\n  return (source == null) ? source : source.toString();\r\n}\r\n\r\nfunction coerceToGuid(source: any, sourceTypeName: string) {\r\n  if (sourceTypeName === \"string\") {\r\n    return source.trim().toLowerCase();\r\n  }\r\n  return source;\r\n}\r\n\r\nfunction coerceToInt(source: any, sourceTypeName: string) {\r\n  if (sourceTypeName === \"string\") {\r\n    let src = source.trim();\r\n    if (src === \"\") return null;\r\n    let val = parseInt(src, 10);\r\n    return isNaN(val) ? source : val;\r\n  } else if (sourceTypeName === \"number\") {\r\n    return Math.round(source);\r\n  }\r\n  // do we want to coerce floats -> ints\r\n  return source;\r\n}\r\n\r\nfunction coerceToFloat(source: any, sourceTypeName: string) {\r\n  if (sourceTypeName === \"string\") {\r\n    let src = source.trim();\r\n    if (src === \"\") return null;\r\n    let val = parseFloat(src);\r\n    return isNaN(val) ? source : val;\r\n  }\r\n  return source;\r\n}\r\n\r\nfunction coerceToDate(source: any, sourceTypeName: string) {\r\n  let val: any;\r\n  if (sourceTypeName === \"string\") {\r\n    let src = source.trim();\r\n    if (src === \"\") return null;\r\n    val = new Date(Date.parse(src));\r\n    return core.isDate(val) ? val : source;\r\n  } else if (sourceTypeName === \"number\") {\r\n    val = new Date(source);\r\n    return core.isDate(val) ? val : source;\r\n  }\r\n  return source;\r\n}\r\n\r\nfunction coerceToBool(source: any, sourceTypeName: string) {\r\n  if (sourceTypeName === \"string\") {\r\n    let src = source.trim().toLowerCase();\r\n    if (src === \"false\" || src === \"\") {\r\n      return false;\r\n    } else if (src === \"true\") {\r\n      return true;\r\n    } else {\r\n      return source;\r\n    }\r\n  }\r\n  return source;\r\n}\r\n\r\nfunction fmtString(val: any) {\r\n  return val == null ? null : \"'\" + val.replace(/'/g, \"''\") + \"'\";\r\n}\r\n\r\nfunction fmtInt(val: any) {\r\n  return val == null ? null : ((typeof val === \"string\") ? parseInt(val, 10) : val);\r\n}\r\n\r\nfunction makeFloatFmt(fmtSuffix: string) {\r\n  return function (val: any) {\r\n    if (val == null) return null;\r\n    if (typeof val === \"string\") {\r\n      val = parseFloat(val);\r\n    }\r\n    return val + fmtSuffix;\r\n  };\r\n}\r\n\r\nfunction fmtDateTime(val: Date) {\r\n  if (val == null) return null;\r\n  try {\r\n    return \"datetime'\" + val.toISOString() + \"'\";\r\n  } catch (e) {\r\n    throwError(\"'%1' is not a valid dateTime\", val);\r\n  }\r\n}\r\n\r\nfunction fmtDateTimeOffset(val: Date) {\r\n  if (val == null) return null;\r\n  try {\r\n    return \"datetimeoffset'\" + val.toISOString() + \"'\";\r\n  } catch (e) {\r\n    throwError(\"'%1' is not a valid dateTime\", val);\r\n  }\r\n}\r\n\r\nfunction fmtTime(val: any) {\r\n  if (val == null) return null;\r\n  if (!core.isDuration(val)) {\r\n    throwError(\"'%1' is not a valid ISO 8601 duration\", val);\r\n  }\r\n  return \"time'\" + val + \"'\";\r\n}\r\n\r\nfunction fmtGuid(val: any) {\r\n  if (val == null) return null;\r\n  if (!core.isGuid(val)) {\r\n    throwError(\"'%1' is not a valid guid\", val);\r\n  }\r\n  return \"guid'\" + val + \"'\";\r\n}\r\n\r\nfunction fmtBoolean(val: any) {\r\n  if (val == null) return null;\r\n  if (typeof val === \"string\") {\r\n    return val.trim().toLowerCase() === \"true\";\r\n  } else {\r\n    return !!val;\r\n  }\r\n}\r\n\r\nfunction fmtBinary(val: any) {\r\n  if (val == null) return val;\r\n  return \"binary'\" + val + \"'\";\r\n}\r\n\r\n// TODO: use __identity instead;\r\nfunction fmtUndefined(val: any) {\r\n  return val;\r\n}\r\n\r\nfunction throwError(msg: string, val: any) {\r\n  msg = core.formatString(msg, val);\r\n  throw new Error(msg);\r\n}\r\n\r\nfunction parseRawDate(val: any) {\r\n  if (!core.isDate(val)) {\r\n    val = DataType.parseDateFromServer(val);\r\n  }\r\n  return val;\r\n}\r\n\r\nfunction parseRawBinary(val: any) {\r\n  if (val && val.$value !== undefined) {\r\n    val = val.$value; // this will be a byte[] encoded as a string\r\n  }\r\n  return val;\r\n}\r\n\r\n//function hasTimeZone(source) {\r\n//  var ix = source.indexOf(\"T\");\r\n//  var timePart = source.substring(ix+1);\r\n//  return  timePart.indexOf(\"-\") >= 0 || timePart.indexOf(\"+\") >= 0 || timePart.indexOf(\"Z\");\r\n//}\r\n\r\n\r\n"]}