@gnwebsoft/ui 3.0.9 → 4.0.1

package/dist/chunk-NC3JINIM.cjs

@@ -0,0 +1,1596 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 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 _class; var _class2;// src/core/api/CorrelationIdGenerator.ts
+var CorrelationIdGenerator = class {
+  static generateUUID() {
+    if (typeof crypto !== "undefined" && crypto.randomUUID) {
+      return crypto.randomUUID();
+    }
+    return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+      const r = Math.random() * 16 | 0;
+      const v = c === "x" ? r : r & 3 | 8;
+      return v.toString(16);
+    });
+  }
+  static generate(prefix) {
+    const uuid = this.generateUUID();
+    return prefix ? `${prefix}-${uuid}` : uuid;
+  }
+};
+
+// src/core/api/RequestManager.ts
+var RequestManager = (_class = class {constructor() { _class.prototype.__init.call(this);_class.prototype.__init2.call(this); }
+  __init() {this.activeRequests = /* @__PURE__ */ new Map()}
+  __init2() {this.correlationMap = /* @__PURE__ */ new Map()}
+  add(key, controller, correlationId) {
+    this.cancel(key);
+    this.activeRequests.set(key, controller);
+    this.correlationMap.set(key, correlationId);
+  }
+  remove(key) {
+    this.activeRequests.delete(key);
+    this.correlationMap.delete(key);
+  }
+  cancel(key) {
+    const controller = this.activeRequests.get(key);
+    if (controller) {
+      controller.abort();
+      this.activeRequests.delete(key);
+      this.correlationMap.delete(key);
+    }
+  }
+  cancelAll() {
+    this.activeRequests.forEach((controller) => controller.abort());
+    this.activeRequests.clear();
+    this.correlationMap.clear();
+  }
+  has(key) {
+    return this.activeRequests.has(key);
+  }
+  getCorrelationId(key) {
+    return this.correlationMap.get(key);
+  }
+}, _class);
+
+// src/core/api/ApiClient.ts
+var ApiClient = (_class2 = class {
+  
+  
+  __init3() {this.requestInterceptors = []}
+  __init4() {this.responseInterceptors = []}
+  __init5() {this.errorInterceptors = []}
+  __init6() {this.authToken = null}
+  __init7() {this.refreshTokenPromise = null}
+  __init8() {this.requestManager = new RequestManager()}
+  __init9() {this.correlationIdPrefix = "api"}
+  __init10() {this.includeCorrelationId = true}
+  constructor(baseURL = "", defaultTimeout = 3e4) {;_class2.prototype.__init3.call(this);_class2.prototype.__init4.call(this);_class2.prototype.__init5.call(this);_class2.prototype.__init6.call(this);_class2.prototype.__init7.call(this);_class2.prototype.__init8.call(this);_class2.prototype.__init9.call(this);_class2.prototype.__init10.call(this);
+    this.baseURL = baseURL;
+    this.defaultTimeout = defaultTimeout;
+  }
+  // Configuration methods
+  setCorrelationIdPrefix(prefix) {
+    this.correlationIdPrefix = prefix;
+  }
+  setIncludeCorrelationId(include) {
+    this.includeCorrelationId = include;
+  }
+  // Interceptor management
+  addRequestInterceptor(interceptor) {
+    this.requestInterceptors.push(interceptor);
+    return () => {
+      const index = this.requestInterceptors.indexOf(interceptor);
+      if (index > -1) this.requestInterceptors.splice(index, 1);
+    };
+  }
+  addResponseInterceptor(interceptor) {
+    this.responseInterceptors.push(interceptor);
+    return () => {
+      const index = this.responseInterceptors.indexOf(interceptor);
+      if (index > -1) this.responseInterceptors.splice(index, 1);
+    };
+  }
+  addErrorInterceptor(interceptor) {
+    this.errorInterceptors.push(interceptor);
+    return () => {
+      const index = this.errorInterceptors.indexOf(interceptor);
+      if (index > -1) this.errorInterceptors.splice(index, 1);
+    };
+  }
+  // Auth token management
+  setAuthToken(token) {
+    this.authToken = token;
+  }
+  getAuthToken() {
+    return this.authToken;
+  }
+  // Request cancellation
+  cancelRequest(key) {
+    this.requestManager.cancel(key);
+  }
+  cancelAllRequests() {
+    this.requestManager.cancelAll();
+  }
+  // URL and params handling
+  buildURL(endpoint, params) {
+    const url = new URL(endpoint, this.baseURL);
+    if (params) {
+      Object.keys(params).forEach((key) => {
+        const value = params[key];
+        if (value !== void 0 && value !== null) {
+          if (Array.isArray(value)) {
+            value.forEach((v) => url.searchParams.append(key, String(v)));
+          } else {
+            url.searchParams.append(key, String(value));
+          }
+        }
+      });
+    }
+    return url.toString();
+  }
+  // Apply request interceptors
+  async applyRequestInterceptors(config) {
+    let modifiedConfig = { ...config };
+    for (const interceptor of this.requestInterceptors) {
+      modifiedConfig = await interceptor(modifiedConfig);
+    }
+    return modifiedConfig;
+  }
+  // Apply response interceptors
+  async applyResponseInterceptors(response) {
+    let modifiedResponse = response;
+    for (const interceptor of this.responseInterceptors) {
+      modifiedResponse = await interceptor(modifiedResponse);
+    }
+    return modifiedResponse;
+  }
+  // Apply error interceptors
+  async applyErrorInterceptors(error) {
+    let modifiedError = error;
+    for (const interceptor of this.errorInterceptors) {
+      try {
+        modifiedError = await interceptor(modifiedError);
+      } catch (e) {
+        modifiedError = e;
+      }
+    }
+    throw modifiedError;
+  }
+  // Create combined abort signal
+  createCombinedSignal(signals) {
+    const controller = new AbortController();
+    for (const signal of signals) {
+      if (signal) {
+        if (signal.aborted) {
+          controller.abort(signal.reason);
+          break;
+        }
+        signal.addEventListener(
+          "abort",
+          () => {
+            controller.abort(signal.reason);
+          },
+          { once: true }
+        );
+      }
+    }
+    return controller;
+  }
+  // Timeout handling with AbortSignal
+  createTimeoutSignal(timeout) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => {
+      controller.abort(`Request timeout after ${timeout}ms`);
+    }, timeout);
+    controller.signal.addEventListener(
+      "abort",
+      () => {
+        clearTimeout(timeoutId);
+      },
+      { once: true }
+    );
+    return controller;
+  }
+  // Retry logic with abort support
+  async retryRequest(fn, retries, delay, signal) {
+    try {
+      if (_optionalChain([signal, 'optionalAccess', _ => _.aborted])) {
+        throw new Error(signal.reason || "Request aborted");
+      }
+      return await fn();
+    } catch (error) {
+      if (error.name === "AbortError" || _optionalChain([signal, 'optionalAccess', _2 => _2.aborted])) {
+        throw error;
+      }
+      if (error.type === "validation_error" || error.status === 400) {
+        throw error;
+      }
+      if (retries === 0) throw error;
+      await new Promise((resolve, reject) => {
+        const timeoutId = setTimeout(resolve, delay);
+        if (signal) {
+          signal.addEventListener(
+            "abort",
+            () => {
+              clearTimeout(timeoutId);
+              reject(new Error(signal.reason || "Request aborted"));
+            },
+            { once: true }
+          );
+        }
+      });
+      return this.retryRequest(fn, retries - 1, delay * 2, signal);
+    }
+  }
+  // Main request method implementation
+  async request(endpoint, config = {}) {
+    const correlationId = config.correlationId || (!config.skipCorrelationId && this.includeCorrelationId ? CorrelationIdGenerator.generate(this.correlationIdPrefix) : void 0);
+    const requestKey = `${config.method || "GET"}_${endpoint}_${Date.now()}`;
+    const masterController = new AbortController();
+    try {
+      const signals = [
+        config.signal,
+        _optionalChain([config, 'access', _3 => _3.cancelToken, 'optionalAccess', _4 => _4.signal]),
+        masterController.signal
+      ];
+      const timeout = config.timeout || this.defaultTimeout;
+      const timeoutController = this.createTimeoutSignal(timeout);
+      signals.push(timeoutController.signal);
+      const combinedController = this.createCombinedSignal(signals);
+      if (correlationId) {
+        this.requestManager.add(requestKey, masterController, correlationId);
+      }
+      const finalConfig = await this.applyRequestInterceptors({
+        ...config,
+        signal: combinedController.signal,
+        correlationId
+      });
+      const url = this.buildURL(endpoint, finalConfig.params);
+      const headers = new Headers(finalConfig.headers);
+      if (correlationId) {
+        headers.set("X-Correlation-Id", correlationId);
+        headers.set("X-Request-Id", correlationId);
+      }
+      if (this.authToken && !finalConfig.skipAuthRefresh) {
+        headers.set("Authorization", `Bearer ${this.authToken}`);
+      }
+      if (finalConfig.body && typeof finalConfig.body === "object" && !(finalConfig.body instanceof FormData)) {
+        headers.set("Content-Type", "application/json");
+        finalConfig.body = JSON.stringify(finalConfig.body);
+      }
+      finalConfig.headers = headers;
+      const fetchPromise = async () => {
+        try {
+          const response = await fetch(url, {
+            ...finalConfig,
+            signal: combinedController.signal
+          });
+          const responseData = await this.parseResponseData(response);
+          if (!response.ok) {
+            const error = Object.assign(
+              new Error(
+                responseData.title || `HTTP ${response.status}: ${response.statusText}`
+              ),
+              {
+                type: responseData.type || this.getErrorType(response.status),
+                title: responseData.title || this.getErrorTitle(response.status),
+                status: response.status,
+                traceId: responseData.traceId || correlationId,
+                errors: responseData.errors,
+                isAborted: false,
+                config: finalConfig
+              }
+            );
+            if (finalConfig.throwErrors !== false) {
+              throw error;
+            } else {
+              return await this.applyResponseInterceptors({
+                error
+              });
+            }
+          }
+          const apiResponse = {
+            data: responseData
+          };
+          return await this.applyResponseInterceptors(apiResponse);
+        } catch (error) {
+          if (error.name === "AbortError") {
+            const abortError = Object.assign(
+              new Error(error.message || "Request aborted"),
+              {
+                type: "request_cancelled",
+                title: "Request was cancelled",
+                status: 0,
+                traceId: correlationId,
+                isAborted: true,
+                config: finalConfig
+              }
+            );
+            if (finalConfig.throwErrors !== false) {
+              throw abortError;
+            } else {
+              return await this.applyResponseInterceptors({
+                error: abortError
+              });
+            }
+          }
+          throw error;
+        }
+      };
+      if (finalConfig.retries && finalConfig.retries > 0) {
+        return await this.retryRequest(
+          fetchPromise,
+          finalConfig.retries,
+          finalConfig.retryDelay || 1e3,
+          combinedController.signal
+        );
+      }
+      return await fetchPromise();
+    } catch (error) {
+      const apiError = this.normalizeError(
+        error,
+        config,
+        correlationId
+      );
+      if (config.throwErrors !== false) {
+        await this.applyErrorInterceptors(apiError);
+        throw apiError;
+      } else {
+        return {
+          error: apiError
+        };
+      }
+    } finally {
+      this.requestManager.remove(requestKey);
+    }
+  }
+  // Get error type based on status code
+  getErrorType(status) {
+    if (status >= 400 && status < 500) {
+      return status === 400 ? "validation_error" : "client_error";
+    } else if (status >= 500) {
+      return "server_error";
+    }
+    return "unknown_error";
+  }
+  // Get error title based on status code
+  getErrorTitle(status) {
+    const titles = {
+      400: "Bad Request",
+      401: "Unauthorized",
+      403: "Forbidden",
+      404: "Not Found",
+      405: "Method Not Allowed",
+      408: "Request Timeout",
+      409: "Conflict",
+      422: "Unprocessable Entity",
+      429: "Too Many Requests",
+      500: "Internal Server Error",
+      502: "Bad Gateway",
+      503: "Service Unavailable",
+      504: "Gateway Timeout"
+    };
+    return titles[status] || `HTTP Error ${status}`;
+  }
+  // Parse response data based on content type
+  async parseResponseData(response) {
+    const contentType = response.headers.get("content-type");
+    if (_optionalChain([contentType, 'optionalAccess', _5 => _5.includes, 'call', _6 => _6("application/json")])) {
+      return response.json();
+    } else if (_optionalChain([contentType, 'optionalAccess', _7 => _7.includes, 'call', _8 => _8("text/")])) {
+      return response.text();
+    } else if (_optionalChain([contentType, 'optionalAccess', _9 => _9.includes, 'call', _10 => _10("application/octet-stream")])) {
+      return response.blob();
+    } else {
+      const text = await response.text();
+      try {
+        return JSON.parse(text);
+      } catch (e2) {
+        return text;
+      }
+    }
+  }
+  // Normalize errors
+  normalizeError(error, config, correlationId) {
+    if (error.type || error.title || error.errors) {
+      return Object.assign(
+        error instanceof Error ? error : new Error(error.message || "Unknown error"),
+        {
+          type: error.type,
+          title: error.title,
+          status: error.status,
+          traceId: error.traceId || correlationId,
+          errors: error.errors,
+          isAborted: error.isAborted || false,
+          config
+        }
+      );
+    }
+    if (error.name === "AbortError" || error.isAborted) {
+      return Object.assign(new Error(error.message || "Request was aborted"), {
+        type: "request_cancelled",
+        title: "Request was cancelled",
+        status: 0,
+        traceId: correlationId,
+        isAborted: true,
+        config
+      });
+    }
+    if (_optionalChain([error, 'access', _11 => _11.message, 'optionalAccess', _12 => _12.includes, 'call', _13 => _13("timeout")])) {
+      return Object.assign(new Error(error.message), {
+        type: "timeout_error",
+        title: "Request Timeout",
+        status: 408,
+        traceId: correlationId,
+        isAborted: true,
+        config
+      });
+    }
+    if (_optionalChain([error, 'access', _14 => _14.message, 'optionalAccess', _15 => _15.includes, 'call', _16 => _16("network")])) {
+      return Object.assign(
+        new Error(error.message || "Network request failed"),
+        {
+          type: "network_error",
+          title: "Network Error",
+          status: 0,
+          traceId: correlationId,
+          isAborted: false,
+          config
+        }
+      );
+    }
+    return Object.assign(
+      new Error(error.message || "An unknown error occurred"),
+      {
+        type: "unknown_error",
+        title: "Unknown Error",
+        status: 0,
+        traceId: correlationId,
+        isAborted: false,
+        config
+      }
+    );
+  }
+  get(endpoint, config) {
+    return this.request(endpoint, { ...config, method: "GET" });
+  }
+  post(endpoint, data, config) {
+    return this.request(endpoint, { ...config, method: "POST", body: data });
+  }
+  put(endpoint, data, config) {
+    return this.request(endpoint, { ...config, method: "PUT", body: data });
+  }
+  patch(endpoint, data, config) {
+    return this.request(endpoint, {
+      ...config,
+      method: "PATCH",
+      body: data
+    });
+  }
+  delete(endpoint, config) {
+    return this.request(endpoint, { ...config, method: "DELETE" });
+  }
+  filter(url, data, config) {
+    const mergedData = { ...data, ...data.filterModel };
+    return this.request(url, {
+      ...config,
+      method: "POST",
+      body: mergedData
+    });
+  }
+}, _class2);
+
+// src/core/api/createApiClient.ts
+var globalApiClient = null;
+function createApiClient(config = {}) {
+  const {
+    baseURL = import.meta.env.VITE_API_URL,
+    timeout = 3e4,
+    correlationIdPrefix = "api",
+    includeCorrelationId = true,
+    requestInterceptors = [],
+    responseInterceptors = [],
+    errorInterceptors = []
+  } = config;
+  const client = new ApiClient(baseURL, timeout);
+  client.addRequestInterceptor((config2) => {
+    const token = localStorage.getItem("serviceToken");
+    if (token && !config2.skipAuthRefresh) {
+      config2.headers = {
+        ...config2.headers,
+        Authorization: `Bearer ${token}`
+      };
+    }
+    return config2;
+  });
+  client.setCorrelationIdPrefix(correlationIdPrefix);
+  client.setIncludeCorrelationId(includeCorrelationId);
+  requestInterceptors.forEach((interceptor) => {
+    client.addRequestInterceptor(interceptor);
+  });
+  responseInterceptors.forEach((interceptor) => {
+    client.addResponseInterceptor(interceptor);
+  });
+  errorInterceptors.forEach((interceptor) => {
+    client.addErrorInterceptor(interceptor);
+  });
+  return client;
+}
+function getGlobalApiClient(config) {
+  if (!globalApiClient) {
+    globalApiClient = createApiClient(config);
+  }
+  return globalApiClient;
+}
+function setGlobalApiClient(client) {
+  globalApiClient = client;
+}
+function resetGlobalApiClient() {
+  globalApiClient = null;
+}
+
+// src/core/api/types/CancelToken.ts
+var CancelToken = class _CancelToken {
+  
+  
+  
+  constructor() {
+    this.abortController = new AbortController();
+    this.cancelPromise = new Promise((resolve) => {
+      this.cancelResolve = resolve;
+    });
+  }
+  get signal() {
+    return this.abortController.signal;
+  }
+  cancel(reason) {
+    this.abortController.abort(reason);
+    _optionalChain([this, 'access', _17 => _17.cancelResolve, 'optionalCall', _18 => _18()]);
+  }
+  get isCancelled() {
+    return this.abortController.signal.aborted;
+  }
+  throwIfCancelled() {
+    if (this.isCancelled) {
+      throw new Error("Request cancelled");
+    }
+  }
+  static source() {
+    const token = new _CancelToken();
+    return {
+      token,
+      cancel: (reason) => token.cancel(reason)
+    };
+  }
+};
+
+// src/core/api/useValidationErrors.ts
+var _react = require('react');
+function useValidationErrors(error) {
+  const getFieldError = _react.useCallback.call(void 0, 
+    (field) => {
+      if (!_optionalChain([error, 'optionalAccess', _19 => _19.errors]) || !error.errors[field]) return null;
+      const fieldError = error.errors[field];
+      if (typeof fieldError === "string") return fieldError;
+      if (Array.isArray(fieldError)) return fieldError[0];
+      if (typeof fieldError === "object" && "message" in fieldError) {
+        return fieldError.message;
+      }
+      return null;
+    },
+    [error]
+  );
+  const hasFieldError = _react.useCallback.call(void 0, 
+    (field) => {
+      return !!getFieldError(field);
+    },
+    [getFieldError]
+  );
+  const getAllErrors = _react.useCallback.call(void 0, () => {
+    if (!_optionalChain([error, 'optionalAccess', _20 => _20.errors])) return {};
+    const result = {};
+    Object.entries(error.errors).forEach(([key, value]) => {
+      if (typeof value === "string") {
+        result[key] = value;
+      } else if (Array.isArray(value)) {
+        result[key] = value.join(", ");
+      } else if (typeof value === "object" && value && "message" in value) {
+        result[key] = value.message;
+      }
+    });
+    return result;
+  }, [error]);
+  return {
+    getFieldError,
+    hasFieldError,
+    getAllErrors,
+    hasErrors: _optionalChain([error, 'optionalAccess', _21 => _21.errors])
+  };
+}
+
+// src/core/components/AuthorizedView/AuthorizedView.tsx
+var _jsxruntime = require('react/jsx-runtime');
+var AuthorizedView = ({ children, show }) => {
+  if (!show) return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _jsxruntime.Fragment, {});
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _jsxruntime.Fragment, { children });
+};
+
+// src/core/components/CancelButton/CancelButton.tsx
+var _material = require('@mui/material');
+
+var CancelButton = ({
+  children = "Cancel",
+  variant = "outlined",
+  sx,
+  ...rest
+}) => /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _material.Button, { variant, sx: { width: "6rem", ...sx }, ...rest, children });
+
+// src/core/components/ClearButton/ClearButton.tsx
+
+
+var ClearButton = ({
+  isSubmitting,
+  handleClear,
+  sx,
+  storeKey
+}) => {
+  const onClick = () => {
+    handleClear();
+    if (storeKey != null) {
+      localStorage.removeItem(storeKey);
+    }
+  };
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+    _material.Button,
+    {
+      variant: "outlined",
+      onClick,
+      disabled: isSubmitting,
+      sx,
+      children: "Clear"
+    }
+  );
+};
+
+// src/core/components/Containers/SimpleContainer.tsx
+
+
+var SimpleContainer = ({
+  children,
+  className,
+  sx
+}) => /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _material.Container, { className, sx: { ...sx }, children });
+
+// src/core/components/FilterButton/FilterButton.tsx
+var _FilterAlt = require('@mui/icons-material/FilterAlt'); var _FilterAlt2 = _interopRequireDefault(_FilterAlt);
+var _lab = require('@mui/lab');
+
+
+var FilterButton = ({
+  isSubmitting,
+  show,
+  title,
+  icon,
+  sx,
+  iconSx
+}) => {
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+    _lab.LoadingButton,
+    {
+      type: "submit",
+      variant: "contained",
+      loading: isSubmitting,
+      disabled: !show,
+      disableRipple: true,
+      color: "primary",
+      sx: {
+        display: "flex",
+        alignItems: "center",
+        ...sx
+      },
+      startIcon: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _material.Badge, { color: "error", variant: "standard", children: icon ? icon : /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _FilterAlt2.default, { width: "20", height: "20", sx: iconSx }) }),
+      children: _optionalChain([title, 'optionalAccess', _22 => _22.trim, 'call', _23 => _23()]) === "" || !title ? "Filter" : title
+    }
+  );
+};
+
+// src/core/components/FilterDisplay/FilterChip.tsx
+var _Chip = require('@mui/material/Chip'); var _Chip2 = _interopRequireDefault(_Chip);
+
+
+var FilterChip = _react.memo.call(void 0, 
+  ({
+    fieldKey,
+    filter,
+    onDelete
+  }) => {
+    const hasValue = filter.Value !== null && filter.Value !== void 0 && filter.Value !== "";
+    const label = `${fieldKey.replace("PK", "")}: ${filter.Label}`;
+    return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+      _Chip2.default,
+      {
+        label,
+        variant: hasValue ? "filled" : "outlined",
+        size: "small",
+        onDelete: hasValue ? onDelete : void 0
+      },
+      fieldKey
+    );
+  }
+);
+FilterChip.displayName = "FilterChip";
+
+// src/core/components/FilterDisplay/FilterDisplay.tsx
+
+
+
+var ProgramsFilterDisplay = _react.memo.call(void 0, 
+  (props) => {
+    const { friendlyFilter, onFriendlyFilterChange } = props;
+    const deleteHandlers = _react.useMemo.call(void 0, () => {
+      if (!onFriendlyFilterChange) return {};
+      const handlers = {};
+      for (const key of Object.keys(friendlyFilter)) {
+        handlers[key] = () => onFriendlyFilterChange(key);
+      }
+      return handlers;
+    }, [onFriendlyFilterChange, friendlyFilter]);
+    const chipList = _react.useMemo.call(void 0, () => {
+      return Object.entries(friendlyFilter).map(([key, filter]) => /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+        FilterChip,
+        {
+          fieldKey: key,
+          filter,
+          onDelete: deleteHandlers[key]
+        },
+        key
+      ));
+    }, [friendlyFilter, deleteHandlers]);
+    return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _material.Card, { sx: { mb: 2 }, children: /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, _material.CardContent, { children: [
+      /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _material.Typography, { variant: "h6", gutterBottom: true, children: "Active Filters" }),
+      /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _material.Box, { display: "flex", gap: 1, flexWrap: "wrap", children: chipList })
+    ] }) });
+  }
+);
+ProgramsFilterDisplay.displayName = "FilterDisplay";
+
+// src/core/components/FilterWrapper/FilterWrapper.tsx
+var _ManageSearch = require('@mui/icons-material/ManageSearch'); var _ManageSearch2 = _interopRequireDefault(_ManageSearch);
+
+
+
+
+
+
+
+
+
+
+
+var FilterWrapper = ({
+  children,
+  title,
+  filterCount,
+  cardSx,
+  textSx,
+  icon,
+  iconSx,
+  showCount
+}) => {
+  const theme = _material.useTheme.call(void 0, );
+  return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, 
+    _material.Card,
+    {
+      sx: {
+        position: "relative",
+        borderRadius: "0px",
+        mb: 2,
+        ...cardSx
+      },
+      children: [
+        /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+          _material.CardHeader,
+          {
+            sx: {
+              display: "flex",
+              flexWrap: "wrap",
+              p: "1rem",
+              ".MuiCardHeader-action": {
+                margin: 0,
+                alignSelf: "center"
+              },
+              alignItems: "center"
+            },
+            title: /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, _material.Box, { sx: { display: "flex", alignItems: "center", gap: 0.5 }, children: [
+              icon ? icon : /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+                _ManageSearch2.default,
+                {
+                  sx: {
+                    height: "2.5rem",
+                    color: theme.palette.primary.main,
+                    ...iconSx
+                  }
+                }
+              ),
+              /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, 
+                _material.Typography,
+                {
+                  variant: "h5",
+                  sx: {
+                    fontWeight: "bold",
+                    color: theme.palette.primary.main,
+                    ...textSx
+                  },
+                  children: [
+                    title ? title : "Filter",
+                    " ",
+                    showCount ? `(${filterCount ? filterCount : 0})` : /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _jsxruntime.Fragment, {})
+                  ]
+                }
+              )
+            ] })
+          }
+        ),
+        /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _material.Divider, {}),
+        /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _material.CardContent, { sx: { py: 2 }, children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _material.Grid, { container: true, spacing: 2, children }) })
+      ]
+    }
+  );
+};
+
+// src/core/components/Footer/Footer.tsx
+
+
+var Footer = () => {
+  const currentYear = (/* @__PURE__ */ new Date()).getFullYear();
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+    _material.Box,
+    {
+      component: "footer",
+      sx: {
+        py: 2,
+        px: 4,
+        mt: "auto",
+        backgroundColor: (theme) => theme.palette.mode === "light" ? theme.palette.grey[200] : theme.palette.grey[800]
+      },
+      children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _material.Typography, { variant: "body2", color: "text.secondary", align: "center", children: `\xA9 Copyright ${currentYear} GN. All rights reserved by Parul University.` })
+    }
+  );
+};
+
+// src/core/components/LabelText/LabelText.tsx
+
+
+var LabelText = ({
+  label,
+  value,
+  gridSize,
+  containerSize,
+  labelSx,
+  valueSx
+}) => {
+  const defaultGridSize = {
+    labelSize: { xs: 6, sm: 6, md: 6 },
+    valueSize: { xs: 12, sm: 6, md: 6 }
+  };
+  const defaultContainerSize = { xs: 12, sm: 6, md: 6 };
+  const size = gridSize || defaultGridSize;
+  const container = containerSize || defaultContainerSize;
+  return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, 
+    _material.Grid,
+    {
+      size: container,
+      sx: {
+        display: "flex",
+        flexDirection: { xs: "column", sm: "row", md: "row" },
+        "&:hover": { bgcolor: "#efefef", overflow: "hidden" }
+      },
+      children: [
+        /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, 
+          _material.Grid,
+          {
+            size: size.labelSize,
+            sx: {
+              padding: "5px",
+              fontSize: "14px",
+              textAlign: { xs: "left", sm: "right", md: "right" },
+              ...labelSx
+            },
+            children: [
+              label,
+              " :"
+            ]
+          }
+        ),
+        /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+          _material.Grid,
+          {
+            size: size.valueSize,
+            sx: { padding: "5px", display: "flex", flexWrap: "wrap" },
+            children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _material.Tooltip, { title: value, arrow: true, children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+              _material.Typography,
+              {
+                sx: {
+                  fontSize: "14px",
+                  wordBreak: "break-word",
+                  overflow: "hidden",
+                  display: "-webkit-box",
+                  textOverflow: "ellipsis",
+                  WebkitLineClamp: 2,
+                  WebkitBoxOrient: "vertical",
+                  ...valueSx,
+                  color: "#078dee"
+                },
+                children: value ? value : "-"
+              }
+            ) })
+          }
+        )
+      ]
+    }
+  );
+};
+
+// src/core/components/RenderIf/RenderIf.tsx
+
+var RenderIf = ({
+  show,
+  children
+}) => {
+  return show ? /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _jsxruntime.Fragment, { children }) : null;
+};
+
+// src/core/components/SectionBox/SectionBox.tsx
+
+
+
+var getSectionTheme = (variant = "default") => {
+  const themes = {
+    default: {
+      bgcolor: "#faebd7",
+      color: "#925d21"
+    },
+    form: {
+      bgcolor: "#cdced1",
+      color: "black"
+    },
+    info: {
+      bgcolor: "#e3f2fd",
+      color: "#1976d2"
+    },
+    warning: {
+      bgcolor: "#fff3e0",
+      color: "#f57c00"
+    },
+    error: {
+      bgcolor: "#ffebee",
+      color: "#d32f2f"
+    }
+  };
+  return themes[variant];
+};
+var SectionBox = _react.memo.call(void 0, 
+  ({
+    title,
+    children,
+    spacing = 0,
+    containerSx,
+    titleSx,
+    variant = "default",
+    icon,
+    actions
+  }) => {
+    const themeColors = _react.useMemo.call(void 0, () => getSectionTheme(variant), [variant]);
+    const headerSx = _react.useMemo.call(void 0, 
+      () => ({
+        px: 1.5,
+        py: 0.1,
+        width: "fit-content",
+        ...themeColors,
+        ...titleSx
+      }),
+      [themeColors, titleSx]
+    );
+    const contentSx = _react.useMemo.call(void 0, 
+      () => ({
+        padding: "16px",
+        ...containerSx
+      }),
+      [containerSx]
+    );
+    return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, _jsxruntime.Fragment, { children: [
+      /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, _material.Box, { sx: { display: "flex", flexDirection: "column", width: "100%" }, children: [
+        /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, 
+          _material.Stack,
+          {
+            direction: "row",
+            justifyContent: "space-between",
+            alignItems: "center",
+            sx: headerSx,
+            children: [
+              /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, _material.Stack, { direction: "row", alignItems: "center", spacing: 1, children: [
+                icon,
+                /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _material.Typography, { sx: { fontSize: "15px", fontWeight: 400 }, children: title })
+              ] }),
+              actions
+            ]
+          }
+        ),
+        /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _material.Divider, {})
+      ] }),
+      /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _material.Grid, { container: true, spacing, sx: contentSx, children })
+    ] });
+  }
+);
+
+// src/core/components/SimpleTabs/SimpleTabs.tsx
+
+
+
+
+var SimpleTabs = ({
+  tabs,
+  defaultValue = 1,
+  onTabChange,
+  children,
+  tabSx,
+  tabsSx
+}) => {
+  const [value, setValue] = _react.useState.call(void 0, defaultValue);
+  const handleChange = (event, newValue) => {
+    setValue(newValue);
+    if (onTabChange) onTabChange(newValue);
+  };
+  return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, _lab.TabContext, { value, children: [
+    /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _material.Box, { sx: { borderBottom: 1, borderColor: "divider", width: "100%" }, children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+      _material.Tabs,
+      {
+        value,
+        onChange: handleChange,
+        sx: { px: 2, py: 0, ...tabsSx },
+        children: tabs.map((tab) => /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+          _material.Tab,
+          {
+            label: tab.label,
+            value: tab.value,
+            disabled: tab.permission === false,
+            sx: { fontSize: "1rem", ...tabSx }
+          },
+          tab.value
+        ))
+      }
+    ) }),
+    children
+  ] });
+};
+
+// src/core/components/SubmitButton/SubmitButton.tsx
+
+
+var SubmitButton = ({
+  loading = false,
+  ...rest
+}) => /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+  _lab.LoadingButton,
+  {
+    loading,
+    variant: "contained",
+    color: "primary",
+    type: "submit",
+    ...rest,
+    sx: { fontWeight: 400 },
+    children: "Submit"
+  }
+);
+
+// src/core/components/WithRef/WithRef.tsx
+
+function withDataModal(component) {
+  return _react.forwardRef.call(void 0, 
+    (props, ref) => component({ ...props, ref })
+  );
+}
+
+// src/core/config.ts
+var Config = {
+  defaultPageSize: 20,
+  apiBaseUrl: "http://localhost:5143"
+  // apiBaseUrl: 'http://192.168.1.246:5143',
+};
+var dateTimePatterns = {
+  dateTime: "DD MMM YYYY h:mm A",
+  // 17 Apr 2022 12:00 am
+  date: "DD MMM YYYY",
+  // 17 Apr 2022
+  month_year_short_format: "MMM YYYY",
+  month_year_full_format: "MMMM YYYY",
+  year: "YYYY",
+  time: "h:mm a",
+  // 12:00 am
+  split: {
+    dateTime: "DD/MM/YYYY h:mm A",
+    // 17/04/2022 12:00 am
+    date: "DD/MM/YYYY"
+    // 17/04/2022
+  },
+  paramCase: {
+    dateTime: "DD-MM-YYYY h:mm A",
+    // 17-04-2022 12:00 am
+    date: "DD-MM-YYYY",
+    // 17-04-2022
+    dateReverse: "YYYY-MM-DD",
+    // 2022-04-17 for compare date
+    MonthYear: "MMM-YYYY"
+  }
+};
+
+// src/core/hooks/useApiClient.ts
+
+function useApiClient(config = {}) {
+  return _react.useMemo.call(void 0, () => {
+    return createApiClient(config);
+  }, [
+    config.baseURL,
+    config.timeout,
+    config.correlationIdPrefix,
+    config.includeCorrelationId,
+    config.authToken,
+    config.requestInterceptors,
+    config.responseInterceptors,
+    config.errorInterceptors
+  ]);
+}
+
+// src/core/hooks/useFormErrorHandler.ts
+
+var _sonner = require('sonner');
+var useFormErrorHandler = ({
+  setError,
+  successMessage = {
+    create: "Created successfully",
+    update: "Updated successfully"
+  },
+  errorMessage = {
+    noChanges: "No changes were made",
+    general: "Failed to save. Please try again."
+  }
+}) => {
+  const getFieldError = _react.useCallback.call(void 0, 
+    (fields, fieldName) => {
+      if (!fields || !fields[fieldName]) return void 0;
+      const fieldError = fields[fieldName];
+      if (typeof fieldError === "string") {
+        return fieldError;
+      }
+      if (Array.isArray(fieldError)) {
+        return fieldError.join(", ");
+      }
+      if (typeof fieldError === "object" && "message" in fieldError) {
+        return fieldError.message;
+      }
+      return void 0;
+    },
+    []
+  );
+  const handleSuccess = _react.useCallback.call(void 0, 
+    (isEditing, rowsAffected) => {
+      if (rowsAffected !== void 0 && rowsAffected > 0) {
+        _sonner.toast.success(isEditing ? successMessage.update : successMessage.create);
+        return true;
+      } else if (rowsAffected === 0) {
+        _sonner.toast.error(errorMessage.noChanges);
+        return false;
+      }
+      _sonner.toast.success(isEditing ? successMessage.update : successMessage.create);
+      return true;
+    },
+    [successMessage, errorMessage]
+  );
+  const handleError = _react.useCallback.call(void 0, 
+    (processedError) => {
+      if (processedError.type === "validation_error" && processedError.errors && setError) {
+        Object.keys(processedError.errors).forEach((fieldName) => {
+          const fieldError = getFieldError(processedError.errors, fieldName);
+          if (fieldError) {
+            setError(fieldName, {
+              type: "server",
+              message: fieldError
+            });
+          }
+        });
+        _sonner.toast.error(processedError.title || "Please check the form for validation errors");
+      } else {
+        _sonner.toast.error(processedError.title || errorMessage.general);
+      }
+    },
+    [errorMessage.general, getFieldError, setError]
+  );
+  return {
+    handleSuccess,
+    handleError
+  };
+};
+var useDeleteHandler = ({
+  successMessage = "Deleted successfully",
+  errorMessage = "Failed to delete. Please try again."
+} = {}) => {
+  return useFormErrorHandler({
+    successMessage: {
+      create: successMessage,
+      // Not used for delete, but required for type
+      update: successMessage
+    },
+    errorMessage: {
+      noChanges: "No changes were made",
+      // Not typically used for delete
+      general: errorMessage
+    }
+    // setError is omitted (undefined) for delete operations
+  });
+};
+
+// src/core/utils/CacheUtility/index.ts
+var _reactquery = require('@tanstack/react-query');
+
+var CacheUtility = class {
+  constructor(queryClient) {
+    this.queryClient = queryClient;
+  }
+  /**
+   * Get cached data using only the queryKey from query factory
+   */
+  getCachedData(queryKey) {
+    return this.queryClient.getQueryData(queryKey);
+  }
+  /**
+   * Get cached data with transformation using select function
+   */
+  getCachedDataWithSelect(queryKey, select) {
+    const cachedData = this.queryClient.getQueryData(queryKey);
+    if (cachedData === void 0) {
+      return void 0;
+    }
+    return select(cachedData);
+  }
+};
+function useCacheUtility() {
+  const queryClient = _reactquery.useQueryClient.call(void 0, );
+  return _react.useMemo.call(void 0, () => new CacheUtility(queryClient), [queryClient]);
+}
+
+// src/core/utils/watch/core.ts
+var _reacthookform = require('react-hook-form');
+var useWatchForm = (control) => _reacthookform.useWatch.call(void 0, { control });
+var useWatchField = (control, name) => _reacthookform.useWatch.call(void 0, { control, name });
+var useWatchFields = (control, names) => _reacthookform.useWatch.call(void 0, { control, name: names });
+
+// src/core/utils/watch/utilities.ts
+
+
+var useWatchTransform = (control, name, transform) => {
+  const value = _reacthookform.useWatch.call(void 0, { control, name });
+  return _react.useMemo.call(void 0, () => transform(value), [value, transform]);
+};
+var useWatchDefault = (control, name, defaultValue) => {
+  const value = _reacthookform.useWatch.call(void 0, { control, name });
+  return _nullishCoalesce(value, () => ( defaultValue));
+};
+var useWatchBoolean = (control, name, defaultValue = false) => {
+  const value = _reacthookform.useWatch.call(void 0, { control, name });
+  return Boolean(_nullishCoalesce(value, () => ( defaultValue)));
+};
+var useWatchBatch = (control, fields) => {
+  const values = _reacthookform.useWatch.call(void 0, { control, name: fields });
+  return _react.useMemo.call(void 0, () => {
+    const result = {};
+    fields.forEach((field, index) => {
+      result[field] = values[index];
+    });
+    return result;
+  }, [values, fields]);
+};
+var useWatchConditional = (control, name, shouldWatch, fallback) => {
+  const activeValue = _reacthookform.useWatch.call(void 0, {
+    control,
+    name,
+    disabled: !shouldWatch
+  });
+  return shouldWatch ? activeValue : fallback;
+};
+var useWatchDebounced = (control, name, delay = 300) => {
+  const value = _reacthookform.useWatch.call(void 0, { control, name });
+  const [debouncedValue, setDebouncedValue] = _react.useState.call(void 0, value);
+  _react.useEffect.call(void 0, () => {
+    const timer = setTimeout(() => {
+      setDebouncedValue(value);
+    }, delay);
+    return () => clearTimeout(timer);
+  }, [value, delay]);
+  return debouncedValue;
+};
+var useWatchSelector = (control, name, selector, deps = []) => {
+  const value = _reacthookform.useWatch.call(void 0, { control, name });
+  return _react.useMemo.call(void 0, 
+    () => selector(value),
+    [value, selector, ...deps]
+    // eslint-disable-line react-hooks/exhaustive-deps
+  );
+};
+
+// src/core/utils/watch/index.ts
+var typedWatch = {
+  // === CORE FUNCTIONS ===
+  /** Watch entire form */
+  form: useWatchForm,
+  /** Watch single field */
+  field: useWatchField,
+  /** Watch multiple fields */
+  fields: useWatchFields,
+  // === UTILITY FUNCTIONS ===
+  /** Watch with transformation */
+  transform: useWatchTransform,
+  /** Watch with default value */
+  withDefault: useWatchDefault,
+  /** Watch as boolean */
+  boolean: useWatchBoolean,
+  /** Watch multiple with custom keys */
+  batch: useWatchBatch,
+  /** Watch conditionally */
+  conditional: useWatchConditional,
+  /** Watch with debouncing */
+  debounced: useWatchDebounced,
+  /** Watch with selector */
+  selector: useWatchSelector
+};
+
+// src/core/utils/calculateFilterCount.ts
+var calculateFilterCount = (model) => Object.values(model).filter(
+  (v) => v !== null && v !== void 0 && String(v).trim() !== ""
+).length;
+
+// src/core/utils/format-time.ts
+var _dayjs = require('dayjs'); var _dayjs2 = _interopRequireDefault(_dayjs);
+var _duration = require('dayjs/plugin/duration'); var _duration2 = _interopRequireDefault(_duration);
+var _relativeTime = require('dayjs/plugin/relativeTime'); var _relativeTime2 = _interopRequireDefault(_relativeTime);
+_dayjs2.default.extend(_duration2.default);
+_dayjs2.default.extend(_relativeTime2.default);
+var formatPatterns = {
+  dateTime: "DD MMM YYYY h:mm A",
+  // 17 Apr 2022 12:00 am
+  date: "DD MMM YYYY",
+  // 17 Apr 2022
+  month_year_short_format: "MMM YYYY",
+  month_year_full_format: "MMMM YYYY",
+  year: "YYYY",
+  time: "h:mm a",
+  // 12:00 am
+  split: {
+    dateTime: "DD/MM/YYYY h:mm A",
+    // 17/04/2022 12:00 am
+    date: "DD/MM/YYYY"
+    // 17/04/2022
+  },
+  paramCase: {
+    dateTime: "DD-MM-YYYY h:mm A",
+    // 17-04-2022 12:00 am
+    date: "DD-MM-YYYY",
+    // 17-04-2022
+    dateReverse: "YYYY-MM-DD",
+    // 2022-04-17 for compare date
+    MonthYear: "MMM-YYYY"
+  }
+};
+var isValidDate = (date) => date !== null && date !== void 0 && _dayjs2.default.call(void 0, date).isValid();
+function today(template) {
+  return _dayjs2.default.call(void 0, /* @__PURE__ */ new Date()).startOf("day").format(template);
+}
+function fDateTime(date, template) {
+  if (!isValidDate(date)) {
+    return "Invalid date";
+  }
+  return _dayjs2.default.call(void 0, date).format(_nullishCoalesce(template, () => ( formatPatterns.dateTime)));
+}
+function fDate(date, template) {
+  if (!isValidDate(date)) {
+    return "Invalid date";
+  }
+  return _dayjs2.default.call(void 0, date).format(_nullishCoalesce(template, () => ( formatPatterns.date)));
+}
+function fTime(date, template) {
+  if (!isValidDate(date)) {
+    return "Invalid date";
+  }
+  return _dayjs2.default.call(void 0, date).format(_nullishCoalesce(template, () => ( formatPatterns.time)));
+}
+function fTimestamp(date) {
+  if (!isValidDate(date)) {
+    return "Invalid date";
+  }
+  return _dayjs2.default.call(void 0, date).valueOf();
+}
+function fToNow(date) {
+  if (!isValidDate(date)) {
+    return "Invalid date";
+  }
+  return _dayjs2.default.call(void 0, date).toNow(true);
+}
+function fIsBetween(inputDate, startDate, endDate) {
+  if (!isValidDate(inputDate) || !isValidDate(startDate) || !isValidDate(endDate)) {
+    return false;
+  }
+  const formattedInputDate = fTimestamp(inputDate);
+  const formattedStartDate = fTimestamp(startDate);
+  const formattedEndDate = fTimestamp(endDate);
+  if (formattedInputDate === "Invalid date" || formattedStartDate === "Invalid date" || formattedEndDate === "Invalid date") {
+    return false;
+  }
+  return formattedInputDate >= formattedStartDate && formattedInputDate <= formattedEndDate;
+}
+function fIsAfter(startDate, endDate) {
+  if (!isValidDate(startDate) || !isValidDate(endDate)) {
+    return false;
+  }
+  return _dayjs2.default.call(void 0, startDate).isAfter(endDate);
+}
+function fIsSame(startDate, endDate, unitToCompare) {
+  if (!isValidDate(startDate) || !isValidDate(endDate)) {
+    return false;
+  }
+  return _dayjs2.default.call(void 0, startDate).isSame(endDate, _nullishCoalesce(unitToCompare, () => ( "year")));
+}
+function fDateRangeShortLabel(startDate, endDate, initial) {
+  if (!isValidDate(startDate) || !isValidDate(endDate) || fIsAfter(startDate, endDate)) {
+    return "Invalid date";
+  }
+  let label = `${fDate(startDate)} - ${fDate(endDate)}`;
+  if (initial) {
+    return label;
+  }
+  const isSameYear = fIsSame(startDate, endDate, "year");
+  const isSameMonth = fIsSame(startDate, endDate, "month");
+  const isSameDay = fIsSame(startDate, endDate, "day");
+  if (isSameYear && !isSameMonth) {
+    label = `${fDate(startDate, "DD MMM")} - ${fDate(endDate)}`;
+  } else if (isSameYear && isSameMonth && !isSameDay) {
+    label = `${fDate(startDate, "DD")} - ${fDate(endDate)}`;
+  } else if (isSameYear && isSameMonth && isSameDay) {
+    label = `${fDate(endDate)}`;
+  }
+  return label;
+}
+function fAdd({
+  years = 0,
+  months = 0,
+  days = 0,
+  hours = 0,
+  minutes = 0,
+  seconds = 0,
+  milliseconds = 0
+}) {
+  const result = _dayjs2.default.call(void 0, ).add(
+    _dayjs2.default.duration({
+      years,
+      months,
+      days,
+      hours,
+      minutes,
+      seconds,
+      milliseconds
+    })
+  ).format();
+  return result;
+}
+function fSub({
+  years = 0,
+  months = 0,
+  days = 0,
+  hours = 0,
+  minutes = 0,
+  seconds = 0,
+  milliseconds = 0
+}) {
+  const result = _dayjs2.default.call(void 0, ).subtract(
+    _dayjs2.default.duration({
+      years,
+      months,
+      days,
+      hours,
+      minutes,
+      seconds,
+      milliseconds
+    })
+  ).format();
+  return result;
+}
+
+// src/core/utils/getEmptyObject.ts
+function getEmptyObject(data, defaultValues = {}) {
+  const obj = {};
+  for (const key of Object.keys(data)) {
+    const value = data[key];
+    const type = typeof value;
+    if (type === "number") {
+      obj[key] = 0;
+    } else if (type === "string" || type === "boolean") {
+      obj[key] = null;
+    } else if (value instanceof Date) {
+      obj[key] = null;
+    } else {
+      obj[key] = null;
+    }
+  }
+  return { ...obj, ...defaultValues };
+}
+
+// src/core/utils/useStableRowCount.ts
+
+function useStableRowCount(currentTotal) {
+  const rowCountRef = _react.useRef.call(void 0, currentTotal || 0);
+  const stableRowCount = _react.useMemo.call(void 0, () => {
+    if (currentTotal !== void 0) {
+      rowCountRef.current = currentTotal;
+    }
+    return rowCountRef.current;
+  }, [currentTotal]);
+  return stableRowCount;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.CorrelationIdGenerator = CorrelationIdGenerator; exports.RequestManager = RequestManager; exports.ApiClient = ApiClient; exports.createApiClient = createApiClient; exports.getGlobalApiClient = getGlobalApiClient; exports.setGlobalApiClient = setGlobalApiClient; exports.resetGlobalApiClient = resetGlobalApiClient; exports.CancelToken = CancelToken; exports.useValidationErrors = useValidationErrors; exports.AuthorizedView = AuthorizedView; exports.CancelButton = CancelButton; exports.ClearButton = ClearButton; exports.SimpleContainer = SimpleContainer; exports.FilterButton = FilterButton; exports.FilterChip = FilterChip; exports.ProgramsFilterDisplay = ProgramsFilterDisplay; exports.FilterWrapper = FilterWrapper; exports.Footer = Footer; exports.LabelText = LabelText; exports.RenderIf = RenderIf; exports.SectionBox = SectionBox; exports.SimpleTabs = SimpleTabs; exports.SubmitButton = SubmitButton; exports.withDataModal = withDataModal; exports.Config = Config; exports.dateTimePatterns = dateTimePatterns; exports.useApiClient = useApiClient; exports.useFormErrorHandler = useFormErrorHandler; exports.useDeleteHandler = useDeleteHandler; exports.CacheUtility = CacheUtility; exports.useCacheUtility = useCacheUtility; exports.useWatchForm = useWatchForm; exports.useWatchField = useWatchField; exports.useWatchFields = useWatchFields; exports.useWatchTransform = useWatchTransform; exports.useWatchDefault = useWatchDefault; exports.useWatchBoolean = useWatchBoolean; exports.useWatchBatch = useWatchBatch; exports.useWatchConditional = useWatchConditional; exports.useWatchDebounced = useWatchDebounced; exports.useWatchSelector = useWatchSelector; exports.typedWatch = typedWatch; exports.calculateFilterCount = calculateFilterCount; exports.formatPatterns = formatPatterns; exports.today = today; exports.fDateTime = fDateTime; exports.fDate = fDate; exports.fTime = fTime; exports.fTimestamp = fTimestamp; exports.fToNow = fToNow; exports.fIsBetween = fIsBetween; exports.fIsAfter = fIsAfter; exports.fIsSame = fIsSame; exports.fDateRangeShortLabel = fDateRangeShortLabel; exports.fAdd = fAdd; exports.fSub = fSub; exports.getEmptyObject = getEmptyObject; exports.useStableRowCount = useStableRowCount;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["d:\\Projects\\GNWebSoft.UI\\packages\\ui\\dist\\chunk-NC3JINIM.cjs"],"names":[],"mappings":"AAAA;AACA,IAAI,uBAAuB,EAAE,MAAM;AACnC,EAAE,OAAO,YAAY,CAAC,EAAE;AACxB,IAAI,GAAG,CAAC,OAAO,OAAO,IAAI,YAAY,GAAG,MAAM,CAAC,UAAU,EAAE;AAC5D,MAAM,OAAO,MAAM,CAAC,UAAU,CAAC,CAAC;AAChC,IAAI;AACJ,IAAI,OAAO,sCAAsC,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC,EAAE,GAAG;AAC1E,MAAM,MAAM,EAAE,EAAE,IAAI,CAAC,MAAM,CAAC,EAAE,EAAE,GAAG,EAAE,CAAC;AACtC,MAAM,MAAM,EAAE,EAAE,EAAE,IAAI,IAAI,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC;AACzC,MAAM,OAAO,CAAC,CAAC,QAAQ,CAAC,EAAE,CAAC;AAC3B,IAAI,CAAC,CAAC;AACN,EAAE;AACF,EAAE,OAAO,QAAQ,CAAC,MAAM,EAAE;AAC1B,IAAI,MAAM,KAAK,EAAE,IAAI,CAAC,YAAY,CAAC,CAAC;AACpC,IAAI,OAAO,OAAO,EAAE,CAAC,EAAA;AACA,EAAA;AACA;AACA;AACA;AACA;AACA,iBAAA;AACA,kBAAA;AACA,EAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,EAAA;AACA,EAAA;AACA,IAAA;AACA,IAAA;AACA,EAAA;AACA,EAAA;AACA,IAAA;AACA,IAAA;AACA,MAAA;AACA,MAAA;AACA,MAAA;AACA,IAAA;AACA,EAAA;AACA,EAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,EAAA;AACA,EAAA;AACA,IAAA;AACA,EAAA;AACA,EAAA;AACA,IAAA;AACA,EAAA;AACA;AACA;AACA;AACA;AACA,EAAA;AACA,EAAA;AACA,kBAAA;AACA,kBAAA;AACA,kBAAA;AACA,kBAAA;AACA,kBAAA;AACA,kBAAA;AACA,kBAAA;AACA,mBAAA;AACA,EAAA;AACA,IAAA;AACA,IAAA;AACA,EAAA;AACA;AACA,EAAA;AACA,IAAA;AACA,EAAA;AACA,EAAA;AACA,IAAA;AACA,EAAA;AACA;AACA,EAAA;AACA,IAAA;AACA,IAAA;AACA,MAAA;AACA,MAAA;AACA,IAAA;AACA,EAAA;AACA,EAAA;AACA,IAAA;AACA,IAAA;AACA,MAAA;AACA,MAAA;AACA,IAAA;AACA,EAAA;AACA,EAAA;AACA,IAAA;AACA,IAAA;AACA,MAAA;AACA,MAAA;AACA,IAAA;AACA,EAAA;AACA;AACA,EAAA;AACA,IAAA;AACA,EAAA;AACA,EAAA;AACA,IAAA;AACA,EAAA;AACA;AACA,EAAA;AACA,IAAA;AACA,EAAA;AACA,EAAA;AACA,IAAA;AACA,EAAA;AACA;AACA,EAAA;AACA,IAAA;AACA,IAAA;AACA,MAAA;AACA,QAAA;AACA,QAAA;AACA,UAAA;AACA,YAAA;AACA,UAAA;AACA,YAAA;AACA,UAAA;AACA,QAAA;AACA,MAAA;AACA,IAAA;AACA,IAAA;AACA,EAAA;AACA;AACA,EAAA;AACA,IAAA;AACA,IAAA;AACA,MAAA;AACA,IAAA;AACA,IAAA;AACA,EAAA;AACA;AACA,EAAA;AACA,IAAA;AACA,IAAA;AACA,MAAA;AACA,IAAA;AACA,IAAA;AACA,EAAA;AACA;AACA,EAAA;AACA,IAAA;AACA,IAAA;AACA,MAAA;AACA,QAAA;AACA,MAAA;AACA,QAAA;AACA,MAAA;AACA,IAAA;AACA,IAAA;AACA,EAAA;AACA;AACA,EAAA;AACA,IAAA;AACA,IAAA;AACA,MAAA;AACA,QAAA;AACA,UAAA;AACA,UAAA;AACA,QAAA;AACA,QAAA;AACA,UAAA;AACA,UAAA;AACA,YAAA;AACA,UAAA;AACA,UAAA;AACA,QAAA;AACA,MAAA;AACA,IAAA;AACA,IAAA;AACA,EAAA;AACA;AACA,EAAA;AACA,IAAA;AACA,IAAA;AACA,MAAA;AACA,IAAA;AACA,IAAA;AACA,MAAA;AACA,MAAA;AACA,QAAA;AACA,MAAA;AACA,MAAA;AACA,IAAA;AACA,IAAA;AACA,EAAA;AACA;AACA,EAAA;AACA,IAAA;AACA,MAAA;AACA,QAAA;AACA,MAAA;AACA,MAAA;AACA,IAAA;AACA,MAAA;AACA,QAAA;AACA,MAAA;AACA,MAAA;AACA,QAAA;AACA,MAAA;AACA,MAAA;AACA,MAAA;AACA,QAAA;AACA,QAAA;AACA,UAAA;AACA,YAAA;AACA,YAAA;AACA,cAAA;AACA,cAAA;AACA,YAAA;AACA,YAAA;AACA,UAAA;AACA,QAAA;AACA,MAAA;AACA,MAAA;AACA,IAAA;AACA,EAAA;AACA;AACA,EAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,MAAA;AACA,QAAA;AACA,wBAAA;AACA,QAAA;AACA,MAAA;AACA,MAAA;AACA,MAAA;AACA,MAAA;AACA,MAAA;AACA,MAAA;AACA,QAAA;AACA,MAAA;AACA,MAAA;AACA,QAAA;AACA,QAAA;AACA,QAAA;AACA,MAAA;AACA,MAAA;AACA,MAAA;AACA,MAAA;AACA,QAAA;AACA,QAAA;AACA,MAAA;AACA,MAAA;AACA,QAAA;AACA,MAAA;AACA,MAAA;AACA,QAAA;AACA,QAAA;AACA,MAAA;AACA,MAAA;AACA,MAAA;AACA,QAAA;AACA,UAAA;AACA,YAAA;AACA,YAAA;AACA,UAAA;AACA,UAAA;AACA,UAAA;AACA,YAAA;AACA,cAAA;AACA,gBAAA;AACA,cAAA;AACA,cAAA;AACA,gBAAA;AACA,gBAAA;AACA,gBAAA;AACA,gBAAA;AACA,gBAAA;AACA,gBAAA;AACA,gBAAA;AACA,cAAA;AACA,YAAA;AACA,YAAA;AACA,cAAA;AACA,YAAA;AACA,cAAA;AACA,gBAAA;AACA,cAAA;AACA,YAAA;AACA,UAAA;AACA,UAAA;AACA,YAAA;AACA,UAAA;AACA,UAAA;AACA,QAAA;AACA,UAAA;AACA,YAAA;AACA,cAAA;AACA,cAAA;AACA,gBAAA;AACA,gBAAA;AACA,gBAAA;AACA,gBAAA;AACA,gBAAA;AACA,gBAAA;AACA,cAAA;AACA,YAAA;AACA,YAAA;AACA,cAAA;AACA,YAAA;AACA,cAAA;AACA,gBAAA;AACA,cAAA;AACA,YAAA;AACA,UAAA;AACA,UAAA;AACA,QAAA;AACA,MAAA;AACA,MAAA;AACA,QAAA;AACA,UAAA;AACA,UAAA;AACA,UAAA;AACA,UAAA;AACA,QAAA;AACA,MAAA;AACA,MAAA;AACA,IAAA;AACA,MAAA;AACA,QAAA;AACA,QAAA;AACA,QAAA;AACA,MAAA;AACA,MAAA;AACA,QAAA;AACA,QAAA;AACA,MAAA;AACA,QAAA;AACA,UAAA;AACA,QAAA;AACA,MAAA;AACA,IAAA;AACA,MAAA;AACA,IAAA;AACA,EAAA;AACA;AACA,EAAA;AACA,IAAA;AACA,MAAA;AACA,IAAA;AACA,MAAA;AACA,IAAA;AACA,IAAA;AACA,EAAA;AACA;AACA,EAAA;AACA,IAAA;AACA,MAAA;AACA,MAAA;AACA,MAAA;AACA,MAAA;AACA,MAAA;AACA,MAAA;AACA,MAAA;AACA,MAAA;AACA,MAAA;AACA,MAAA;AACA,MAAA;AACA,MAAA;AACA,MAAA;AACA,IAAA;AACA,IAAA;AACA,EAAA;AACA;AACA,EAAA;AACA,IAAA;AACA,IAAA;AACA,MAAA;AACA,IAAA;AACA,MAAA;AACA,IAAA;AACA,MAAA;AACA,IAAA;AACA,MAAA;AACA,MAAA;AACA,QAAA;AACA,MAAA;AACA,QAAA;AACA,MAAA;AACA,IAAA;AACA,EAAA;AACA;AACA,EAAA;AACA,IAAA;AACA,MAAA;AACA,QAAA;AACA,QAAA;AACA,UAAA;AACA,UAAA;AACA,UAAA;AACA,UAAA;AACA,UAAA;AACA,UAAA;AACA,UAAA;AACA,QAAA;AACA,MAAA;AACA,IAAA;AACA,IAAA;AACA,MAAA;AACA,QAAA;AACA,QAAA;AACA,QAAA;AACA,QAAA;AACA,QAAA;AACA,QAAA;AACA,MAAA;AACA,IAAA;AACA,IAAA;AACA,MAAA;AACA,QAAA;AACA,QAAA;AACA,QAAA;AACA,QAAA;AACA,QAAA;AACA,QAAA;AACA,MAAA;AACA,IAAA;AACA,IAAA;AACA,MAAA;AACA,QAAA;AACA,QAAA;AACA,UAAA;AACA,UAAA;AACA,UAAA;AACA,UAAA;AACA,UAAA;AACA,UAAA;AACA,QAAA;AACA,MAAA;AACA,IAAA;AACA,IAAA;AACA,MAAA;AACA,MAAA;AACA,QAAA;AACA,QAAA;AACA,QAAA;AACA,QAAA;AACA,QAAA;AACA,QAAA;AACA,MAAA;AACA,IAAA;AACA,EAAA;AACA,EAAA;AACA,IAAA;AACA,EAAA;AACA,EAAA;AACA,IAAA;AACA,EAAA;AACA,EAAA;AACA,IAAA;AACA,EAAA;AACA,EAAA;AACA,IAAA;AACA,MAAA;AACA,MAAA;AACA,MAAA;AACA,IAAA;AACA,EAAA;AACA,EAAA;AACA,IAAA;AACA,EAAA;AACA,EAAA;AACA,IAAA;AACA,IAAA;AACA,MAAA;AACA,MAAA;AACA,MAAA;AACA,IAAA;AACA,EAAA;AACA;AACA;AACA;AACA;AACA;AACA,EAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA,IAAA;AACA,IAAA;AACA,MAAA;AACA,QAAA;AACA,QAAA;AACA,MAAA;AACA,IAAA;AACA,IAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA,IAAA;AACA,EAAA;AACA,EAAA;AACA,IAAA;AACA,EAAA;AACA,EAAA;AACA,IAAA;AACA,EAAA;AACA,EAAA;AACA;AACA;AACA,EAAA;AACA,IAAA;AACA,EAAA;AACA,EAAA;AACA;AACA;AACA,EAAA;AACA;AACA;AACA,EAAA;AACA;AACA;AACA;AACA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA,IAAA;AACA,IAAA;AACA,MAAA;AACA,IAAA;AACA,EAAA;AACA,EAAA;AACA,IAAA;AACA,EAAA;AACA,EAAA;AACA,IAAA;AACA,oBAAA;AACA,EAAA;AACA,EAAA;AACA,IAAA;AACA,EAAA;AACA,EAAA;AACA,IAAA;AACA,MAAA;AACA,IAAA;AACA,EAAA;AACA,EAAA;AACA,IAAA;AACA,IAAA;AACA,MAAA;AACA,MAAA;AACA,IAAA;AACA,EAAA;AACA;AACA;AACA;AACA;AACA;AACA,EAAA;AACA,IAAA;AACA,MAAA;AACA,MAAA;AACA,MAAA;AACA,MAAA;AACA,MAAA;AACA,QAAA;AACA,MAAA;AACA,MAAA;AACA,IAAA;AACA,IAAA;AACA,EAAA;AACA,EAAA;AACA,IAAA;AACA,MAAA;AACA,IAAA;AACA,IAAA;AACA,EAAA;AACA,EAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,MAAA;AACA,QAAA;AACA,MAAA;AACA,QAAA;AACA,MAAA;AACA,QAAA;AACA,MAAA;AACA,IAAA;AACA,IAAA;AACA,EAAA;AACA,EAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,EAAA;AACA;AACA;AACA;AACA;AACA;AACA,EAAA;AACA,EAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA;AACA,EAAA;AACA,IAAA;AACA,IAAA;AACA,MAAA;AACA,IAAA;AACA,EAAA;AACA,EAAA;AACA,IAAA;AACA,IAAA;AACA,MAAA;AACA,MAAA;AACA,MAAA;AACA,MAAA;AACA,MAAA;AACA,IAAA;AACA,EAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA;AACA,EAAA;AACA,IAAA;AACA,IAAA;AACA,MAAA;AACA,MAAA;AACA,MAAA;AACA,MAAA;AACA,MAAA;AACA,MAAA;AACA,MAAA;AACA,QAAA;AACA,QAAA;AACA,QAAA;AACA,MAAA;AACA,MAAA;AACA,MAAA;AACA,IAAA;AACA,EAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,EAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,EAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,MAAA;AACA,MAAA;AACA,QAAA;AACA,QAAA;AACA,QAAA;AACA,QAAA;AACA,MAAA;AACA,MAAA;AACA,IAAA;AACA,EAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,EAAA;AACA,IAAA;AACA,IAAA;AACA,MAAA;AACA,MAAA;AACA,MAAA;AACA,QAAA;AACA,MAAA;AACA,MAAA;AACA,IAAA;AACA,IAAA;AACA,MAAA;AACA,QAAA;AACA,QAAA;AACA,UAAA;AACA,UAAA;AACA,UAAA;AACA,QAAA;AACA,QAAA;AACA,MAAA;AACA,IAAA;AACA,IAAA;AACA,sBAAA;AACA,sBAAA;AACA,IAAA;AACA,EAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA;AACA,EAAA;AACA,EAAA;AACA,IAAA;AACA,IAAA;AACA,MAAA;AACA,QAAA;AACA,QAAA;AACA,QAAA;AACA,QAAA;AACA,MAAA;AACA,MAAA;AACA,wBAAA;AACA,UAAA;AACA,UAAA;AACA,YAAA;AACA,cAAA;AACA,cAAA;AACA,cAAA;AACA,cAAA;AACA,gBAAA;AACA,gBAAA;AACA,cAAA;AACA,cAAA;AACA,YAAA;AACA,YAAA;AACA,cAAA;AACA,gBAAA;AACA,gBAAA;AACA,kBAAA;AACA,oBAAA;AACA,oBAAA;AACA,oBAAA;AACA,kBAAA;AACA,gBAAA;AACA,cAAA;AACA,8BAAA;AACA,gBAAA;AACA,gBAAA;AACA,kBAAA;AACA,kBAAA;AACA,oBAAA;AACA,oBAAA;AACA,oBAAA;AACA,kBAAA;AACA,kBAAA;AACA,oBAAA;AACA,oBAAA;AACA,oBAAA;AACA,kBAAA;AACA,gBAAA;AACA,cAAA;AACA,YAAA;AACA,UAAA;AACA,QAAA;AACA,wBAAA;AACA,wBAAA;AACA,MAAA;AACA,IAAA;AACA,EAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,EAAA;AACA,EAAA;AACA,IAAA;AACA,IAAA;AACA,MAAA;AACA,MAAA;AACA,QAAA;AACA,QAAA;AACA,QAAA;AACA,QAAA;AACA,MAAA;AACA,MAAA;AACA,IAAA;AACA,EAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA;AACA,EAAA;AACA,IAAA;AACA,IAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA,IAAA;AACA,IAAA;AACA,MAAA;AACA,MAAA;AACA,QAAA;AACA,QAAA;AACA,QAAA;AACA,MAAA;AACA,MAAA;AACA,wBAAA;AACA,UAAA;AACA,UAAA;AACA,YAAA;AACA,YAAA;AACA,cAAA;AACA,cAAA;AACA,cAAA;AACA,cAAA;AACA,YAAA;AACA,YAAA;AACA,cAAA;AACA,cAAA;AACA,YAAA;AACA,UAAA;AACA,QAAA;AACA,wBAAA;AACA,UAAA;AACA,UAAA;AACA,YAAA;AACA,YAAA;AACA,YAAA;AACA,cAAA;AACA,cAAA;AACA,gBAAA;AACA,kBAAA;AACA,kBAAA;AACA,kBAAA;AACA,kBAAA;AACA,kBAAA;AACA,kBAAA;AACA,kBAAA;AACA,kBAAA;AACA,kBAAA;AACA,gBAAA;AACA,gBAAA;AACA,cAAA;AACA,YAAA;AACA,UAAA;AACA,QAAA;AACA,MAAA;AACA,IAAA;AACA,EAAA;AACA;AACA;AACA;AACA;AACA;AACA,EAAA;AACA,EAAA;AACA;AACA,EAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,EAAA;AACA,IAAA;AACA,MAAA;AACA,MAAA;AACA,IAAA;AACA,IAAA;AACA,MAAA;AACA,MAAA;AACA,IAAA;AACA,IAAA;AACA,MAAA;AACA,MAAA;AACA,IAAA;AACA,IAAA;AACA,MAAA;AACA,MAAA;AACA,IAAA;AACA,IAAA;AACA,MAAA;AACA,MAAA;AACA,IAAA;AACA,EAAA;AACA,EAAA;AACA;AACA;AACA,EAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,EAAA;AACA,IAAA;AACA,IAAA;AACA,MAAA;AACA,QAAA;AACA,QAAA;AACA,QAAA;AACA,QAAA;AACA,QAAA;AACA,MAAA;AACA,MAAA;AACA,IAAA;AACA,IAAA;AACA,MAAA;AACA,QAAA;AACA,QAAA;AACA,MAAA;AACA,MAAA;AACA,IAAA;AACA,IAAA;AACA,sBAAA;AACA,wBAAA;AACA,UAAA;AACA,UAAA;AACA,YAAA;AACA,YAAA;AACA,YAAA;AACA,YAAA;AACA,YAAA;AACA,8BAAA;AACA,gBAAA;AACA,gCAAA;AACA,cAAA;AACA,cAAA;AACA,YAAA;AACA,UAAA;AACA,QAAA;AACA,wBAAA;AACA,MAAA;AACA,sBAAA;AACA,IAAA;AACA,EAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA;AACA,EAAA;AACA,EAAA;AACA,IAAA;AACA,IAAA;AACA,EAAA;AACA,EAAA;AACA,oBAAA;AACA,MAAA;AACA,MAAA;AACA,QAAA;AACA,QAAA;AACA,QAAA;AACA,QAAA;AACA,UAAA;AACA,UAAA;AACA,YAAA;AACA,YAAA;AACA,YAAA;AACA,YAAA;AACA,UAAA;AACA,UAAA;AACA,QAAA;AACA,MAAA;AACA,IAAA;AACA,IAAA;AACA,EAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,EAAA;AACA,EAAA;AACA;AACA,EAAA;AACA,EAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,EAAA;AACA;AACA;AACA;AACA;AACA;AACA,EAAA;AACA,IAAA;AACA,EAAA;AACA;AACA;AACA;AACA;AACA,EAAA;AACA,EAAA;AACA;AACA;AACA;AACA,EAAA;AACA;AACA,EAAA;AACA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA;AACA,EAAA;AACA,IAAA;AACA;AACA,IAAA;AACA;AACA,EAAA;AACA,EAAA;AACA,IAAA;AACA;AACA,IAAA;AACA;AACA,IAAA;AACA;AACA,IAAA;AACA,EAAA;AACA;AACA;AACA;AACA;AACA;AACA,EAAA;AACA,IAAA;AACA,EAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,EAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,EAAA;AACA,EAAA;AACA,IAAA;AACA,IAAA;AACA,EAAA;AACA,EAAA;AACA,IAAA;AACA,IAAA;AACA,EAAA;AACA;AACA,EAAA;AACA,IAAA;AACA,MAAA;AACA,MAAA;AACA,MAAA;AACA,QAAA;AACA,MAAA;AACA,MAAA;AACA,QAAA;AACA,MAAA;AACA,MAAA;AACA,QAAA;AACA,MAAA;AACA,MAAA;AACA,IAAA;AACA,IAAA;AACA,EAAA;AACA,EAAA;AACA,IAAA;AACA,MAAA;AACA,QAAA;AACA,QAAA;AACA,MAAA;AACA,QAAA;AACA,QAAA;AACA,MAAA;AACA,MAAA;AACA,MAAA;AACA,IAAA;AACA,IAAA;AACA,EAAA;AACA,EAAA;AACA,IAAA;AACA,MAAA;AACA,QAAA;AACA,UAAA;AACA,UAAA;AACA,YAAA;AACA,cAAA;AACA,c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file":"D:\\Projects\\GNWebSoft.UI\\packages\\ui\\dist\\chunk-NC3JINIM.cjs","sourcesContent":[null]}