@fctc/interface-logic 5.2.6 → 5.2.8

package/dist/{chunk-U4Q3MW45.js → chunk-JDXUTKMX.js}

@@ -1,79 +1,319 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class2;// src/utils/storage/local-storage.ts
-var localStorageUtils = () => {
-  const setToken = async (access_token) => {
-    localStorage.setItem("accessToken", access_token);
-  };
-  const setRefreshToken = async (refresh_token) => {
-    localStorage.setItem("refreshToken", refresh_token);
-  };
-  const getAccessToken = async () => {
-    return localStorage.getItem("accessToken");
-  };
-  const getRefreshToken = async () => {
-    return localStorage.getItem("refreshToken");
-  };
-  const clearToken = async () => {
-    localStorage.removeItem("accessToken");
-    localStorage.removeItem("refreshToken");
-  };
-  return {
-    setToken,
-    setRefreshToken,
-    getAccessToken,
-    getRefreshToken,
-    clearToken
-  };
-};
+'use strict';
 
-// src/utils/storage/session-storage.ts
-var sessionStorageUtils = /* @__PURE__ */ (() => {
-  const getMenuFocus = () => {
-    const menuFocus = sessionStorage.getItem("menuFocus");
-    return menuFocus ? JSON.parse(menuFocus) : {
-      id: void 0,
-      service: ""
-    };
-  };
-  const setMenuFocus = (menuTree) => {
-    sessionStorage.setItem("menuFocus", JSON.stringify({ ...menuTree }));
-  };
-  const getActionData = () => {
-    const actionData = sessionStorage.getItem("actionData");
-    return actionData ? JSON.parse(actionData) : {};
-  };
-  const setActionData = (actData) => {
-    sessionStorage.setItem("actionData", JSON.stringify(actData));
-  };
-  const getViewData = () => {
-    const viewData = sessionStorage.getItem("viewData");
-    return viewData ? JSON.parse(viewData) : {};
-  };
-  const getBrowserSession = () => {
-    const actionData = sessionStorage.getItem("browserSession");
-    return actionData ? JSON.parse(actionData) : null;
-  };
-  const setViewData = (viewData) => {
-    sessionStorage.setItem("viewData", JSON.stringify(viewData));
-  };
-  const getXNode = () => {
-    const xNode = sessionStorage.getItem("xNode");
-    return xNode;
+var moment = require('moment');
+var react = require('react');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var moment__default = /*#__PURE__*/_interopDefault(moment);
+
+// src/utils/error-handler.ts
+var WesapError = class extends Error {
+  code;
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+  }
+};
+function handleError(error, env) {
+  if (error instanceof WesapError) {
+    env.services.notification.error(error.message);
+  } else {
+    env.services.notification.error("An unexpected error occurred");
+  }
+}
+var formatCurrency = (amount, currency = "USD") => {
+  const formatter = new Intl.NumberFormat("vi-VN", {
+    style: "currency",
+    currency,
+    minimumFractionDigits: 0
+  });
+  return formatter.format(amount).replaceAll(".", ",");
+};
+var formatDate = (date, locale = "en-US") => {
+  return new Intl.DateTimeFormat(locale).format(new Date(date));
+};
+var validateAndParseDate = (input, isDateTime = false) => {
+  if (!input || typeof input !== "string") return null;
+  const cleanInput = input.replace(/[^0-9-\/:\s]/g, "");
+  const dateFormat = "YYYY-MM-DD";
+  const dateTimeFormat = "YYYY-MM-DD HH:mm:ss";
+  const currentDay = moment__default.default().format("DD");
+  const currentMonth = moment__default.default().format("MM");
+  const currentYear = moment__default.default().format("YYYY");
+  const defaultTime = "00:00:00";
+  const maxYear = parseInt(currentYear) + 10;
+  const isValidDate = (day, month, year) => {
+    const date = moment__default.default(`${day}-${month}-${year}`, "DD-MM-YYYY", true);
+    return date.isValid();
   };
-  const setXNode = (xNode) => {
-    sessionStorage.setItem("xNode", xNode);
+  const isValidTime = (hour, minute = "00", second = "00") => {
+    const h = parseInt(hour, 10);
+    const m = parseInt(minute, 10);
+    const s = parseInt(second, 10);
+    return h >= 0 && h <= 23 && m >= 0 && m <= 59 && s >= 0 && s <= 59;
   };
-  return {
-    getMenuFocus,
-    setMenuFocus,
-    setActionData,
-    getActionData,
-    getViewData,
-    setViewData,
-    getBrowserSession,
-    getXNode,
-    setXNode
+  const formatOutput = (day, month, year, time = defaultTime) => {
+    let result = moment__default.default(
+      `${day}-${month}-${year} ${time}`,
+      "DD-MM-YYYY HH:mm:ss"
+    );
+    if (!result.isValid()) return null;
+    if (isDateTime) {
+      result = result.subtract(7, "hours");
+      return result.format(dateTimeFormat);
+    }
+    return result.format(dateFormat);
   };
-})();
+  if (isDateTime && input.match(
+    /^\d{1,2}[\/-]\d{1,2}[\/-]\d{2,4}\s+\d{1,2}(:\d{1,2}(:\d{1,2})?)?$/
+  )) {
+    const [datePart, timePart] = input.split(/\s+/);
+    const dateParts = datePart.split(/[\/-]/);
+    const timeParts = timePart.split(":");
+    const day = dateParts[0].padStart(2, "0");
+    const month = dateParts[1].padStart(2, "0");
+    const year = dateParts[2].length <= 2 ? `20${dateParts[2].padStart(2, "0")}` : dateParts[2].padStart(4, "0");
+    const hour = timeParts[0].padStart(2, "0");
+    const minute = timeParts[1] ? timeParts[1].padStart(2, "0") : "00";
+    const second = timeParts[2] ? timeParts[2].padStart(2, "0") : "00";
+    if (isValidDate(day, month, year) && isValidTime(hour, minute, second)) {
+      let result = moment__default.default(
+        `${day}-${month}-${year} ${hour}:${minute}:${second}`,
+        "DD-MM-YYYY HH:mm:ss"
+      );
+      if (!result.isValid()) return null;
+      result = result.subtract(7, "hours");
+      return result.format(dateTimeFormat);
+    }
+    return null;
+  }
+  if (cleanInput.match(/^\d{4}-\d{2}-\d{2}$/)) {
+    const [year, month, day] = cleanInput.split("-");
+    if (isValidDate(day, month, year)) {
+      return formatOutput(day, month, year);
+    }
+    return null;
+  }
+  if (cleanInput.match(/^\d{1,2}\/\d{1,2}\/\d{2,4}$/)) {
+    const [day, month, year] = cleanInput.split("/");
+    const paddedDay = day.padStart(2, "0");
+    const paddedMonth = month.padStart(2, "0");
+    const fullYear = year.length <= 2 ? `20${year.padStart(2, "0")}` : year.padStart(4, "0");
+    if (isValidDate(paddedDay, paddedMonth, fullYear)) {
+      return formatOutput(paddedDay, paddedMonth, fullYear);
+    }
+    return null;
+  }
+  if (cleanInput.match(/^\d{1,2}-\d{1,2}-\d{2,4}$/)) {
+    const [day, month, year] = cleanInput.split("-");
+    const paddedDay = day.padStart(2, "0");
+    const paddedMonth = month.padStart(2, "0");
+    const fullYear = year.length <= 2 ? `20${year.padStart(2, "0")}` : year.padStart(4, "0");
+    if (isValidDate(paddedDay, paddedMonth, fullYear)) {
+      return formatOutput(paddedDay, paddedMonth, fullYear);
+    }
+    return null;
+  }
+  if (cleanInput.match(/^\d{1,2}[\/-]\d{1,2}$/)) {
+    const [day, month] = cleanInput.split(/[\/-]/);
+    const paddedDay = day.padStart(2, "0");
+    const paddedMonth = month.padStart(2, "0");
+    if (isValidDate(paddedDay, paddedMonth, currentYear)) {
+      return formatOutput(paddedDay, paddedMonth, currentYear);
+    }
+    return null;
+  }
+  if (cleanInput.match(/^\d{4}$/)) {
+    const num = parseInt(cleanInput, 10);
+    if (num >= 2e3 && num <= maxYear) {
+      if (isValidDate(currentDay, currentMonth, num.toString())) {
+        return formatOutput(currentDay, currentMonth, num.toString());
+      }
+      return null;
+    }
+    const day = cleanInput.slice(0, 2);
+    const month = cleanInput.slice(2, 4);
+    if (isValidDate(day, month, currentYear)) {
+      return formatOutput(day, month, currentYear);
+    }
+    return null;
+  }
+  if (cleanInput.startsWith("-") && /^\-\d+$/.test(cleanInput)) {
+    const daysToSubtract = Math.abs(parseInt(cleanInput, 10));
+    let result = moment__default.default().subtract(daysToSubtract, "days");
+    if (isDateTime) {
+      result = result.subtract(7, "hours");
+    }
+    if (result.isValid()) {
+      return isDateTime ? result.format(dateTimeFormat) : result.format(dateFormat);
+    }
+    return null;
+  }
+  if (input.match(/^\d{1,2}[^0-9-\/]+\d{1,2}[^0-9-\/]+\d{2,4}.*$/)) {
+    const parts = input.split(/[^0-9-\/]+/).filter(Boolean);
+    const day = parts[0].padStart(2, "0");
+    const month = parts[1].padStart(2, "0");
+    let year = parts[2];
+    year = year.length === 2 ? `20${year}` : year.padStart(4, "0");
+    if (isValidDate(day, month, year)) {
+      return formatOutput(day, month, year);
+    }
+    return null;
+  }
+  if (isDateTime) {
+    if (cleanInput.length === 9) {
+      const day = cleanInput.slice(0, 2);
+      const month = cleanInput.slice(2, 4);
+      const year = cleanInput.slice(4, 8);
+      const hour = cleanInput.slice(8, 9).padStart(2, "0");
+      if (isValidDate(day, month, year) && isValidTime(hour)) {
+        let result = moment__default.default(
+          `${day}-${month}-${year} ${hour}:00:00`,
+          "DD-MM-YYYY HH:mm:ss"
+        );
+        if (!result.isValid()) return null;
+        result = result.subtract(7, "hours");
+        return result.format(dateTimeFormat);
+      }
+      return null;
+    }
+    if (cleanInput.length === 10) {
+      const day = cleanInput.slice(0, 2);
+      const month = cleanInput.slice(2, 4);
+      const year = cleanInput.slice(4, 8);
+      const hour = cleanInput.slice(8, 10);
+      if (isValidDate(day, month, year) && isValidTime(hour)) {
+        let result = moment__default.default(
+          `${day}-${month}-${year} ${hour}:00:00`,
+          "DD-MM-YYYY HH:mm:ss"
+        );
+        if (!result.isValid()) return null;
+        result = result.subtract(7, "hours");
+        return result.format(dateTimeFormat);
+      }
+      return null;
+    }
+    if (cleanInput.length === 11) {
+      const day = cleanInput.slice(0, 2);
+      const month = cleanInput.slice(2, 4);
+      const year = cleanInput.slice(4, 8);
+      const hour = cleanInput.slice(8, 10);
+      const minute = cleanInput.slice(10, 11).padStart(2, "0");
+      if (isValidDate(day, month, year) && isValidTime(hour, minute)) {
+        let result = moment__default.default(
+          `${day}-${month}-${year} ${hour}:${minute}:00`,
+          "DD-MM-YYYY HH:mm:ss"
+        );
+        if (!result.isValid()) return null;
+        result = result.subtract(7, "hours");
+        return result.format(dateTimeFormat);
+      }
+      return null;
+    }
+    if (cleanInput.length === 12) {
+      const day = cleanInput.slice(0, 2);
+      const month = cleanInput.slice(2, 4);
+      const year = cleanInput.slice(4, 8);
+      const hour = cleanInput.slice(8, 10);
+      const minute = cleanInput.slice(10, 12);
+      if (isValidDate(day, month, year) && isValidTime(hour, minute)) {
+        let result = moment__default.default(
+          `${day}-${month}-${year} ${hour}:${minute}:00`,
+          "DD-MM-YYYY HH:mm:ss"
+        );
+        if (!result.isValid()) return null;
+        result = result.subtract(7, "hours");
+        return result.format(dateTimeFormat);
+      }
+      return null;
+    }
+    if (cleanInput.length === 13) {
+      const day = cleanInput.slice(0, 2);
+      const month = cleanInput.slice(2, 4);
+      const year = cleanInput.slice(4, 8);
+      const hour = cleanInput.slice(8, 10);
+      const minute = cleanInput.slice(10, 12);
+      const second = cleanInput.slice(12, 13).padStart(2, "0");
+      if (isValidDate(day, month, year) && isValidTime(hour, minute, second)) {
+        let result = moment__default.default(
+          `${day}-${month}-${year} ${hour}:${minute}:${second}`,
+          "DD-MM-YYYY HH:mm:ss"
+        );
+        if (!result.isValid()) return null;
+        result = result.subtract(7, "hours");
+        return result.format(dateTimeFormat);
+      }
+      return null;
+    }
+    if (cleanInput.length === 14) {
+      const day = cleanInput.slice(0, 2);
+      const month = cleanInput.slice(2, 4);
+      const year = cleanInput.slice(4, 8);
+      const hour = cleanInput.slice(8, 10);
+      const minute = cleanInput.slice(10, 12);
+      const second = cleanInput.slice(12, 14);
+      if (isValidDate(day, month, year) && isValidTime(hour, minute, second)) {
+        let result = moment__default.default(
+          `${day}-${month}-${year} ${hour}:${minute}:${second}`,
+          "DD-MM-YYYY HH:mm:ss"
+        );
+        if (!result.isValid()) return null;
+        result = result.subtract(7, "hours");
+        return result.format(dateTimeFormat);
+      }
+      return null;
+    }
+  }
+  const len = cleanInput.length;
+  if (len === 1 || len === 2) {
+    const paddedDay = cleanInput.padStart(2, "0");
+    if (isValidDate(paddedDay, currentMonth, currentYear)) {
+      return formatOutput(paddedDay, currentMonth, currentYear);
+    }
+    return null;
+  }
+  if (len === 3) {
+    const day = cleanInput.slice(0, 2);
+    const month = cleanInput.slice(2, 3).padStart(2, "0");
+    if (isValidDate(day, month, currentYear)) {
+      return formatOutput(day, month, currentYear);
+    }
+    return null;
+  }
+  if (len === 6) {
+    const day = cleanInput.slice(0, 2);
+    const month = cleanInput.slice(2, 4);
+    let year = cleanInput.slice(4, 6);
+    year = `20${year}`;
+    if (parseInt(month) > 12) {
+      if (isValidDate(day, currentMonth, currentYear)) {
+        return formatOutput(day, currentMonth, currentYear);
+      }
+      return null;
+    }
+    if (isValidDate(day, month, year)) {
+      return formatOutput(day, month, year);
+    }
+    return null;
+  }
+  if (len === 7) {
+    return null;
+  }
+  if (len === 8) {
+    const day = cleanInput.slice(0, 2);
+    const month = cleanInput.slice(2, 4);
+    const year = cleanInput.slice(4, 8);
+    if (isValidDate(day, month, year)) {
+      return formatOutput(day, month, year);
+    }
+    return null;
+  }
+  if (len > 8 && !isDateTime) {
+    return null;
+  }
+  return null;
+};
 
 // src/utils/domain/py_tokenizer.ts
 var TokenizerError = class extends Error {
@@ -229,7 +469,7 @@ var IntNumber = DecNumber;
 var Exponent = "[eE][+-]?\\d+";
 var PointFloat = group(`\\d+\\.\\d*(${Exponent})?`, `\\.\\d+(${Exponent})?`);
 var FloatNumber = group(PointFloat, `\\d+${Exponent}`);
-var Number = group(FloatNumber, IntNumber);
+var Number2 = group(FloatNumber, IntNumber);
 var Operator = group(
   "\\*\\*=?",
   ">>=?",
@@ -247,8 +487,8 @@ var ContStr = group(
   "([uU])?'([^\\n'\\\\]*(?:\\\\.[^\\n'\\\\]*)*)'",
   '([uU])?"([^\\n"\\\\]*(?:\\\\.[^\\n"\\\\]*)*)"'
 );
-var PseudoToken = Whitespace + group(Number, Funny, ContStr, Name);
-var NumberPattern = new RegExp("^" + Number + "$");
+var PseudoToken = Whitespace + group(Number2, Funny, ContStr, Name);
+var NumberPattern = new RegExp("^" + Number2 + "$");
 var StringPattern = new RegExp("^" + ContStr + "$");
 var NamePattern = new RegExp("^" + Name + "$");
 var strip = new RegExp("^" + Whitespace);
@@ -578,8 +818,6 @@ function parseInfix(left, current, tokens) {
             ifTrue: left,
             ifFalse
           };
-        default:
-          break;
       }
   }
   throw new ParserError("Token cannot be parsed");
@@ -1153,22 +1391,22 @@ var PyRelativeDelta = class _PyRelativeDelta {
     this.microsecond = params.microsecond;
     this.weekday = params.weekday;
   }
-  
-  
-  
-  
-  
-  
-  
-  
-  
-  
-  
-  
-  
-  
-  
-  
+  years;
+  months;
+  days;
+  hours;
+  minutes;
+  seconds;
+  microseconds;
+  leapDays;
+  year;
+  month;
+  day;
+  hour;
+  minute;
+  second;
+  microsecond;
+  weekday;
   negate() {
     return new _PyRelativeDelta(this, -1);
   }
@@ -1283,7 +1521,7 @@ function execOnIterable(iterable, func) {
   if (typeof iterable === "object" && !Array.isArray(iterable) && !(iterable instanceof Set)) {
     iterable = Object.keys(iterable);
   }
-  if (typeof _optionalChain([iterable, 'optionalAccess', _ => _[Symbol.iterator]]) !== "function") {
+  if (typeof iterable?.[Symbol.iterator] !== "function") {
     throw new EvaluationError("value not iterable");
   }
   return func(iterable);
@@ -1728,7 +1966,7 @@ function evaluate(ast, context = {}) {
   const dicts = /* @__PURE__ */ new Set();
   let pyContext;
   const evalContext = Object.create(context);
-  if (!_optionalChain([evalContext, 'optionalAccess', _2 => _2.context])) {
+  if (!evalContext?.context) {
     Object.defineProperty(evalContext, "context", {
       get() {
         if (!pyContext) {
@@ -1739,17 +1977,17 @@ function evaluate(ast, context = {}) {
     });
   }
   function _innerEvaluate(ast2) {
-    switch (_optionalChain([ast2, 'optionalAccess', _3 => _3.type])) {
+    switch (ast2?.type) {
       case 0:
       // Number
       case 1:
         return ast2.value;
       case 5:
         if (ast2.value in evalContext) {
-          if (typeof evalContext[ast2.value] === "object" && _optionalChain([evalContext, 'access', _4 => _4[ast2.value], 'optionalAccess', _5 => _5.id]) && _optionalChain([ast2, 'optionalAccess', _6 => _6.value]) !== "parent") {
-            return _optionalChain([evalContext, 'access', _7 => _7[ast2.value], 'optionalAccess', _8 => _8.id]);
+          if (typeof evalContext[ast2.value] === "object" && evalContext[ast2.value]?.id && ast2?.value !== "parent") {
+            return evalContext[ast2.value]?.id;
           }
-          return _nullishCoalesce(evalContext[ast2.value], () => ( false));
+          return evalContext[ast2.value] ?? false;
         } else if (ast2.value in BUILTINS) {
           return BUILTINS[ast2.value];
         } else {
@@ -1786,7 +2024,7 @@ function evaluate(ast, context = {}) {
         const args = ast2.args.map(_evaluate);
         const kwargs = {};
         for (const kwarg in ast2.kwargs) {
-          kwargs[kwarg] = _evaluate(_optionalChain([ast2, 'optionalAccess', _9 => _9.kwargs, 'access', _10 => _10[kwarg]]));
+          kwargs[kwarg] = _evaluate(ast2?.kwargs[kwarg]);
         }
         if (fnValue === PyDate || fnValue === PyDateTime || fnValue === PyTime || fnValue === PyRelativeDelta || fnValue === PyTimeDelta) {
           return fnValue.create(...args, kwargs);
@@ -1817,11 +2055,11 @@ function evaluate(ast, context = {}) {
         } else if (typeof leftVal === "number") {
           result = leftVal;
         } else if (Array.isArray(leftVal[ast2.key])) {
-          result = _optionalChain([leftVal, 'access', _11 => _11[ast2.key], 'optionalAccess', _12 => _12.map, 'call', _13 => _13(
-            (value) => _nullishCoalesce(_optionalChain([value, 'optionalAccess', _14 => _14.id]), () => ( value))
-          )]);
+          result = leftVal[ast2.key]?.map(
+            (value) => value?.id ?? value
+          );
         } else {
-          result = _nullishCoalesce(_nullishCoalesce(_optionalChain([leftVal, 'access', _15 => _15[ast2.key], 'optionalAccess', _16 => _16.id]), () => ( leftVal[ast2.key])), () => ( false));
+          result = leftVal[ast2.key]?.id ?? leftVal[ast2.key] ?? false;
         }
         if (typeof result === "function") {
           const bound = result.bind(leftVal);
@@ -1878,18 +2116,6 @@ function evaluateBooleanExpr(expr, context = {}) {
 }
 
 // src/utils/domain/context.ts
-function makeContext(contexts, initialEvaluationContext) {
-  const evaluationContext = Object.assign({}, initialEvaluationContext);
-  const context = {};
-  for (let ctx of contexts) {
-    if (ctx !== "") {
-      ctx = typeof ctx === "string" ? evaluateExpr(ctx, evaluationContext) : ctx || {};
-      Object.assign(context, ctx);
-      Object.assign(evaluationContext, context);
-    }
-  }
-  return context;
-}
 function evalPartialContext(_context, evaluationContext = {}) {
   const ast = parseExpr(_context);
   const context = {};
@@ -1897,7 +2123,7 @@ function evalPartialContext(_context, evaluationContext = {}) {
     const value = ast.value[key];
     try {
       context[key] = evaluate(value, evaluationContext);
-    } catch (e2) {
+    } catch {
     }
   }
   return context;
@@ -1914,9 +2140,6 @@ function shallowEqual(obj1, obj2, comparisonFn = (a, b) => a === b) {
 
 // src/utils/domain/arrays.ts
 var shallowEqual2 = shallowEqual;
-
-// src/utils/domain/strings.ts
-var escapeMethod = Symbol("html");
 function escapeRegExp(str) {
   return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
@@ -1924,10 +2147,10 @@ function escapeRegExp(str) {
 // src/utils/domain/domain.ts
 var InvalidDomainError = class extends Error {
 };
-var Domain = (_class2 = class _Domain {
-  __init() {this.ast = { type: -1, value: null }}
-  
-  
+var Domain = class _Domain {
+  ast = { type: -1, value: null };
+  static TRUE;
+  static FALSE;
   static combine(domains, operator) {
     if (domains.length === 0) {
       return new _Domain([]);
@@ -2006,7 +2229,7 @@ var Domain = (_class2 = class _Domain {
     processLeaf(d.ast.value, 0, "&", newDomain);
     return newDomain;
   }
-  constructor(descr = []) {;_class2.prototype.__init.call(this);
+  constructor(descr = []) {
     if (descr instanceof _Domain) {
       return new _Domain(descr.toString());
     } else {
@@ -2042,17 +2265,11 @@ var Domain = (_class2 = class _Domain {
         return evaluatedAsList;
       }
       return this.toString();
-    } catch (e3) {
+    } catch {
       return this.toString();
     }
   }
-}, _class2);
-function evalDomain(modifier, evalContext) {
-  if (modifier && typeof modifier !== "boolean") {
-    modifier = new Domain(modifier).contains(evalContext);
-  }
-  return Boolean(modifier);
-}
+};
 var TRUE_LEAF = [1, "=", 1];
 var FALSE_LEAF = [0, "=", 1];
 var TRUE_DOMAIN = new Domain([TRUE_LEAF]);
@@ -2272,19 +2489,12 @@ var checkDomain = (context, domain) => {
 };
 var matchDomains = (context, domains) => {
   if (Array.isArray(domains)) {
-    if (_optionalChain([domains, 'optionalAccess', _17 => _17.length]) > 0) {
+    if (domains?.length > 0) {
       return domains && domains.some((domain) => checkDomain(context, domain));
     }
   } else return checkDomain(context, domains);
   return false;
 };
-
-// src/utils/function/index.ts
-var domainHelper = {
-  checkDomain,
-  matchDomains,
-  Domain
-};
 var evalJSONContext = (_context, context = {}) => {
   try {
     return evalPartialContext(
@@ -2299,16 +2509,16 @@ var evalJSONDomain = (domain, context) => {
   const cloneContext = JSON.parse(JSON.stringify(context));
   try {
     if (cloneContext) {
-      _optionalChain([Object, 'access', _18 => _18.keys, 'call', _19 => _19(cloneContext), 'optionalAccess', _20 => _20.forEach, 'call', _21 => _21((key) => {
+      Object.keys(cloneContext)?.forEach((key) => {
         if (Array.isArray(cloneContext[key])) {
-          const isTypeObject = _optionalChain([cloneContext, 'access', _22 => _22[key], 'optionalAccess', _23 => _23.every, 'call', _24 => _24(
-            (item) => typeof item === "object" && item !== null && _optionalChain([item, 'optionalAccess', _25 => _25.id]) !== void 0
-          )]);
+          const isTypeObject = cloneContext[key]?.every(
+            (item) => typeof item === "object" && item !== null && item?.id !== void 0
+          );
           if (isTypeObject) {
-            cloneContext[key] = _optionalChain([cloneContext, 'access', _26 => _26[key], 'optionalAccess', _27 => _27.map, 'call', _28 => _28((item) => _optionalChain([item, 'optionalAccess', _29 => _29.id]))]);
+            cloneContext[key] = cloneContext[key]?.map((item) => item?.id);
           }
         }
-      })]);
+      });
     }
     const value = evaluateExpr(domain, cloneContext);
     return value;
@@ -2325,24 +2535,320 @@ var formatSortingString = (input) => {
   if (!input) return null;
   return input.split(",").map((field) => {
     const [key, order] = field.trim().split(/\s+/);
-    const sortOrder = _optionalChain([order, 'optionalAccess', _30 => _30.toUpperCase, 'call', _31 => _31()]) === "DESC" ? "DESC" : "ASC";
+    const sortOrder = order?.toUpperCase() === "DESC" ? "DESC" : "ASC";
     return `${key} ${sortOrder}`;
   }).join(", ");
 };
+var domainHelper = {
+  checkDomain,
+  matchDomains,
+  Domain
+};
 var toQueryString = (params) => {
   return Object.keys(params).map(
     (key) => encodeURIComponent(key) + "=" + encodeURIComponent(params[key].toString())
   ).join("&");
 };
-function cleanObject(obj) {
-  const result = {};
-  for (const [k, v] of Object.entries(obj)) {
-    if (v !== null && v !== void 0) {
-      result[k] = v;
+var convertFloatToTime = (floatValue) => {
+  const hours = Math.floor(floatValue);
+  const minutes = Math.round((floatValue - hours) * 60);
+  const formattedHours = String(hours).padStart(2, "0");
+  const formattedMinutes = String(minutes).padStart(2, "0");
+  return `${formattedHours}:${formattedMinutes}`;
+};
+var convertTimeToFloat = (timeString) => {
+  const [hours, minutes] = timeString.split(":").map(Number);
+  return hours + minutes / 60;
+};
+var stringToColor = (name, id) => {
+  const combined = name + id / 2;
+  let hash = 0;
+  for (let i = 0; i < combined.length; i++) {
+    hash = combined.charCodeAt(i) + ((hash << 5) - hash);
+  }
+  const r = hash >> 16 & 255;
+  const g = hash >> 8 & 255;
+  const b = hash & 255;
+  const rNorm = r / 255;
+  const gNorm = g / 255;
+  const bNorm = b / 255;
+  const max = Math.max(rNorm, gNorm, bNorm);
+  const min = Math.min(rNorm, gNorm, bNorm);
+  const delta = max - min;
+  let h = 0;
+  if (delta !== 0) {
+    if (max === rNorm) h = (gNorm - bNorm) / delta % 6;
+    else if (max === gNorm) h = (bNorm - rNorm) / delta + 2;
+    else h = (rNorm - gNorm) / delta + 4;
+  }
+  h = Math.round(h * 60);
+  if (h < 0) h += 360;
+  let l = (max + min) / 2;
+  let s = delta === 0 ? 0 : delta / (1 - Math.abs(2 * l - 1));
+  s = Math.min(1, s * 1.8);
+  l = Math.min(0.75, l * 1.05);
+  const c = (1 - Math.abs(2 * l - 1)) * s;
+  const x = c * (1 - Math.abs(h / 60 % 2 - 1));
+  const m = l - c / 2;
+  let r2 = 0, g2 = 0, b2 = 0;
+  if (0 <= h && h < 60) [r2, g2, b2] = [c, x, 0];
+  else if (60 <= h && h < 120) [r2, g2, b2] = [x, c, 0];
+  else if (120 <= h && h < 180) [r2, g2, b2] = [0, c, x];
+  else if (180 <= h && h < 240) [r2, g2, b2] = [0, x, c];
+  else if (240 <= h && h < 300) [r2, g2, b2] = [x, 0, c];
+  else [r2, g2, b2] = [c, 0, x];
+  const finalR = Math.round((r2 + m) * 255);
+  const finalG = Math.round((g2 + m) * 255);
+  const finalB = Math.round((b2 + m) * 255);
+  return `#${finalR.toString(16).padStart(2, "0")}${finalG.toString(16).padStart(2, "0")}${finalB.toString(16).padStart(2, "0")}`;
+};
+var getFieldsOnChange = (fields) => {
+  const result = [];
+  function traverse(items) {
+    for (const item of items) {
+      if (item) {
+        if (item?.type_co === "field" && matchDomains(fields, item?.on_change)) {
+          result.push(item.name);
+        }
+        if (item?.fields && Array.isArray(item?.fields)) {
+          traverse(item?.fields);
+        }
+      }
     }
   }
+  traverse(fields);
   return result;
-}
+};
+var filterFieldDirty = ({
+  id,
+  viewData,
+  formValues,
+  dirtyFields,
+  model,
+  defaultData,
+  keepZeroValue = false
+}) => {
+  const data = id ? { ...dirtyFields } : { ...formValues };
+  for (const key in data) {
+    if (viewData?.models?.[model]?.[key]?.type === "one2many" /* ONE2MANY */) {
+      const lineData = [];
+      (formValues[key] ?? []).forEach((itemData, index) => {
+        if (typeof itemData?.id === "string" && itemData?.id.includes("virtual")) {
+          delete itemData?.id;
+        }
+        if (!itemData?.id) {
+          lineData.push([
+            0 /* CREATE */,
+            `virtual_${index}`,
+            filterFieldDirty({
+              id: itemData?.id,
+              viewData,
+              formValues: itemData,
+              dirtyFields: {},
+              model: viewData?.models?.[model]?.[key]?.relation,
+              defaultData,
+              keepZeroValue
+            })
+          ]);
+        } else if (dirtyFields[key]?.length) {
+          dirtyFields[key].forEach((itemDirty, indexDirty) => {
+            if (Object.values(itemDirty).includes(true) && indexDirty === index) {
+              lineData.push([
+                1 /* UPDATE */,
+                itemData?.id,
+                filterFieldDirty({
+                  id: itemData?.id,
+                  viewData,
+                  formValues: itemData,
+                  dirtyFields: itemDirty,
+                  model: viewData?.models?.[model]?.[key]?.relation,
+                  defaultData: {},
+                  keepZeroValue
+                })
+              ]);
+            }
+          });
+        }
+      });
+      (defaultData[key] ?? []).forEach((item) => {
+        if (!(formValues[key] ?? []).find(
+          (itemData) => itemData?.id === item?.id
+        )) {
+          lineData.push([2 /* DELETE */, item?.id, item]);
+        }
+      });
+      data[key] = lineData;
+    } else if (viewData?.models?.[model]?.[key]?.type === "many2many" /* MANY2MANY */) {
+      const lineData = [];
+      (formValues[key] || []).forEach((itemData) => {
+        if (itemData?.id) {
+          lineData.push([4 /* NO_CHANGE */, itemData?.id]);
+        }
+      });
+      (defaultData[key] ?? []).forEach((item) => {
+        if (!(formValues[key] ?? []).find(
+          (itemData) => itemData?.id === item?.id
+        )) {
+          lineData.push([3 /* UNLINK */, item?.id]);
+        }
+      });
+      data[key] = lineData;
+    } else {
+      if (id && (typeof dirtyFields?.[key] === "object" && !dirtyFields?.[key]?.id || typeof dirtyFields[key] !== "object" && !dirtyFields[key])) {
+        if (!(keepZeroValue && (formValues[key] === 0 || formValues[key] === "0"))) {
+          delete data[key];
+        }
+      } else {
+        if (!data[key] && !(keepZeroValue && (data[key] === 0 || data[key] === "0"))) {
+          delete data[key];
+        } else {
+          data[key] = formValues?.[key]?.display_name ? formValues?.[key]?.id : formValues?.[key];
+        }
+      }
+    }
+  }
+  return data;
+};
+var mergeObjects = (object1, object2) => {
+  if (!object1 || !object2) return void 0;
+  const mergedObject = { ...object2 };
+  Object.keys(object1).forEach((key) => {
+    if (Array.isArray(object1[key]) && Array.isArray(object2[key])) {
+      mergedObject[key] = object2[key].map((item, index) => {
+        if (object1[key][index]) {
+          return {
+            ...item,
+            ...object1[key][index]
+          };
+        }
+        return item;
+      });
+    } else if (typeof object1[key] === "object" && typeof object2[key] === "object" && object1[key] !== null && object2[key] !== null) {
+      mergedObject[key] = mergeObjects(object1[key], object2[key]);
+    } else {
+      mergedObject[key] = object1[key] !== void 0 ? object1[key] : object2[key];
+    }
+  });
+  if (object2) {
+    Object.keys(object2).forEach((key) => {
+      if (!mergedObject.hasOwnProperty(key)) {
+        mergedObject[key] = object2[key];
+      }
+    });
+  }
+  return mergedObject;
+};
+var formatUrlPath = ({
+  viewType,
+  aid,
+  model,
+  id,
+  actionPath
+}) => {
+  let _url = `/${viewType}/${actionPath}?aid=${aid}&model=${model}`;
+  if (id) {
+    _url += `&id=${id}`;
+  }
+  return _url;
+};
+var removeUndefinedFields = (obj) => {
+  const newObj = {};
+  for (const key in obj) {
+    if (obj[key] !== void 0) {
+      newObj[key] = obj[key];
+    }
+  }
+  return newObj;
+};
+var useTabModel = (viewData, onchangeData) => {
+  const tabsData = viewData?.views?.form?.tabs?.filter((val) => {
+    if (!val) return null;
+    const hide = checkDomain(onchangeData, val.invisible);
+    if (!hide) {
+      return val;
+    }
+    return false;
+  }) || [];
+  return tabsData;
+};
+var isBase64File = (str) => {
+  try {
+    const dataUriPattern = /^data:([a-zA-Z]+\/[a-zA-Z0-9-.+]+)?;base64,/;
+    if (dataUriPattern.test(str)) {
+      return true;
+    }
+    const base64Pattern = (
+      // eslint-disable-next-line no-useless-escape
+      /^(?:[A-Za-z0-9+\/]{4})*(?:[A-Za-z0-9+\/]{3}=|[A-Za-z0-9+\/]{2}==)?$/
+    );
+    return base64Pattern.test(str);
+  } catch (e) {
+    return false;
+  }
+};
+var isBase64Image = (str) => {
+  const base64Regex = /^data:image\/(png|jpeg|jpg|gif|webp);base64,/;
+  if (!base64Regex.test(str)) {
+    return false;
+  }
+  try {
+    const base64Data = str.split(",")[1];
+    return !!base64Data && atob(base64Data).length > 0;
+  } catch (error) {
+    return false;
+  }
+};
+var checkIsImageLink = (url) => {
+  const imageExtensions = /\.(jpg|jpeg|png|gif|bmp|webp|svg|tiff|ico)$/i;
+  return imageExtensions.test(url) || isBase64Image(url);
+};
+var formatFileSize = (size) => {
+  if (size < 1024) return `${size} B`;
+  const i = Math.floor(Math.log(size) / Math.log(1024));
+  const sizes = ["B", "KB", "MB", "GB", "TB"];
+  return `${(size / Math.pow(1024, i)).toFixed(2)} ${sizes[i]}`;
+};
+var getSubdomain = (url = window.location.href) => {
+  const parts = url?.split(".");
+  if (parts.length > 2) {
+    return parts[0].replace("https://", "").replace("http://", "");
+  }
+  return null;
+};
+var resequence = (arr, start, end) => {
+  if (start < 0 || start >= arr.length || end < 0 || end >= arr.length) {
+    return [];
+  }
+  const [element] = arr.splice(start, 1);
+  arr.splice(end, 0, element);
+  return arr.slice(Math.min(start, end), Math.max(start, end) + 1);
+};
+var getOffSet = (arr, start, end) => {
+  if (start < 0 || start >= arr.length || end < 0 || end >= arr.length) {
+    return 0;
+  }
+  if (start > end) {
+    return end;
+  }
+  return arr.slice(0, start).length;
+};
+var copyTextToClipboard = async (text) => {
+  if ("clipboard" in navigator) {
+    return await navigator.clipboard.writeText(text);
+  } else {
+    const textArea = document.createElement("textarea");
+    textArea.value = text;
+    textArea.style.position = "fixed";
+    document.body.appendChild(textArea);
+    textArea.focus();
+    textArea.select();
+    try {
+      document.execCommand("copy");
+    } finally {
+      document.body.removeChild(textArea);
+    }
+  }
+};
 var updateTokenParamInOriginalRequest = (originalRequest, newAccessToken) => {
   if (!originalRequest.data) return originalRequest.data;
   if (typeof originalRequest.data === "string") {
@@ -2362,22 +2868,198 @@ var updateTokenParamInOriginalRequest = (originalRequest, newAccessToken) => {
   }
   return originalRequest.data;
 };
+var isObjectEmpty = (obj) => {
+  return Object.keys(obj).length === 0;
+};
+var useField = (props) => {
+  const [invisible, setInvisible] = react.useState(true);
+  const [required, setRequired] = react.useState(false);
+  const [readonly, setReadOnly] = react.useState(false);
+  const {
+    invisible: inv,
+    required: req,
+    readonly: rea,
+    onchangeData,
+    rootField,
+    index,
+    name
+  } = props;
+  const nameField = rootField ? `${rootField?.name}.${index}.${name}` : null;
+  react.useEffect(() => {
+    if (onchangeData && Object.keys(onchangeData).length > 0) {
+      setRequired(
+        typeof req === "object" ? matchDomains(onchangeData, req) : checkDomain(onchangeData, req)
+      );
+      setInvisible(matchDomains(onchangeData, inv));
+      setReadOnly(
+        typeof req === "object" ? matchDomains(onchangeData, rea) : checkDomain(onchangeData, rea)
+      );
+    }
+  }, [onchangeData]);
+  return {
+    invisible,
+    required,
+    readonly,
+    nameField
+  };
+};
+var downloadFile = async (url, filename) => {
+  try {
+    const response = await fetch(url);
+    if (!response.ok) throw new Error(`Failed to fetch ${url}`);
+    const contentType = response.headers.get("Content-Type") || "";
+    let ext = "";
+    if (contentType.includes("pdf")) ext = ".pdf";
+    else if (contentType.includes("png")) ext = ".png";
+    else if (contentType.includes("jpeg") || contentType.includes("jpg"))
+      ext = ".jpg";
+    else if (contentType.includes("zip")) ext = ".zip";
+    else if (contentType.includes("msword")) ext = ".doc";
+    else if (contentType.includes("spreadsheet")) ext = ".xls";
+    else if (contentType.includes("json")) ext = ".json";
+    else if (contentType.includes("text")) ext = ".txt";
+    else {
+      ext = "";
+    }
+    const blob = await response.blob();
+    const urlBlob = window.URL.createObjectURL(blob);
+    const link = document.createElement("a");
+    link.href = urlBlob;
+    link.download = (filename || "file") + ext;
+    document.body.appendChild(link);
+    link.click();
+    document.body.removeChild(link);
+    window.URL.revokeObjectURL(urlBlob);
+  } catch (error) {
+    console.error("File download failed:", error);
+  }
+};
+function cleanObject(obj) {
+  const result = {};
+  for (const [k, v] of Object.entries(obj)) {
+    if (v !== null && v !== void 0) {
+      result[k] = v;
+    }
+  }
+  return result;
+}
+var extractIdFromDomain = (domain) => {
+  if (!domain || !Array.isArray(domain)) return null;
+  const idCond = domain.find(
+    ([field, operator]) => field === "id" && operator === "="
+  );
+  return idCond ? Number(idCond[2]) : null;
+};
 
+// src/utils/storage/local-storage.ts
+var localStorageUtils = () => {
+  const setToken = async (access_token) => {
+    localStorage.setItem("accessToken", access_token);
+  };
+  const setRefreshToken = async (refresh_token) => {
+    localStorage.setItem("refreshToken", refresh_token);
+  };
+  const getAccessToken = async () => {
+    return localStorage.getItem("accessToken");
+  };
+  const getRefreshToken = async () => {
+    return localStorage.getItem("refreshToken");
+  };
+  const clearToken = async () => {
+    localStorage.removeItem("accessToken");
+    localStorage.removeItem("refreshToken");
+  };
+  return {
+    setToken,
+    setRefreshToken,
+    getAccessToken,
+    getRefreshToken,
+    clearToken
+  };
+};
 
+// src/utils/storage/session-storage.ts
+var sessionStorageUtils = /* @__PURE__ */ (() => {
+  const getMenuFocus = () => {
+    const menuFocus = sessionStorage.getItem("menuFocus");
+    return menuFocus ? JSON.parse(menuFocus) : {
+      id: void 0,
+      service: ""
+    };
+  };
+  const setMenuFocus = (menuTree) => {
+    sessionStorage.setItem("menuFocus", JSON.stringify({ ...menuTree }));
+  };
+  const getActionData = () => {
+    const actionData = sessionStorage.getItem("actionData");
+    return actionData ? JSON.parse(actionData) : {};
+  };
+  const setActionData = (actData) => {
+    sessionStorage.setItem("actionData", JSON.stringify(actData));
+  };
+  const getViewData = () => {
+    const viewData = sessionStorage.getItem("viewData");
+    return viewData ? JSON.parse(viewData) : {};
+  };
+  const getBrowserSession = () => {
+    const actionData = sessionStorage.getItem("browserSession");
+    return actionData ? JSON.parse(actionData) : null;
+  };
+  const setViewData = (viewData) => {
+    sessionStorage.setItem("viewData", JSON.stringify(viewData));
+  };
+  const getXNode = () => {
+    const xNode = sessionStorage.getItem("xNode");
+    return xNode;
+  };
+  const setXNode = (xNode) => {
+    sessionStorage.setItem("xNode", xNode);
+  };
+  return {
+    getMenuFocus,
+    setMenuFocus,
+    setActionData,
+    getActionData,
+    getViewData,
+    setViewData,
+    getBrowserSession,
+    getXNode,
+    setXNode
+  };
+})();
 
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-exports.localStorageUtils = localStorageUtils; exports.sessionStorageUtils = sessionStorageUtils; exports.makeContext = makeContext; exports.evalPartialContext = evalPartialContext; exports.InvalidDomainError = InvalidDomainError; exports.Domain = Domain; exports.evalDomain = evalDomain; exports.checkDomain = checkDomain; exports.matchDomains = matchDomains; exports.domainHelper = domainHelper; exports.evalJSONContext = evalJSONContext; exports.evalJSONDomain = evalJSONDomain; exports.formatSortingString = formatSortingString; exports.toQueryString = toQueryString; exports.cleanObject = cleanObject; exports.updateTokenParamInOriginalRequest = updateTokenParamInOriginalRequest;
+exports.WesapError = WesapError;
+exports.checkIsImageLink = checkIsImageLink;
+exports.cleanObject = cleanObject;
+exports.convertFloatToTime = convertFloatToTime;
+exports.convertTimeToFloat = convertTimeToFloat;
+exports.copyTextToClipboard = copyTextToClipboard;
+exports.domainHelper = domainHelper;
+exports.downloadFile = downloadFile;
+exports.evalJSONContext = evalJSONContext;
+exports.evalJSONDomain = evalJSONDomain;
+exports.extractIdFromDomain = extractIdFromDomain;
+exports.filterFieldDirty = filterFieldDirty;
+exports.formatCurrency = formatCurrency;
+exports.formatDate = formatDate;
+exports.formatFileSize = formatFileSize;
+exports.formatSortingString = formatSortingString;
+exports.formatUrlPath = formatUrlPath;
+exports.getFieldsOnChange = getFieldsOnChange;
+exports.getOffSet = getOffSet;
+exports.getSubdomain = getSubdomain;
+exports.handleError = handleError;
+exports.isBase64File = isBase64File;
+exports.isBase64Image = isBase64Image;
+exports.isObjectEmpty = isObjectEmpty;
+exports.localStorageUtils = localStorageUtils;
+exports.mergeObjects = mergeObjects;
+exports.removeUndefinedFields = removeUndefinedFields;
+exports.resequence = resequence;
+exports.sessionStorageUtils = sessionStorageUtils;
+exports.stringToColor = stringToColor;
+exports.toQueryString = toQueryString;
+exports.updateTokenParamInOriginalRequest = updateTokenParamInOriginalRequest;
+exports.useField = useField;
+exports.useTabModel = useTabModel;
+exports.validateAndParseDate = validateAndParseDate;