sk-js/lib/Codes.js

JavaScript for ShaneKing

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = void 0;

var _Mesgs = _interopRequireDefault(require("./Mesgs"));

var _Proxy = _interopRequireDefault(require("./Proxy0"));

var _SK = _interopRequireDefault(require("./SK"));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread(); }

function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance"); }

function _iterableToArray(iter) { if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter); }

function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }

function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }

var Codes =
/*#__PURE__*/
function () {
  function Codes() {
    _classCallCheck(this, Codes);
  }

  _createClass(Codes, null, [{
    key: "get",
    //current language hash
    value: function get(code) {
      var path = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '/';

      var validPath = _SK.default.getValidPath(path);

      var validPaths = Codes.getSubPaths(validPath, false);

      for (var i = 0; i < validPaths.length; i += 1) {
        var validPathsCode0 = Codes.code[validPaths[i]];

        if (validPathsCode0) {
          var validPathsCodes = _SK.default.s4a(validPathsCode0.skVal(code));

          if (validPathsCodes.length !== 0) {
            return validPathsCodes;
          }
        }
      }

      return [];
    }
  }, {
    key: "getSubPaths",
    value: function getSubPaths(path, justUnExisted) {
      return justUnExisted ? _Proxy.default._.difference(_SK.default.getSubPaths(path), Object.keys(Codes.code)) : _SK.default.getSubPaths(path);
    }
  }, {
    key: "load",
    value: function load() {
      var path = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '/';
      var async = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
      path = _SK.default.getValidPath(path);

      if (Codes.code[path]) {
        return _Proxy.default.$.when(Codes.code[path]);
      } else if (_Proxy.default.$.isEmptyObject(Codes.hash)) {
        var deferred = _Proxy.default.$.Deferred();

        Codes.loadHash(async).done(function () {
          Codes.load(path, async).always(function () {
            deferred.resolve();
          });
        }).fail(function () {
          _Proxy.default.$.ajax({
            async: async,
            cache: false,
            dataType: _SK.default.FILE_TYPE_JSON,
            method: _SK.default.REQUEST_METHOD_GET,
            url: Codes.SERVER_URL + Codes.PATH_PREFIX + _SK.default.CHAR_UNDERLINE + _SK.default.getCurrentLanguage() + _SK.default.FILE_TYPE_JSON_WITH_POINT
          }).done(function (resp) {
            _Mesgs.default.jsonNodeParser(resp, _SK.default.STR_EMPTY, Codes.code);

            Object.keys(Codes.code).forEach(function (item) {
              Codes.loadMesg(Codes.code[item]);
            });
          }).always(function () {
            deferred.resolve();
          });
        });
        return deferred;
      } else {
        var _Proxy0$$;

        return (_Proxy0$$ = _Proxy.default.$).when.apply(_Proxy0$$, _toConsumableArray(Codes.getSubPaths(path, true).filter(function (validPath) {
          return Codes.hash[validPath];
        }).map(function (validPath) {
          return _Proxy.default.$.ajax({
            async: async,
            cache: true,
            dataType: _SK.default.FILE_TYPE_JSON,
            method: _SK.default.REQUEST_METHOD_GET,
            url: Codes.SERVER_URL + Codes.PATH_PREFIX + validPath + Codes.hash[validPath] + _SK.default.CHAR_UNDERLINE + _SK.default.getCurrentLanguage() + _SK.default.FILE_TYPE_JSON_WITH_POINT
          }).done(function (resp) {
            Codes.code[validPath] = resp;
            Codes.loadMesg(Codes.code[validPath]);
          });
        })));
      }
    }
  }, {
    key: "loadHash",
    value: function loadHash() {
      var async = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
      return _Proxy.default.$.ajax({
        async: async,
        cache: false,
        dataType: _SK.default.FILE_TYPE_JSON,
        method: _SK.default.REQUEST_METHOD_GET,
        url: Codes.SERVER_URL + Codes.PATH_PREFIX + _Mesgs.default.PART_OF_HASH_PATH + _SK.default.getCurrentLanguage() + _SK.default.FILE_TYPE_JSON_WITH_POINT
      }).done(function (resp) {
        Codes.hash = resp;
      });
    }
  }, {
    key: "loadMesg",
    value: function loadMesg(pathObject) {
      Object.keys(pathObject).forEach(function (key) {
        if (_Proxy.default._.isArray(pathObject[key])) {
          pathObject[key].forEach(function (item) {
            pathObject[key + _SK.default.STR_UNDERLINE_UNDERLINE + item.id] = item.text ? item.text : item.label;
          });
        }
      });
    }
  }, {
    key: "mesg",
    value: function mesg(key) {
      var path = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '/';

      var validPath = _SK.default.getValidPath(path);

      var validPaths = Codes.getSubPaths(validPath, false);

      var rtn = _SK.default.s4s(key);

      for (var i = 0; i < validPaths.length; i += 1) {
        var tmpRtn = _SK.default.s4o(Codes.code[validPaths[i]]).skVal(key);

        if (!_Proxy.default._.isNil(tmpRtn)) {
          rtn = tmpRtn;
          break;
        }
      }

      return rtn;
    }
  }, {
    key: "unload",
    value: function unload(path) {
      Object.keys(Codes.code).filter(function (existPath) {
        return _Proxy.default._.startsWith(existPath, path);
      }).forEach(function (existPath) {
        delete Codes.code[existPath];
      });
    }
  }]);

  return Codes;
}();

exports.default = Codes;
Codes.code = {};
Codes.hash = {};
Codes.PATH_PREFIX = '/json/codes';
Codes.SERVER_URL = '';