@web-atoms/core/dist/services/JsonService.js

Web Atoms Core

System.register(["tslib", "../core/StringHelper", "../di/RegisterSingleton", "@web-atoms/date-time/dist/DateTime"], function (_export, _context) {
  "use strict";

  var __decorate, StringHelper, RegisterSingleton, DateTime, dateFormatISORegEx, dateFormatMSRegEx, timeZoneDiff, JsonService;
  return {
    setters: [function (_tslib) {
      __decorate = _tslib.__decorate;
    }, function (_coreStringHelper) {
      StringHelper = _coreStringHelper.StringHelper;
    }, function (_diRegisterSingleton) {
      RegisterSingleton = _diRegisterSingleton.RegisterSingleton;
    }, function (_webAtomsDateTimeDistDateTime) {
      DateTime = _webAtomsDateTimeDistDateTime.default;
    }],
    execute: function () {
      _export("dateFormatISORegEx", dateFormatISORegEx = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2}(?:\.\d*)?)Z$/);
      _export("dateFormatMSRegEx", dateFormatMSRegEx = /^\/Date\((d|-|.*)\)[\/|\\]$/);
      timeZoneDiff = new Date().getTimezoneOffset();
      _export("JsonService", JsonService = class JsonService {
        constructor() {
          this.options = {
            indent: 2,
            namingStrategy: "none",
            dateConverter: [{
              regex: dateFormatISORegEx,
              valueConverter: {
                fromSource(v) {
                  const d = new DateTime(v);
                  return d;
                },
                fromTarget(v) {
                  return v.toISOString();
                }
              }
            }, {
              regex: dateFormatMSRegEx,
              valueConverter: {
                fromSource(v) {
                  const a = dateFormatMSRegEx.exec(v);
                  const b = a[1].split(/[-+,.]/);
                  return new DateTime(b[0] ? +b[0] : 0 - +b[1]);
                },
                fromTarget(v) {
                  return v.toISOString();
                }
              }
            }]
          };
        }
        transformKeys(t, v) {
          if (!v) {
            return v;
          }
          if (typeof v !== "object") {
            return v;
          }
          if (v instanceof Date) {
            return v;
          }
          if (typeof v === "object" && v.length !== undefined && typeof v.length === "number") {
            const a = v;
            if (a.map) {
              return a.map(x => this.transformKeys(t, x));
            }
            const ra = [];
            for (let i = 0; i < a.length; i++) {
              const iterator = a[i];
              ra.push(this.transformKeys(t, iterator));
            }
            return ra;
          }
          const r = {};
          for (const key in v) {
            if (v.hasOwnProperty(key)) {
              const element = v[key];
              r[t(key)] = this.transformKeys(t, element);
            }
          }
          return r;
        }
        parse(text, options) {
          const {
            dateConverter,
            namingStrategy
          } = Object.assign(Object.assign({}, this.options), options);
          const result = JSON.parse(text, (key, value) => {
            if (typeof value === "string") {
              for (const iterator of dateConverter) {
                const a = iterator.regex.test(value);
                if (a) {
                  const dv = iterator.valueConverter.fromSource(value);
                  return dv;
                }
              }
            }
            return value;
          });
          switch (namingStrategy) {
            case "hyphen":
              return this.transformKeys(StringHelper.fromHyphenToCamel, result);
            case "underscore":
              return this.transformKeys(StringHelper.fromUnderscoreToCamel, result);
            case "pascal":
              return this.transformKeys(StringHelper.fromPascalToCamel, result);
          }
          return result;
        }
        stringify(v, options) {
          const {
            namingStrategy,
            dateConverter,
            indent
          } = Object.assign(Object.assign({}, this.options), options);
          switch (namingStrategy) {
            case "hyphen":
              v = this.transformKeys(StringHelper.fromCamelToHyphen, v);
              break;
            case "underscore":
              v = this.transformKeys(StringHelper.fromCamelToUnderscore, v);
              break;
            case "pascal":
              v = this.transformKeys(StringHelper.fromCamelToPascal, v);
              break;
          }
          return JSON.stringify(v, (key, value) => {
            if (key && /^\_\$\_/.test(key)) {
              return undefined;
            }
            if (dateConverter && value instanceof Date) {
              return dateConverter[0].valueConverter.fromTarget(value);
            }
            return value;
          }, indent);
        }
      });
      _export("JsonService", JsonService = __decorate([RegisterSingleton], JsonService));
    }
  };
});
//# sourceMappingURL=JsonService.js.map