@gct-paas/render 0.1.4-dev.7 → 0.1.4-dev.9

package/es/utils/expression/regularExpression/methods.mjs

@@ -0,0 +1,729 @@
+import { isEqual, isNull, isUndefined } from 'lodash-es';
+import dayjs from 'dayjs';
+import utc from 'dayjs/plugin/utc';
+import timezone from 'dayjs/plugin/timezone';
+import quarterOfYear from 'dayjs/plugin/quarterOfYear';
+import toArray from 'dayjs/plugin/toArray';
+import isoWeek from 'dayjs/plugin/isoWeek';
+import BigNumberJS from 'bignumber.js';
+
+dayjs.extend(utc);
+dayjs.extend(timezone);
+dayjs.extend(quarterOfYear);
+dayjs.extend(toArray);
+dayjs.extend(isoWeek);
+function IF(expr, v, l) {
+  const fn = () => {
+    return expr ? v : l;
+  };
+  const isIfFn = fn;
+  return isIfFn();
+}
+function ISEMPTY(v) {
+  const func = () => v == null || v === "" || v === 0;
+  const isEmptyFn = func;
+  return isEmptyFn();
+}
+function ISNULL(v) {
+  const func = () => isNull(v);
+  const isNullFn = func;
+  return isNullFn();
+}
+function ISUNDEFINED(v) {
+  const func = () => isUndefined(v);
+  const isUndefinedFn = func;
+  return isUndefinedFn();
+}
+function AND(...e) {
+  const func = () => {
+    for (const i of e) {
+      if (!i) return false;
+    }
+    return true;
+  };
+  const isAndFn = func;
+  return isAndFn();
+}
+function OR(...e) {
+  const func = () => e.some((i) => i);
+  const isOrFn = func;
+  return isOrFn();
+}
+function EQ(v, o) {
+  const func = () => isEqual(v, o);
+  const isEqFn = func;
+  return isEqFn();
+}
+function NE(v, o) {
+  const func = () => v !== o;
+  const isNotEqual = func;
+  return isNotEqual();
+}
+function LE(v, o) {
+  const fn = () => {
+    if (typeof v === "number" && typeof o === "number" || typeof v === "string" && typeof o === "string" || v instanceof Date && o instanceof Date) {
+      if (v <= o) {
+        return true;
+      } else {
+        return false;
+      }
+    } else {
+      return false;
+    }
+  };
+  const isLeFn = fn;
+  return isLeFn();
+}
+function LT(v, o) {
+  const fn = () => {
+    if (typeof v === "number" && typeof o === "number" || typeof v === "string" && typeof o === "string" || v instanceof Date && o instanceof Date) {
+      return v < o;
+    } else {
+      return false;
+    }
+  };
+  const isLtFn = fn;
+  return isLtFn();
+}
+function GE(v, o) {
+  const fn = () => {
+    if (typeof v === "number" && typeof o === "number" || typeof v === "string" && typeof o === "string" || v instanceof Date && o instanceof Date) {
+      if (v >= o) {
+        return true;
+      } else {
+        return false;
+      }
+    } else {
+      return false;
+    }
+  };
+  const isGeFn = fn;
+  return isGeFn();
+}
+function GT(v, o) {
+  const fn = () => {
+    if (typeof v === "number" && typeof o === "number" || typeof v === "string" && typeof o === "string" || v instanceof Date && o instanceof Date) {
+      if (v > o) {
+        return true;
+      } else {
+        return false;
+      }
+    } else {
+      return false;
+    }
+  };
+  const isGtFn = fn;
+  return isGtFn();
+}
+function LEN(v) {
+  const fn = () => v?.length || 0;
+  const isLenFn = fn;
+  return isLenFn();
+}
+function CONCAT(...args) {
+  const fn = () => args.join("");
+  const isConcatFn = fn;
+  return isConcatFn();
+}
+function SUBSTRING(v = "", s, e) {
+  const fn = () => {
+    const val = (s < 0 ? [...v].reverse().join("") : v).slice(
+      Math.abs(s + Number(s < 0)),
+      Math.abs(e) + Number(s >= 0)
+    );
+    return s < 0 ? [...val].reverse().join("") : val;
+  };
+  const isSubstringFn = fn;
+  return isSubstringFn();
+}
+function SUBSTR(v = "", s, l) {
+  const fn = () => {
+    const val = (s < 0 ? [...v].reverse().join("") : v).slice(
+      Math.abs(s + Number(s < 0)),
+      Math.abs(s + Number(s < 0)) + Math.abs(l)
+    );
+    return s < 0 ? [...val].reverse().join("") : val;
+  };
+  const isSubstrFn = fn;
+  return isSubstrFn();
+}
+function UPPER(v = "") {
+  const fn = () => v.toUpperCase();
+  const isUpperFn = fn;
+  return isUpperFn();
+}
+function LOWER(v = "") {
+  const fn = () => v.toLowerCase();
+  const isLowerFn = fn;
+  return isLowerFn();
+}
+function TRIM(v = "") {
+  const fn = () => v.trim();
+  const isTrimFn = fn;
+  return isTrimFn();
+}
+function LTRIM(v = "") {
+  const fn = () => v.replace(/^\s\s*/, "");
+  const isTrimFn = fn;
+  return isTrimFn();
+}
+function RTRIM(v = "") {
+  const fn = () => v.replace(/\s\s*$/, "");
+  const isTrimFn = fn;
+  return isTrimFn();
+}
+function REPEAT(v = "", c = "") {
+  const fn = () => v.match(new RegExp(c, "g"))?.length || null;
+  const isRepeatFn = fn;
+  return isRepeatFn();
+}
+function REPLACE(v = "", o = "", t = "") {
+  const fn = () => v.replace(new RegExp(o, "g"), t);
+  const isReplaceFn = fn;
+  return isReplaceFn();
+}
+function FINDSTR(v = "", c = "") {
+  const fn = () => v.includes(c);
+  const isFindStrFn = fn;
+  return isFindStrFn();
+}
+function SEARCHSTR(v = "", c = "") {
+  const fn = () => {
+    const l = v.match(new RegExp(c, "g"))?.length;
+    return l ? l : 0;
+  };
+  const isSearchstrFn = fn;
+  return isSearchstrFn();
+}
+function PARSENUMBER(v = "") {
+  const fn = () => {
+    const num = parseFloat(v);
+    return isNaN(num) ? null : num;
+  };
+  const isParsenumberFn = fn;
+  return isParsenumberFn();
+}
+function SPLIT(v = "", c = "") {
+  const fn = () => v.split(c);
+  const isSplitFn = fn;
+  return isSplitFn();
+}
+function SUM(...args) {
+  const v = args.flat().filter((i) => i !== "" && i !== null && i !== void 0);
+  if (!v.length) return "";
+  const fn = () => v.reduce(plus, 0);
+  const isSumFn = fn;
+  return isSumFn();
+}
+function ADD(...args) {
+  const v = args.flat();
+  const fn = () => v.reduce(plus, 0);
+  const isSumFn = fn;
+  return isSumFn();
+}
+function REDUCE(v, ...args) {
+  const fn = () => args.reduce(minus, v);
+  const isReduceFN = fn;
+  return isReduceFN();
+}
+function MULTIPLICATION(val, ...args) {
+  const v = args.flat().filter((i) => i !== "" && i !== null && i !== void 0);
+  if (!v.length) return "";
+  const fn = () => v.reduce(multipliedBy, val);
+  const isMultiFn = fn;
+  return isMultiFn();
+}
+function DIVISION(v, ...args) {
+  const fn = () => args.reduce(div, v);
+  const isDivision = fn;
+  return isDivision();
+}
+function FIXED(v, n) {
+  const fn = () => {
+    if (n < 0) {
+      throw new Error("Decimal places should be non-negative.");
+    }
+    const arr = v.toString().split(".");
+    const [integer, decimal = ""] = arr;
+    if (n == 0) {
+      return integer;
+    }
+    let decimalArr = decimal.split("");
+    if (decimalArr.length > n) {
+      decimalArr = decimalArr.slice(0, n);
+    } else {
+      const count = decimalArr.length;
+      for (let i = 0; i < n - count; i++) {
+        decimalArr.push("0");
+      }
+    }
+    return `${integer}.${decimalArr.join("")}`;
+  };
+  const isFixedFn = fn;
+  return isFixedFn();
+}
+function ROUND(v, n) {
+  const fn = () => {
+    if (v === null || v === "" || v === void 0) return "";
+    if (n < 0) {
+      throw new Error("Decimal places should be non-negative.");
+    }
+    const digits = Math.trunc(n);
+    const numValue = Number(v);
+    if (isNaN(numValue)) return "";
+    const num = numValue > 0 ? (+(Math.round(Number(numValue + `e${digits}`)) + `e-${digits}`)).toFixed(digits) : -(+(Math.round(Number(-numValue + `e${digits}`)) + `e-${digits}`)).toFixed(digits);
+    return parseFloat(num + "");
+  };
+  const isRoundFn = fn;
+  return isRoundFn();
+}
+function ROUNDUP(v, n) {
+  if (v === null || v === "" || v === void 0) return "";
+  if (n < 0) {
+    throw new Error("Decimal places should be non-negative.");
+  }
+  n = n ? parseInt(n + "") : 0;
+  return new BigNumberJS(v).decimalPlaces(n, BigNumberJS.ROUND_UP).toNumber();
+}
+function MAX(...args) {
+  const v = args.flat().filter((i) => i !== "" && i !== null && i !== void 0);
+  if (!v.length) return "";
+  const fn = () => Math.max.apply(null, v);
+  const isMaxFn = fn;
+  return isMaxFn();
+}
+function LARGE(v, n) {
+  const fn = () => {
+    if (n < 1 || n > v.length) {
+      throw new Error(
+        "Invalid value of n. It should be between 1 and the array length."
+      );
+    }
+    const s = v.sort((a, b) => b - a);
+    return s[n - 1];
+  };
+  const isLargeFn = fn;
+  return isLargeFn();
+}
+function MIN(...args) {
+  const v = args.flat().filter((i) => i !== "" && i !== null && i !== void 0);
+  if (!v.length) return "";
+  const fn = () => Math.min.apply(null, v);
+  const isMinFn = fn;
+  return isMinFn();
+}
+function SMALL(v, n) {
+  const fn = () => {
+    if (n < 1 || n > v.length) {
+      throw new Error(
+        "Invalid value of n. It should be between 1 and the array length."
+      );
+    }
+    const s = v.sort((a, b) => a - b);
+    return s[n - 1];
+  };
+  const isSmallFn = fn;
+  return isSmallFn();
+}
+function AVERAGE(...args) {
+  const numbers = args.flat().filter((i) => i !== "" && i !== null && i !== void 0);
+  const count = numbers.length;
+  if (!count) return "";
+  let sum = new BigNumberJS(0);
+  for (const number of numbers) {
+    sum = sum.plus(number);
+  }
+  return sum.dividedBy(count).toNumber();
+}
+function ABS(v) {
+  const fn = () => Math.abs.call(null, v);
+  const isAbsFn = fn;
+  return isAbsFn();
+}
+function MOD(v, n) {
+  const fn = () => {
+    if (v === 0) {
+      throw new Error("The second value should not be zero.");
+    }
+    const result = new BigNumberJS(v).mod(n).toNumber();
+    if (isNaN(result)) return "";
+    return result;
+  };
+  const isModFn = fn;
+  return isModFn();
+}
+function toSafeNumber(x) {
+  if (typeof x === "number") {
+    return Number.isFinite(x) ? x : null;
+  }
+  if (typeof x === "string") {
+    const s = x.trim();
+    if (s === "") return null;
+    const n = Number(s);
+    return Number.isFinite(n) ? n : null;
+  }
+  if (typeof x === "bigint") {
+    const n = Number(x);
+    return Number.isFinite(n) ? n : null;
+  }
+  return null;
+}
+function POWER(v, n) {
+  const fn = () => {
+    const base = toSafeNumber(v);
+    const exp = toSafeNumber(n);
+    if (base === null || exp === null) return NaN;
+    const MAX_EXP = 1e9;
+    if (Math.abs(exp) > MAX_EXP) {
+      return exp > 0 ? Infinity : 0;
+    }
+    const result = Math.pow(base, exp);
+    return result;
+  };
+  const isProwerFn = fn;
+  return isProwerFn();
+}
+function SQRT(v) {
+  const fn = () => {
+    const n = toSafeNumber(v);
+    if (n === null) return NaN;
+    return Math.sqrt(n);
+  };
+  const isSqrt = fn;
+  return isSqrt();
+}
+function GET(v, p) {
+  const fn = () => {
+    if (Array.isArray(v)) {
+      if (typeof p === "number") {
+        return v[p];
+      } else {
+        throw new Error("For arrays, the second argument should be a number.");
+      }
+    } else if (typeof v === "object") {
+      if (typeof p === "string") {
+        return v[p];
+      } else {
+        throw new Error(
+          "For objects, the second argument (b) should be a string."
+        );
+      }
+    } else {
+      throw new Error(
+        "Unsupported data type. The first argument (a) should be an array or an object."
+      );
+    }
+  };
+  const isGetFn = fn;
+  return isGetFn();
+}
+function PUT(a, b, c) {
+  const fn = () => {
+    if (Array.isArray(a)) {
+      if (typeof b === "number" && b >= 0 && b < a.length) {
+        a[b] = c;
+      } else {
+        throw new Error(
+          "For arrays, the second argument (b) should be a number."
+        );
+      }
+    } else if (typeof a === "object") {
+      if (typeof b === "string" && a) {
+        a[b] = c;
+      } else {
+        throw new Error(
+          "For objects, the second argument (b) should be a string."
+        );
+      }
+    } else {
+      throw new Error(
+        "Unsupported data type. The first argument (a) should be an array or an object."
+      );
+    }
+    return a;
+  };
+  const isPutFn = fn;
+  return isPutFn();
+}
+function PUSH(v, n) {
+  const fn = () => {
+    if (!n) {
+      throw new Error(
+        "For arrays, the second argument should not be null or undefined"
+      );
+    }
+    v.push(n);
+    return v;
+  };
+  const isPushFn = fn;
+  return isPushFn();
+}
+function HEADPUSH(v, n) {
+  const fn = () => {
+    if (!n) {
+      throw new Error(
+        "For arrays, the second argument should not be null or undefined"
+      );
+    }
+    v.unshift(n);
+    return v;
+  };
+  const isHeadpushFn = fn;
+  return isHeadpushFn();
+}
+function TIMESTAMP2DATE(v) {
+  if (!v) return;
+  const fn = () => {
+    if (!v) {
+      throw new Error("the frist argument should not be null");
+    }
+    const dateObj = new Date(v * 1e3);
+    const year = dateObj.getFullYear();
+    const month = String(dateObj.getMonth() + 1).padStart(2, "0");
+    const day = String(dateObj.getDate()).padStart(2, "0");
+    const hours = String(dateObj.getHours()).padStart(2, "0");
+    const minutes = String(dateObj.getMinutes()).padStart(2, "0");
+    const seconds = String(dateObj.getSeconds()).padStart(2, "0");
+    return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}`;
+  };
+  const isTimeStampFn = fn;
+  return isTimeStampFn();
+}
+function DATE2TIMESTAMP(v) {
+  if (!v) return;
+  const fn = () => dayjs(v).unix();
+  const isDateToTimestampFn = fn;
+  return isDateToTimestampFn();
+}
+function DATEFORMAT(v, f) {
+  if (!v) return;
+  const fn = () => dayjs(v).format(f);
+  const isDateFormatFn = fn;
+  return isDateFormatFn();
+}
+function NOW() {
+  return dayjs().format("YYYY-MM-DD HH:MM:ss");
+}
+function TODAY() {
+  return dayjs().format("YYYY-MM-DD");
+}
+function YEAR(v) {
+  return dayjs(v).year();
+}
+function MONTH(v) {
+  const fn = () => {
+    const m = dayjs(v).month();
+    return m;
+  };
+  const isMonthFn = fn;
+  return isMonthFn();
+}
+function DAY(v) {
+  const fn = () => {
+    const d = dayjs(v).day();
+    return d;
+  };
+  const isDayFn = fn;
+  return isDayFn();
+}
+function HOUR(v) {
+  const fn = () => {
+    const h = dayjs(v).hour();
+    return h;
+  };
+  const isHourFn = fn;
+  return isHourFn();
+}
+function MINUTE(v) {
+  const fn = () => {
+    const m = dayjs(v).minute();
+    return m;
+  };
+  const isMinuteFn = fn;
+  return isMinuteFn();
+}
+function WEEKRANGE() {
+  const fn = () => {
+    const startOfWeek = convertToCST(dayjs().startOf("week").toDate());
+    const endOfWeek = convertToCST(dayjs().endOf("week").toDate());
+    return [startOfWeek, endOfWeek];
+  };
+  const isWeekDayFn = fn;
+  return isWeekDayFn();
+}
+function LASTWEEKRANGE() {
+  const fn = () => {
+    const startOfLastWeek = convertToCST(
+      dayjs().subtract(1, "week").startOf("week").toDate()
+    );
+    const endOfLastWeek = convertToCST(
+      dayjs().subtract(1, "week").endOf("week").toDate()
+    );
+    return [startOfLastWeek, endOfLastWeek];
+  };
+  const isLastWeekFn = fn;
+  return isLastWeekFn();
+}
+function MONTHRANGE() {
+  const fn = () => {
+    const startOfLastMonth = convertToCST(dayjs().startOf("month").toDate());
+    const endOfLastMonth = convertToCST(dayjs().endOf("month").toDate());
+    return [startOfLastMonth, endOfLastMonth];
+  };
+  const isMonthRangeFn = fn;
+  return isMonthRangeFn();
+}
+function LASTMONTHRANGE() {
+  const fn = () => {
+    const startOfLastMonth = convertToCST(
+      dayjs().subtract(1, "month").startOf("month").toDate()
+    );
+    const endOfLastMonth = convertToCST(
+      dayjs().subtract(1, "month").endOf("month").toDate()
+    );
+    return [startOfLastMonth, endOfLastMonth];
+  };
+  const isLastMonthRangeFn = fn;
+  return isLastMonthRangeFn();
+}
+function YEARRANGE() {
+  const fn = () => {
+    const startOfYear = convertToCST(dayjs().startOf("year").toDate());
+    const endOfYear = convertToCST(dayjs().endOf("year").toDate());
+    return [startOfYear, endOfYear];
+  };
+  const isYearRange = fn;
+  return isYearRange();
+}
+function LASTYEARRANGE() {
+  const fn = () => {
+    const startOfLastYear = convertToCST(
+      dayjs().subtract(1, "year").startOf("year").toDate()
+    );
+    const endOfLastYear = convertToCST(
+      dayjs().subtract(1, "year").endOf("year").toDate()
+    );
+    return [startOfLastYear, endOfLastYear];
+  };
+  const isLastYearRange = fn;
+  return isLastYearRange();
+}
+function QUARTER() {
+  const fn = () => {
+    const currentQuarter = Math.floor((dayjs().month() + 3) / 3);
+    const startOfCurrentQuarter = convertToCST(
+      dayjs().quarter(currentQuarter).startOf("quarter").toDate()
+    );
+    const endOfCurrentQuarter = convertToCST(
+      dayjs().quarter(currentQuarter).endOf("quarter").toDate()
+    );
+    return [startOfCurrentQuarter, endOfCurrentQuarter];
+  };
+  const isQuarterFn = fn;
+  return isQuarterFn();
+}
+function LASTQUARTER() {
+  const fn = () => {
+    const currentQuarter = Math.floor((dayjs().month() + 3) / 3);
+    const startOfLastQuarter = convertToCST(
+      dayjs().quarter(currentQuarter - 1).startOf("quarter").toDate()
+    );
+    const endOfLastQuarter = convertToCST(
+      dayjs().quarter(currentQuarter - 1).endOf("quarter").toDate()
+    );
+    return [startOfLastQuarter, endOfLastQuarter];
+  };
+  const isLastQuarter = fn;
+  return isLastQuarter();
+}
+function ISDATERANGE(v, r) {
+  const fn = () => {
+    const [startDate, endDate] = r;
+    return v >= startDate && v <= endDate;
+  };
+  const isDateRangFn = fn;
+  return isDateRangFn();
+}
+function ISTIMERANGE(v, r) {
+  const fn = () => {
+    const [startTime, endTime] = r;
+    const dtTime = dayjs(v, "HH:mm");
+    if (startTime > endTime) {
+      const startTimeAfterMidnight = dayjs(startTime, "HH:mm");
+      const endTimeBeforeMidnight = dayjs(endTime, "HH:mm").add(1, "day");
+      return dtTime >= startTimeAfterMidnight || dtTime <= endTimeBeforeMidnight;
+    } else {
+      return dtTime >= dayjs(startTime, "HH:mm") && dtTime <= dayjs(endTime, "HH:mm");
+    }
+  };
+  const isTimeRangFn = fn;
+  return isTimeRangFn();
+}
+function convertToCST(isoDateString) {
+  const cstFormattedDate = dayjs(isoDateString).tz("America/Chicago").format("YYYY-MM-DD HH:mm:ss.SSSSSSSSS ZZ");
+  return cstFormattedDate;
+}
+function TUPLE(...args) {
+  return [...args];
+}
+function SEQMAP(...args) {
+  const len = (args.length - args.length % 2) / 2;
+  const map = {};
+  Array(len).forEach((i) => {
+    const key = args[i * 2];
+    const value = args[i * 2 + 1];
+    map[key] = value;
+  });
+  return map;
+}
+function SUMSQ(...args) {
+  args = args.flat().filter((i) => i !== "" && i !== null && i !== void 0);
+  if (args.length === 0) return "";
+  const squares = args.map((value) => {
+    const square = multipliedBy(value, value);
+    return square !== "" ? square : new BigNumberJS(0).toNumber();
+  });
+  return squares.reduce((sum, square) => {
+    return plus(sum, square) || BigNumberJS(0).toNumber();
+  }, new BigNumberJS(0).toNumber());
+}
+function COUNT(v) {
+  if (!Array.isArray(v)) {
+    return "";
+  }
+  return v.length;
+}
+function STDEV(...args) {
+  const data = args.flat().map((v) => Number(v)).filter((v) => Number.isFinite(v));
+  if (data.length < 2) {
+    return "";
+  }
+  const mean = data.reduce((sum, val) => sum + val, 0) / data.length;
+  const variance = data.reduce((sum, val) => {
+    const diff = val - mean;
+    return sum + diff * diff;
+  }, 0) / (data.length - 1);
+  return Math.sqrt(variance);
+}
+function plus(a, b) {
+  const result = new BigNumberJS(a).plus(new BigNumberJS(b)).toNumber();
+  if (isNaN(result)) return "";
+  return result;
+}
+function minus(a, b) {
+  const result = new BigNumberJS(a).minus(new BigNumberJS(b)).toNumber();
+  if (isNaN(result)) return "";
+  return result;
+}
+function multipliedBy(a, b) {
+  const result = new BigNumberJS(a).multipliedBy(new BigNumberJS(b)).toNumber();
+  if (isNaN(result)) return "";
+  return result;
+}
+function div(a, b) {
+  const result = new BigNumberJS(a).div(new BigNumberJS(b)).toNumber();
+  if (isNaN(result)) return "";
+  return result;
+}
+
+export { ABS, ADD, AND, AVERAGE, CONCAT, COUNT, DATE2TIMESTAMP, DATEFORMAT, DAY, DIVISION, EQ, FINDSTR, FIXED, GE, GET, GT, HEADPUSH, HOUR, IF, ISDATERANGE, ISEMPTY, ISNULL, ISTIMERANGE, ISUNDEFINED, LARGE, LASTMONTHRANGE, LASTQUARTER, LASTWEEKRANGE, LASTYEARRANGE, LE, LEN, LOWER, LT, LTRIM, MAX, MIN, MINUTE, MOD, MONTH, MONTHRANGE, MULTIPLICATION, NE, NOW, OR, PARSENUMBER, POWER, PUSH, PUT, QUARTER, REDUCE, REPEAT, REPLACE, ROUND, ROUNDUP, RTRIM, SEARCHSTR, SEQMAP, SMALL, SPLIT, SQRT, STDEV, SUBSTR, SUBSTRING, SUM, SUMSQ, TIMESTAMP2DATE, TODAY, TRIM, TUPLE, UPPER, WEEKRANGE, YEAR, YEARRANGE };