sk-js/es/Mesgs.js

JavaScript for ShaneKing

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; }

import Proxy0 from './Proxy0';
import SK from './SK';

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.getValidPath(path);
      var validPaths = Mesgs.getSubPaths(validPath, false);
      var rtn = SK.s4s(key);

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

        if (!Proxy0._.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 = Proxy0._.isArray(keys) ? keys : keys.split(SK.CHAR_FEMALE);
      var sep = SK.LANGUAGE_zh_CN === SK.getCurrentLanguage() ? SK.STR_EMPTY : SK.CHAR_BLANK;
      return keyArray.map(function (key) {
        return Mesgs.get(key, path);
      }).join(sep);
    }
  }, {
    key: "getSubPaths",
    value: function getSubPaths(path, justUnExisted) {
      return justUnExisted ? Proxy0._.difference(SK.getSubPaths(path), Object.keys(Mesgs.mesg)) : SK.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.CHAR_SLASH) {
          var rootObject = jsonObject[path];
          Object.keys(rootObject).forEach(function (key) {
            pathObject[key] = rootObject[key];
          });
        } else if (Proxy0._.endsWith(path, SK.CHAR_SLASH)) {
          pathObjects[existPath + (Proxy0._.startsWith(path, SK.CHAR_SLASH) ? path : SK.CHAR_SLASH + path)] = jsonObject[path];
        } else if (Proxy0._.startsWith(path, SK.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.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.getValidPath(path);

      if (Mesgs.mesg[path]) {
        return Proxy0.$.when(Mesgs.mesg[path]);
      } else if (Proxy0.$.isEmptyObject(Mesgs.hash)) {
        var $Deferred = Proxy0.$.Deferred();
        Mesgs.loadHash(async).done(function () {
          Mesgs.load(path, async).always(function () {
            $Deferred.resolve();
          });
        }).fail(function () {
          Proxy0.$.ajax({
            async: async,
            cache: false,
            dataType: SK.FILE_TYPE_JSON,
            method: SK.REQUEST_METHOD_GET,
            url: Mesgs.SERVER_URL + Mesgs.PATH_PREFIX + SK.CHAR_UNDERLINE + SK.getCurrentLanguage() + SK.FILE_TYPE_JSON_WITH_POINT
          }).done(function (resp) {
            Mesgs.jsonNodeParser(resp, SK.STR_EMPTY, Mesgs.mesg);
          }).always(function () {
            $Deferred.resolve();
          });
        });
        return $Deferred;
      } else {
        var _Proxy0$$;

        return (_Proxy0$$ = Proxy0.$).when.apply(_Proxy0$$, _toConsumableArray(Mesgs.getSubPaths(path, true).filter(function (validPath) {
          return Mesgs.hash[validPath];
        }).map(function (validPath) {
          return Proxy0.$.ajax({
            async: async,
            cache: true,
            dataType: SK.FILE_TYPE_JSON,
            method: SK.REQUEST_METHOD_GET,
            url: Mesgs.SERVER_URL + Mesgs.PATH_PREFIX + validPath + Mesgs.hash[validPath] + SK.CHAR_UNDERLINE + SK.getCurrentLanguage() + SK.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 Proxy0.$.ajax({
        async: async,
        cache: false,
        dataType: SK.FILE_TYPE_JSON,
        method: SK.REQUEST_METHOD_GET,
        url: Mesgs.SERVER_URL + Mesgs.PATH_PREFIX + Mesgs.PART_OF_HASH_PATH + SK.getCurrentLanguage() + SK.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 Proxy0._.startsWith(existPath, path);
      }).forEach(function (existPath) {
        delete Mesgs.mesg[existPath];
      });
    }
  }]);

  return Mesgs;
}();

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