@bchr/bchr-front-lib 0.4.4 → 0.5.1-alpha-20241221

package/lib/base/utils/FormDatas.js

@@ -0,0 +1,109 @@
+"use strict";
+
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.convertVO2FormValuesUsingFormValueFormat = exports.convertFormValues2VOUsingVOFormat = void 0;
+
+var _lodash = _interopRequireWildcard(require("lodash"));
+
+var _LangTypes = _interopRequireDefault(require("./LangTypes"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+var convertFormValues2VOUsingVOFormat = function convertFormValues2VOUsingVOFormat(values) {
+  if (!values) {
+    return null;
+  }
+
+  var vo = {};
+  var attrs = Object.keys(values);
+
+  for (var i = 0, length = attrs.length; i < length; i++) {
+    var attr = attrs[i];
+    var attrValue = values[attr];
+
+    if (attrValue === null || attrValue === void 0) {
+      continue;
+    }
+
+    if (_lodash["default"].isString(attrValue)) {
+      vo[attr] = attrValue;
+    } else if (_lodash["default"].isNumber(attrValue)) {
+      if (!Number.isNaN(attrValue)) {
+        vo[attr] = attrValue;
+      }
+    } else if (_lodash["default"].isBoolean(attrValue)) {
+      vo[attr] = attrValue;
+    } else if (_lodash["default"].isDate(attrValue)) {
+      vo[attr] = attrValue;
+    } else if (_lodash["default"].isArray(attrValue)) {
+      vo[attr] = attrValue.join(",");
+    } else if (_lodash["default"].isObject(attrValue) && attr.endsWith("_pk") && attrValue.label !== null && attrValue.value !== null && Object.keys(attrValue)) {
+      if (attrValue._inputCreateOnly === true) {
+        vo[attr] = -1;
+        vo[attr.substring(0, attr.length - 3) + "_ext_name"] = attrValue.label;
+      } else {
+        vo[attr] = attrValue.value;
+        vo[attr.substring(0, attr.length - 3) + "_ext_name"] = attrValue.label;
+      }
+    }
+  }
+
+  return vo;
+};
+
+exports.convertFormValues2VOUsingVOFormat = convertFormValues2VOUsingVOFormat;
+
+var convertVO2FormValuesUsingFormValueFormat = function convertVO2FormValuesUsingFormValueFormat(voValue, attrNameArrayForMultiSelect) {
+  if (!voValue) {
+    return null;
+  }
+
+  var formValues = {};
+  var attrs = Object.keys(voValue);
+
+  for (var i = 0, length = attrs.length; i < length; i++) {
+    var attr = attrs[i];
+    var attrValue = voValue[attr];
+
+    if (attrValue === null) {
+      continue;
+    }
+
+    if ((0, _lodash.isPlainObject)(attrValue)) {
+      formValues[attr] = convertVO2FormValuesUsingFormValueFormat(attrValue, attrNameArrayForMultiSelect);
+    } else if (attr.endsWith("_pk")) {
+      formValues[attr] = {
+        value: attrValue,
+        label: voValue[attr.substring(0, attr.length - 3) + "_ext_name"]
+      };
+    } else if (attr.endsWith("status")) {
+      formValues[attr] = _LangTypes["default"].asBooleanValue(attrValue);
+    } else {
+      formValues[attr] = attrValue;
+    }
+  }
+
+  if (attrNameArrayForMultiSelect && attrNameArrayForMultiSelect.length > 0) {
+    for (var _i = 0, _length = attrNameArrayForMultiSelect.length; _i < _length; _i++) {
+      var attrName = attrNameArrayForMultiSelect[_i];
+
+      if (attrName) {
+        if (formValues[attrName] && formValues[attrName].split) {
+          formValues[attrName] = formValues[attrName].split(",");
+        }
+      }
+    }
+  }
+
+  return formValues;
+};
+
+exports.convertVO2FormValuesUsingFormValueFormat = convertVO2FormValuesUsingFormValueFormat;

package/lib/base/utils/LangTypes.js

@@ -0,0 +1,173 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _moment = _interopRequireDefault(require("moment"));
+
+var _decimal = _interopRequireDefault(require("decimal.js"));
+
+var _lodash = _interopRequireDefault(require("lodash"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+var LangTypes = {
+  asStringValue: function asStringValue(rawValue) {
+    if (rawValue === null || rawValue === void 0) {
+      return null;
+    }
+
+    if (_lodash["default"].isString(rawValue)) {
+      return rawValue.toString();
+    } else if (_lodash["default"].isNumber(rawValue)) {
+      return rawValue.toString();
+    } else if (_lodash["default"].isBoolean(rawValue)) {
+      return rawValue.toString();
+    } else if (_lodash["default"].isDate(rawValue)) {
+      return (0, _moment["default"])(rawValue).format("YYYY-MM-DD HH:mm:ss");
+    } else if (_lodash["default"].isFunction(rawValue.isValid) && _lodash["default"].isFunction(rawValue.toDate)) {
+      if (rawValue.isValid() === true) {
+        return (0, _moment["default"])(rawValue.toDate()).format("YYYY-MM-DD HH:mm:ss");
+      }
+    } else if (_lodash["default"].isPlainObject(rawValue) && Object.prototype.hasOwnProperty.call(rawValue, "value")) {
+      return this.asStringValue(rawValue.value);
+    }
+
+    throw new Error("For type safe convert, " + rawValue + " cannot convert to String value.");
+  },
+  asBooleanValue: function asBooleanValue(rawValue) {
+    if (rawValue === null || rawValue === void 0) {
+      return false;
+    } else if (_lodash["default"].isBoolean(rawValue)) {
+      return rawValue;
+    } else if (_lodash["default"].isString(rawValue)) {
+      var lowercaseValue = rawValue.toLowerCase();
+      return lowercaseValue === "y" || lowercaseValue === "yes" || lowercaseValue === "true" || lowercaseValue === "t" || lowercaseValue === "1" || lowercaseValue === "是" || lowercaseValue === "ok" || lowercaseValue === "on";
+    } else if (_lodash["default"].isNumber(rawValue)) {
+      return Boolean(rawValue);
+    } else if (_lodash["default"].isPlainObject(rawValue) && Object.prototype.hasOwnProperty.call(rawValue, "value")) {
+      return this.asBooleanValue(rawValue.value);
+    }
+
+    throw new Error("For type safe convert, " + rawValue + " cannot convert to Boolean value.");
+  },
+  asNumberValue: function asNumberValue(rawValue) {
+    if (rawValue === null || rawValue === void 0) {
+      return 0;
+    } else if (_lodash["default"].isNumber(rawValue)) {
+      return rawValue;
+    } else if (_lodash["default"].isBoolean(rawValue)) {
+      return rawValue ? 1 : 0;
+    } else if (_lodash["default"].isString(rawValue)) {
+      var _rawValue = rawValue.replaceAll(",", "").replaceAll(' ', '');
+
+      try {
+        var decimalValue = new _decimal["default"](_rawValue);
+        return decimalValue.toNumber();
+      } catch (e) {// do nothing
+      }
+    } else if (_lodash["default"].isDate(rawValue)) {
+      return rawValue.getTime();
+    } else if (_lodash["default"].isFunction(rawValue.isValid) && _lodash["default"].isFunction(rawValue.toDate)) {
+      if (rawValue.isValid() === true) {
+        return rawValue.toDate().getTime();
+      }
+    } else if (_lodash["default"].isPlainObject(rawValue) && Object.prototype.hasOwnProperty.call(rawValue, "value")) {
+      return this.asNumberValue(rawValue.value);
+    }
+
+    throw new Error("For type safe convert, " + rawValue + " cannot convert to Number value.");
+  },
+  asIntegerValue: function asIntegerValue(rawValue) {
+    if (rawValue === null || rawValue === void 0) {
+      return 0;
+    } else if (_lodash["default"].isInteger(rawValue)) {
+      return rawValue;
+    } else if (_lodash["default"].isBoolean(rawValue)) {
+      return rawValue ? 1 : 0;
+    } else if (_lodash["default"].isString(rawValue)) {
+      var _rawValue = rawValue.replaceAll(",", "").replaceAll(' ', '');
+
+      try {
+        var decimalValue = new _decimal["default"](_rawValue);
+
+        if (decimalValue.isInteger()) {
+          return decimalValue.toNumber();
+        }
+      } catch (e) {// do nothing
+      }
+    } else if (_lodash["default"].isDate(rawValue)) {
+      return rawValue.getTime();
+    } else if (_lodash["default"].isFunction(rawValue.isValid) && _lodash["default"].isFunction(rawValue.toDate)) {
+      if (rawValue.isValid() === true) {
+        return rawValue.toDate().getTime();
+      }
+    } else if (_lodash["default"].isPlainObject(rawValue) && Object.prototype.hasOwnProperty.call(rawValue, "value")) {
+      return this.asIntegerValue(rawValue.value);
+    }
+
+    throw new Error("For type safe convert, " + rawValue + " cannot convert to Integer value.");
+  },
+  asDateValue: function asDateValue(rawValue) {
+    if (rawValue === null || rawValue === void 0) {
+      return null;
+    } else if (_lodash["default"].isInteger(rawValue)) {
+      return new Date(rawValue);
+    } else if (_lodash["default"].isString(rawValue)) {
+      var day = (0, _moment["default"])(rawValue);
+
+      if (day.isValid()) {
+        return day.toDate();
+      }
+    } else if (_lodash["default"].isDate(rawValue)) {
+      return rawValue;
+    } else if (_lodash["default"].isFunction(rawValue.isValid) && _lodash["default"].isFunction(rawValue.toDate)) {
+      if (rawValue.isValid() === true) {
+        return rawValue.toDate();
+      }
+    } else if (_lodash["default"].isPlainObject(rawValue) && Object.prototype.hasOwnProperty.call(rawValue, "value")) {
+      return this.asDateValue(rawValue.value);
+    }
+
+    throw new Error("For type safe convert, " + rawValue + " cannot convert to Date value.");
+  },
+
+  /**
+   * used for Framework model data type check
+   */
+  isBooleanType: function isBooleanType(typeExpression) {
+    return typeExpression === Boolean || (typeExpression === null || typeExpression === void 0 ? void 0 : typeExpression.toLowerCase()) === "boolean" || (typeExpression === null || typeExpression === void 0 ? void 0 : typeExpression.toLowerCase()) === "bool";
+  },
+
+  /**
+   * used for Framework model data type check
+   */
+  isStringType: function isStringType(typeExpression) {
+    return typeExpression === null || typeExpression === void 0 || typeExpression === String || (typeExpression === null || typeExpression === void 0 ? void 0 : typeExpression.toLowerCase()) === "string" || typeExpression === "";
+  },
+
+  /**
+   * used for Framework model data type check
+   */
+  isDateType: function isDateType(typeExpression) {
+    return typeExpression === Date || (typeExpression === null || typeExpression === void 0 ? void 0 : typeExpression.toLowerCase()) === "date";
+  },
+
+  /**
+   * used for Framework model data type check
+   */
+  isNumberType: function isNumberType(typeExpression) {
+    return typeExpression === Number || (typeExpression === null || typeExpression === void 0 ? void 0 : typeExpression.toLowerCase()) === "number";
+  },
+
+  /**
+   * used for Framework model data type check
+   */
+  isObjectType: function isObjectType(typeExpression) {
+    return typeExpression === Object || (typeExpression === null || typeExpression === void 0 ? void 0 : typeExpression.toLowerCase()) === "object";
+  }
+};
+var _default = LangTypes;
+exports["default"] = _default;

package/lib/base/utils/Objects.js

@@ -0,0 +1,60 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _lodash = _interopRequireDefault(require("lodash"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+var genGetterAndReadonlySetter = function genGetterAndReadonlySetter(plainObject) {
+  var retObject = {};
+
+  var _loop = function _loop(attrName) {
+    Object.defineProperty(retObject, attrName, {
+      get: function get() {
+        return plainObject[attrName];
+      },
+      set: function set(x) {
+        throw new Error("Cannot Set value for readonly attribute");
+      }
+    });
+  };
+
+  for (var attrName in plainObject) {
+    _loop(attrName);
+  }
+
+  return retObject;
+};
+
+var isPromise = function isPromise(value) {
+  return _lodash["default"].isObject(value) && _lodash["default"].isFunction(value.then) && _lodash["default"].isFunction(value["catch"]) && _lodash["default"].isFunction(value["finally"]);
+};
+
+var toStdPromise = function toStdPromise(thenableObject) {
+  if (_lodash["default"].isFunction(thenableObject.then)) {
+    return Promise.resolve(thenableObject);
+  }
+
+  throw new Error("Not thenable Object, cannot convert to Standard Promise.");
+};
+
+var clone = function clone(value) {
+  if (value === null || value === void 0) {
+    return null;
+  }
+
+  return _lodash["default"].cloneDeep(value);
+};
+
+var Objects = {
+  genGetterAndReadonlySetter: genGetterAndReadonlySetter,
+  clone: clone,
+  isPromise: isPromise,
+  toStdPromise: toStdPromise
+};
+var _default = Objects;
+exports["default"] = _default;

package/lib/base/utils/Randoms.js

@@ -0,0 +1,146 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = exports.CHARS = exports.UPPER_CASE_ALPHABETS = exports.LOWER_CASE_ALPHABETS = exports.ALPHABETS = exports.NUMBERS = void 0;
+
+var _lodash = _interopRequireDefault(require("lodash"));
+
+var _reactUuid = _interopRequireDefault(require("react-uuid"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+var NUMBERS = "0123456789";
+exports.NUMBERS = NUMBERS;
+var ALPHABETS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+exports.ALPHABETS = ALPHABETS;
+var LOWER_CASE_ALPHABETS = "abcdefghijklmnopqrstuvwxyz";
+exports.LOWER_CASE_ALPHABETS = LOWER_CASE_ALPHABETS;
+var UPPER_CASE_ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+exports.UPPER_CASE_ALPHABETS = UPPER_CASE_ALPHABETS;
+var CHARS = ALPHABETS + NUMBERS;
+exports.CHARS = CHARS;
+var Randoms = {
+  /**
+   * Gen the value between the min integer Value and max integer Value.
+   * when only supply one parameter, the parameter as the max Integer Value.
+   * @param minValue
+   * @param maxValue
+   * @returns {number}
+   */
+  randomInt: function randomInt(minValue, maxValue) {
+    var minIntegerValue = 0;
+    var maxIntegerValue = Number.MAX_SAFE_INTEGER;
+
+    if (_lodash["default"].isInteger(minValue) && _lodash["default"].isInteger(maxValue) && maxValue > minValue) {
+      minIntegerValue = minValue;
+      maxIntegerValue = maxValue;
+    }
+
+    if (_lodash["default"].isInteger(minValue) && arguments.length == 1) {
+      if (minValue > 0) {
+        minIntegerValue = 0;
+        maxIntegerValue = minValue;
+      } else if (minValue < 0) {
+        minIntegerValue = minValue;
+        maxIntegerValue = 0;
+      }
+    }
+
+    return Math.floor(Math.random() * (maxIntegerValue - minIntegerValue + 1)) + minIntegerValue;
+  },
+
+  /**
+   * @param genStrLength
+   * @returns {string}
+   */
+  randomString: function randomString(genStrLength) {
+    if (!_lodash["default"].isInteger(genStrLength)) {
+      throw new Error("Invalid string length for generate random String.");
+    }
+
+    var genString = "";
+    var charsArrayLength = CHARS.length;
+
+    for (var i = 0; i < genStrLength; i++) {
+      var number = this.randomInt(charsArrayLength - 1);
+      genString = genString + CHARS.charAt(number);
+    }
+
+    return genString;
+  },
+  randomAlphabets: function randomAlphabets(genStrLength) {
+    if (!_lodash["default"].isInteger(genStrLength)) {
+      throw new Error("Invalid string length for generate random Alphabets.");
+    }
+
+    var genString = "";
+    var charsArrayLength = ALPHABETS.length;
+
+    for (var i = 0; i < genStrLength; i++) {
+      var number = this.randomInt(charsArrayLength - 1);
+      genString = genString + ALPHABETS.charAt(number);
+    }
+
+    return genString;
+  },
+  randomLowercaseAlphabets: function randomLowercaseAlphabets(genStrLength) {
+    if (!_lodash["default"].isInteger(genStrLength)) {
+      throw new Error("Invalid string length for generate random uppercase Alphabets.");
+    }
+
+    var genString = "";
+    var charsArrayLength = LOWER_CASE_ALPHABETS.length;
+
+    for (var i = 0; i < genStrLength; i++) {
+      var number = this.randomInt(charsArrayLength - 1);
+      genString = genString + LOWER_CASE_ALPHABETS.charAt(number);
+    }
+
+    return genString;
+  },
+  randomUppercaseAlphabets: function randomUppercaseAlphabets(genStrLength) {
+    if (!_lodash["default"].isInteger(genStrLength)) {
+      throw new Error("Invalid string length for generate random lowercase Alphabets.");
+    }
+
+    var genString = "";
+    var charsArrayLength = UPPER_CASE_ALPHABETS.length;
+
+    for (var i = 0; i < genStrLength; i++) {
+      var number = this.randomInt(charsArrayLength - 1);
+      genString = genString + UPPER_CASE_ALPHABETS.charAt(number);
+    }
+
+    return genString;
+  },
+  randomStringsIn: function randomStringsIn(scopedStrings, genStrLength) {
+    if (!_lodash["default"].isString(scopedStrings)) {
+      throw new Error("Invalid scopedStrings for generate random strings.");
+    }
+
+    if (scopedStrings.length < 1) {
+      throw new Error("Invalid scopedStrings for generate random strings.");
+    }
+
+    if (!_lodash["default"].isInteger(genStrLength)) {
+      throw new Error("Invalid string length for generate random lowercase Alphabets.");
+    }
+
+    var genString = "";
+    var charsArrayLength = scopedStrings.length;
+
+    for (var i = 0; i < genStrLength; i++) {
+      var number = this.randomInt(charsArrayLength - 1);
+      genString = genString + scopedStrings.charAt(number);
+    }
+
+    return genString;
+  },
+  uuid: function uuid() {
+    return (0, _reactUuid["default"])();
+  }
+};
+var _default = Randoms;
+exports["default"] = _default;

package/lib/base/utils/Strings.js

@@ -0,0 +1,154 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _lodash = _interopRequireDefault(require("lodash"));
+
+var _LangTypes = _interopRequireDefault(require("./LangTypes"));
+
+var _IllegalArgumentError = _interopRequireDefault(require("../error/IllegalArgumentError"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+var isWhitespace = function isWhitespace(c) {
+  if (c === null || c === void 0) {
+    return false;
+  }
+
+  var stringAfterTrim = c.trim();
+  return !(stringAfterTrim === c);
+};
+
+var Strings = {
+  isBlankString: function isBlankString(value) {
+    if (value === null || value === void 0) {
+      return true;
+    }
+
+    if (_lodash["default"].isString(value)) {
+      for (var i = 0, len = value.length; i < len; i++) {
+        var str = value.charAt(i);
+
+        if (!isWhitespace(str)) {
+          return false;
+        }
+      }
+
+      return true;
+    }
+
+    return false;
+  },
+  isNotBlankString: function isNotBlankString(value) {
+    if (value === null || value === void 0) {
+      return false;
+    }
+
+    if (_lodash["default"].isString(value)) {
+      return !this.isBlankString(value);
+    }
+
+    return false;
+  },
+  removeBlankStrings: function removeBlankStrings(value) {
+    if (value === null || value === void 0) {
+      return null;
+    }
+
+    if (!_lodash["default"].isString(value)) {
+      throw new _IllegalArgumentError["default"]("Invalid value [" + value + "] for Strings#removeBlankStrings");
+    }
+
+    var lastString = "";
+
+    for (var i = 0, len = value.length; i < len; i++) {
+      var str = value.charAt(i);
+
+      if (!isWhitespace(str)) {
+        lastString = lastString + str;
+      }
+    }
+
+    return lastString;
+  },
+  isEmail: function isEmail(value) {
+    if (!_lodash["default"].isString(value)) {
+      return false;
+    }
+
+    return new RegExp(/^(([^<>()[\]\\.,;:\s@"]+(\.[^<>()[\]\\.,;:\s@"]+)*)|.(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/).test(value);
+  },
+
+  /**
+   * 检测密码强度
+   * @param password {string}
+   *      密码
+   * @param minLength
+   *      最小长度 默认8位，最小4位;
+   * @returns
+   *      强度等级: [0,1,2,3,4]
+   */
+  checkPasswordStrength: function checkPasswordStrength(password) {
+    var minLength = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 8;
+    var level = 0;
+
+    if (password === null || password === void 0) {
+      return level;
+    }
+
+    if (minLength < 4) {
+      minLength = 4;
+    }
+
+    var _password = _LangTypes["default"].asStringValue(password);
+
+    if (_password.length < minLength) {
+      return level;
+    }
+
+    if (/[0-9]/.test(_password)) {
+      level++;
+    }
+
+    if (/[a-z]/.test(_password)) {
+      level++;
+    }
+
+    if (/[A-Z]/.test(_password)) {
+      level++;
+    }
+
+    if (/\W/.test(_password)) {
+      level++;
+    }
+
+    return level;
+  },
+  isUppercase: function isUppercase(str) {
+    if (str === null || str === void 0) {
+      return false;
+    }
+
+    if (_lodash["default"].isString(str)) {
+      return str === str.toUpperCase();
+    }
+
+    return false;
+  },
+  isLowercase: function isLowercase(str) {
+    if (str === null || str === void 0) {
+      return false;
+    }
+
+    if (_lodash["default"].isString(str)) {
+      return str === str.toLowerCase();
+    }
+
+    return false;
+  }
+};
+var _default = Strings;
+exports["default"] = _default;