zet-lib 1.4.13 → 1.4.14

package/lib/Util.js

@@ -7,241 +7,144 @@ const sha256 = require("js-sha256");
 
 const Util = {};
 
+// Constants
 Util.tab = "\t";
-Util.tabs = (n) => {
-  let ret = "";
-  for (var i = 0; i < n; i++) {
-    ret += Util.tab;
-  }
-  return ret;
-};
-
 Util.NEW_LINE = "\n";
 Util.newLine = "\r\n";
-Util.newLines = (n) => {
-  let ret = "";
-  for (var i = 0; i < n; i++) {
-    ret += Util.newLine;
-  }
-  return ret;
-};
 
-//sha256
-Util.hash = (string) => {
-  return sha256(string);
-};
+// Optimized string generation functions
+Util.tabs = (n) => Util.tab.repeat(n);
+Util.newLines = (n) => Util.newLine.repeat(n);
 
-Util.hashCompare = (myPlaintextPassword, hash) => {
-  return Util.hash(myPlaintextPassword) == hash;
-};
+// Hashing functions
+Util.hash = (string) => sha256(string);
+Util.hashCompare = (myPlaintextPassword, hash) =>
+  Util.hash(myPlaintextPassword) === hash;
 
+// Excel sequence generator - optimized with memoization
+const excelSequenceCache = new Map();
 Util.excelSequence = function () {
-  let abjads = [
-    "A",
-    "B",
-    "C",
-    "D",
-    "E",
-    "F",
-    "G",
-    "H",
-    "I",
-    "J",
-    "K",
-    "L",
-    "M",
-    "N",
-    "O",
-    "P",
-    "Q",
-    "R",
-    "S",
-    "T",
-    "U",
-    "V",
-    "W",
-    "X",
-    "Y",
-    "Z",
-  ];
-  let arr = abjads;
-  let char = 0;
+  if (excelSequenceCache.has("sequence")) {
+    return excelSequenceCache.get("sequence");
+  }
+
+  const abjads = Array.from({ length: 26 }, (_, i) =>
+    String.fromCharCode(65 + i)
+  );
+  const arr = [...abjads];
   let num = 26;
-  for (let x = 2; x < 15; x++) {
-    let idx = 0;
-    for (let i = 1; i <= 26; i++) {
-      arr[num] = abjads[char] + abjads[idx];
-      idx++;
-      num++;
+
+  for (let char = 0; char < 13; char++) {
+    for (let idx = 0; idx < 26; idx++) {
+      arr[num++] = abjads[char] + abjads[idx];
     }
-    char++;
   }
 
+  excelSequenceCache.set("sequence", arr);
   return arr;
 };
 
-Util.now = function () {
-  return moment(new Date()).format("YYYY-MM-DD HH:mm:ss");
-};
+// Date utilities - optimized with consistent formatting
+Util.now = () => moment().format("YYYY-MM-DD HH:mm:ss");
+Util.nowShort = () => moment().format("YYYY-MM-DD");
+Util.ago = (date) => moment(date).fromNow();
 
-Util.nowShort = function () {
-  return moment(new Date()).format("YYYY-MM-DD");
-};
+// Optimized date formatting functions
+const defaultDateFormat = "YYYY-MM-DD";
+const defaultTimeFormat = "YYYY-MM-DD HH:mm:ss";
 
-Util.ago = (data) => {
-  return moment(data).fromNow();
-};
-/*
- moment get one month ago from current
- var monthago = moment().subtract(1, 'months').format('YYYY-MM-DD');
-
- */
+Util.dateSql = (date, format = defaultDateFormat) =>
+  date && date !== "0000-00-00" ? moment(date).format(format) : "";
 
-Util.dateSql = function (date, format) {
-  format = format || "YYYY-MM-DD";
-  if (date && date != "0000-00-00") return moment(date).format(format);
-  else return "";
-};
+Util.dateOriginal = (date) =>
+  date && date !== "0000-00-00" ? moment(date).utc(false) : "";
 
-Util.dateOriginal = function (date) {
-  if (date && date != "0000-00-00") {
-    let value = moment(date).utc(false);
-    return value;
-  } else {
-    return "";
-  }
-};
+Util.dateFormat = (date, format = defaultDateFormat) =>
+  date && date !== "0000-00-00" ? moment(date).format(format) : "";
 
-Util.dateFormat = function (date, format) {
-  format = format || "YYYY-MM-DD";
-  if (date && date != "0000-00-00") return moment(date).format(format);
-  else return "";
-};
+Util.timePublic = (date) => (date ? moment(date).format("DD MMM YYYY") : "");
 
-Util.timePublic = function (date) {
-  if (date) return moment(date).format("DD MMM YYYY");
-  else return "";
-};
+Util.timeSql = (date, format = defaultTimeFormat) =>
+  date && date !== "0000-00-00 00:00:00" ? moment(date).format(format) : "";
 
-Util.timeSql = function (date, format) {
-  if (date && date != "0000-00-00 00:00:00") {
-    format = format || "YYYY-MM-DD HH:mm:ss";
-    return moment(date).format(format);
-  } else return "";
-};
+// Optimized date difference calculation
+Util.dateDiff = (start, end, format = "months") =>
+  start && end ? moment(end).diff(moment(start), format, true) : 0;
 
-//moment('2017-11-30T15:00:00-07:00').diff(moment('2017-05-31T15:00:00-07:00'), 'months')
-Util.dateDiff = (start, end, format = "months") => {
-  let count = 0;
-  if (start && end) {
-    count = moment(end).diff(moment(start), format, true);
-  }
-  return count;
-};
+// Optimized date parsing
+Util.getDate = (date = "") => {
+  if (!date) return { year: 0, month: 0, date: 0 };
 
-Util.getDate = function (date) {
-  date = date + "" || "";
-  if (date != "") {
-    let explode = date.split("-");
-    return {
-      year: parseInt(explode[0]),
-      month: parseInt(explode[1]),
-      date: parseInt(explode[2]),
-    };
-  } else {
-    return {
-      year: 0,
-      month: 0,
-      date: 0,
-    };
-  }
+  const [year, month, day] = date.split("-").map(Number);
+  return { year, month, date: day };
 };
 
+// Optimized date range check
 Util.dateIsBetween = (compare, start, end) => {
-  if (compare == "" || compare == "0000-00-00") {
-    return false;
-  }
-  compare = moment(compare).format("YYYY-MM-DD");
-  start = moment(start).format("YYYY-MM-DD");
-  end = moment(end).format("YYYY-MM-DD");
-  let today = moment(compare);
-  let startDate = moment(start);
-  let endDate = moment(end);
-
-  if (compare == start) {
-    return true;
-  } else if (compare == end) {
-    return true;
-  } else {
-    return today.isBetween(startDate, endDate);
-  }
-};
+  if (!compare || compare === "0000-00-00") return false;
 
-Util.getMonth = function (date) {
-  if (date.length > 5) {
-    let n = new Date(date);
-    let m = n.getMonth();
-    return parseInt(m) + 1;
-  }
-  return 0;
-};
+  const compareDate = moment(compare);
+  const startDate = moment(start);
+  const endDate = moment(end);
 
-Util.getYear = function (date) {
-  date = Util.dateSql(date) || "";
-  return date.slice(0, 4);
+  return (
+    compareDate.isSame(startDate) ||
+    compareDate.isSame(endDate) ||
+    compareDate.isBetween(startDate, endDate)
+  );
 };
 
-//first is smaller than second
+// Optimized month and year extraction
+Util.getMonth = (date) =>
+  date?.length > 5 ? new Date(date).getMonth() + 1 : 0;
+
+Util.getYear = (date) => Util.dateSql(date)?.slice(0, 4) || "";
+
+// Optimized day calculation with memoization
+const dayCalculationCache = new Map();
 Util.calculateDay = function (from, to, holidayInWeek = 0) {
+  const cacheKey = `${from}-${to}-${holidayInWeek}`;
+  if (dayCalculationCache.has(cacheKey)) {
+    return dayCalculationCache.get(cacheKey);
+  }
+
   holidayInWeek = parseInt(holidayInWeek) || 0;
-  let count = 0;
-  if (holidayInWeek == 1) {
-    let days = Util.enumerateDaysBetweenDates(
+  let count;
+
+  if (holidayInWeek === 1) {
+    const days = Util.enumerateDaysBetweenDates(
       moment(from).format("YYYY-MM-DD"),
       moment(to).format("YYYY-MM-DD")
     );
-    let countdays = days.filter(
-      (item) => parseInt(moment(item).format("d")) != 0
-    );
-    count = countdays.length;
-  } else if (holidayInWeek == 2) {
-    let days = Util.enumerateDaysBetweenDates(
+    count = days.filter((item) => moment(item).day() !== 0).length;
+  } else if (holidayInWeek === 2) {
+    const days = Util.enumerateDaysBetweenDates(
       moment(from).format("YYYY-MM-DD"),
       moment(to).format("YYYY-MM-DD")
     );
-    let countdays = days.filter(
-      (item) =>
-        parseInt(moment(item).format("d")) != 0 &&
-        parseInt(moment(item).format("d")) != 6
-    );
-    count = countdays.length;
+    count = days.filter((item) => {
+      const day = moment(item).day();
+      return day !== 0 && day !== 6;
+    }).length;
   } else {
-    let a = moment(from);
-    let b = moment(to);
-    count = b.diff(a, "days") + 1;
+    count = moment(to).diff(moment(from), "days") + 1;
   }
 
+  dayCalculationCache.set(cacheKey, count);
   return count;
 };
 
-var getDaysBetweenDates = function (startDate, endDate) {
-  let now = startDate.clone(),
-    dates = [];
-  while (now.isSameOrBefore(endDate)) {
-    dates.push(now.format("MM/DD/YYYY"));
-    now.add(1, "days");
-  }
-  return dates;
-};
-
-//itterate days in array
+// Optimized date enumeration
 Util.enumerateDaysBetweenDates = function (startDate, endDate) {
-  let now = moment(startDate).clone(),
-    dates = [];
-  while (now.isSameOrBefore(endDate)) {
-    dates.push(now.format("MM/DD/YYYY"));
-    now.add(1, "days");
+  const dates = [];
+  const current = moment(startDate);
+  const end = moment(endDate);
+
+  while (current.isSameOrBefore(end)) {
+    dates.push(current.format("MM/DD/YYYY"));
+    current.add(1, "days");
   }
+
   return dates;
 };
 
@@ -1542,8 +1445,8 @@ Util.tableShowInGrid = (arr, qey, MYMODEL, myCache, companyId) => {
           var keyFields = key + "Fields";
           var keyObject = key + "Object";
           let value = item[key];
-          if(mywidget[key].name == "select"){
-            value = mywidget[key].fields[value] || ""
+          if (mywidget[key].name == "select") {
+            value = mywidget[key].fields[value] || "";
           } else if (mywidget[key].name == "relation") {
             value = value
               ? Util.array_id_to_zname(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zet-lib",
-  "version": "1.4.13",
+  "version": "1.4.14",
   "description": "zet is a library that part of zet generator.",
   "engines": {
     "node": ">=18"