sk-js/lib/Mesgs.js

JavaScript for ShaneKing

"use strict";

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

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 Mesgs =
/*#__PURE__*/
function () {
  function Mesgs() {
    _classCallCheck(this, Mesgs);
  }

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

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

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

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

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

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

      return rtn;
    }
  }, {
    key: "gets",
    value: function gets(keys) {
      var path = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '/';
      var keyArray = _Proxy.default._.isArray(keys) ? keys : keys.split(_SK.default.CHAR_FEMALE);
      var sep = _SK.default.LANGUAGE_zh_CN === _SK.default.getCurrentLanguage() ? _SK.default.STR_EMPTY : _SK.default.CHAR_BLANK;
      return keyArray.map(function (key) {
        return Mesgs.get(key, path);
      }).join(sep);
    }
  }, {
    key: "getSubPaths",
    value: function getSubPaths(path, justUnExisted) {
      return justUnExisted ? _Proxy.default._.difference(_SK.default.getSubPaths(path), Object.keys(Mesgs.mesg)) : _SK.default.getSubPaths(path);
    }
    /**
     *
     * @param jsonObject
     * @param existPath '' or '/path'
     * @param pathObjects
     */

  }, {
    key: "jsonNodeParser",
    value: function jsonNodeParser(jsonObject, existPath, pathObjects) {
      var pathObject = {};
      Object.keys(jsonObject).forEach(function (path) {
        if (path === _SK.default.CHAR_SLASH) {
          var rootObject = jsonObject[path];
          Object.keys(rootObject).forEach(function (key) {
            pathObject[key] = rootObject[key];
          });
        } else if (_Proxy.default._.endsWith(path, _SK.default.CHAR_SLASH)) {
          pathObjects[existPath + (_Proxy.default._.startsWith(path, _SK.default.CHAR_SLASH) ? path : _SK.default.CHAR_SLASH + path)] = jsonObject[path];
        } else if (_Proxy.default._.startsWith(path, _SK.default.CHAR_SLASH)) {
          Mesgs.jsonNodeParser(jsonObject[path], existPath + path, pathObjects);
        } else {
          pathObject[path] = jsonObject[path];
        }
      }); // if (Object.keys(pathObject).length > 0) {
      //   pathObjects[existPath + SK.STR_OF_CHAR_SLASH] = pathObject;
      // }
      //Always generate path

      pathObjects[existPath + _SK.default.CHAR_SLASH] = pathObject;
    }
  }, {
    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 (Mesgs.mesg[path]) {
        return _Proxy.default.$.when(Mesgs.mesg[path]);
      } else if (_Proxy.default.$.isEmptyObject(Mesgs.hash)) {
        var $Deferred = _Proxy.default.$.Deferred();

        Mesgs.loadHash(async).done(function () {
          Mesgs.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: Mesgs.SERVER_URL + Mesgs.PATH_PREFIX + _SK.default.CHAR_UNDERLINE + _SK.default.getCurrentLanguage() + _SK.default.FILE_TYPE_JSON_WITH_POINT
          }).done(function (resp) {
            Mesgs.jsonNodeParser(resp, _SK.default.STR_EMPTY, Mesgs.mesg);
          }).always(function () {
            $Deferred.resolve();
          });
        });
        return $Deferred;
      } else {
        var _Proxy0$$;

        return (_Proxy0$$ = _Proxy.default.$).when.apply(_Proxy0$$, _toConsumableArray(Mesgs.getSubPaths(path, true).filter(function (validPath) {
          return Mesgs.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: Mesgs.SERVER_URL + Mesgs.PATH_PREFIX + validPath + Mesgs.hash[validPath] + _SK.default.CHAR_UNDERLINE + _SK.default.getCurrentLanguage() + _SK.default.FILE_TYPE_JSON_WITH_POINT
          }).done(function (resp) {
            Mesgs.mesg[validPath] = resp;
          });
        })));
      }
    }
  }, {
    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: Mesgs.SERVER_URL + Mesgs.PATH_PREFIX + Mesgs.PART_OF_HASH_PATH + _SK.default.getCurrentLanguage() + _SK.default.FILE_TYPE_JSON_WITH_POINT
      }).done(function (resp) {
        Mesgs.hash = resp;
      });
    }
  }, {
    key: "unload",
    value: function unload(path) {
      Object.keys(Mesgs.mesg).filter(function (existPath) {
        return _Proxy.default._.startsWith(existPath, path);
      }).forEach(function (existPath) {
        delete Mesgs.mesg[existPath];
      });
    }
  }]);

  return Mesgs;
}();

exports.default = Mesgs;
Mesgs.hash = {};
Mesgs.mesg = {};
Mesgs.PART_OF_HASH_PATH = '_Hash_';
Mesgs.PATH_PREFIX = '/json/mesgs';
Mesgs.SERVER_URL = '';