@gnwebsoft/ui 3.0.9 → 4.0.1

package/dist/chunk-L3QQX3BK.js

@@ -0,0 +1,1596 @@
+// 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 {
+  activeRequests = /* @__PURE__ */ new Map();
+  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);
+  }
+};
+
+// src/core/api/ApiClient.ts
+var ApiClient = class {
+  baseURL;
+  defaultTimeout;
+  requestInterceptors = [];
+  responseInterceptors = [];
+  errorInterceptors = [];
+  authToken = null;
+  refreshTokenPromise = null;
+  requestManager = new RequestManager();
+  correlationIdPrefix = "api";
+  includeCorrelationId = true;
+  constructor(baseURL = "", defaultTimeout = 3e4) {
+    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 (signal?.aborted) {
+        throw new Error(signal.reason || "Request aborted");
+      }
+      return await fn();
+    } catch (error) {
+      if (error.name === "AbortError" || signal?.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,
+        config.cancelToken?.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 (contentType?.includes("application/json")) {
+      return response.json();
+    } else if (contentType?.includes("text/")) {
+      return response.text();
+    } else if (contentType?.includes("application/octet-stream")) {
+      return response.blob();
+    } else {
+      const text = await response.text();
+      try {
+        return JSON.parse(text);
+      } catch {
+        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 (error.message?.includes("timeout")) {
+      return Object.assign(new Error(error.message), {
+        type: "timeout_error",
+        title: "Request Timeout",
+        status: 408,
+        traceId: correlationId,
+        isAborted: true,
+        config
+      });
+    }
+    if (error.message?.includes("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
+    });
+  }
+};
+
+// 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 {
+  abortController;
+  cancelPromise;
+  cancelResolve;
+  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);
+    this.cancelResolve?.();
+  }
+  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
+import { useCallback } from "react";
+function useValidationErrors(error) {
+  const getFieldError = useCallback(
+    (field) => {
+      if (!error?.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 = useCallback(
+    (field) => {
+      return !!getFieldError(field);
+    },
+    [getFieldError]
+  );
+  const getAllErrors = useCallback(() => {
+    if (!error?.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: error?.errors
+  };
+}
+
+// src/core/components/AuthorizedView/AuthorizedView.tsx
+import { Fragment, jsx } from "react/jsx-runtime";
+var AuthorizedView = ({ children, show }) => {
+  if (!show) return /* @__PURE__ */ jsx(Fragment, {});
+  return /* @__PURE__ */ jsx(Fragment, { children });
+};
+
+// src/core/components/CancelButton/CancelButton.tsx
+import { Button } from "@mui/material";
+import { jsx as jsx2 } from "react/jsx-runtime";
+var CancelButton = ({
+  children = "Cancel",
+  variant = "outlined",
+  sx,
+  ...rest
+}) => /* @__PURE__ */ jsx2(Button, { variant, sx: { width: "6rem", ...sx }, ...rest, children });
+
+// src/core/components/ClearButton/ClearButton.tsx
+import { Button as Button2 } from "@mui/material";
+import { jsx as jsx3 } from "react/jsx-runtime";
+var ClearButton = ({
+  isSubmitting,
+  handleClear,
+  sx,
+  storeKey
+}) => {
+  const onClick = () => {
+    handleClear();
+    if (storeKey != null) {
+      localStorage.removeItem(storeKey);
+    }
+  };
+  return /* @__PURE__ */ jsx3(
+    Button2,
+    {
+      variant: "outlined",
+      onClick,
+      disabled: isSubmitting,
+      sx,
+      children: "Clear"
+    }
+  );
+};
+
+// src/core/components/Containers/SimpleContainer.tsx
+import { Container } from "@mui/material";
+import { jsx as jsx4 } from "react/jsx-runtime";
+var SimpleContainer = ({
+  children,
+  className,
+  sx
+}) => /* @__PURE__ */ jsx4(Container, { className, sx: { ...sx }, children });
+
+// src/core/components/FilterButton/FilterButton.tsx
+import FilterAltIcon from "@mui/icons-material/FilterAlt";
+import { LoadingButton } from "@mui/lab";
+import { Badge } from "@mui/material";
+import { jsx as jsx5 } from "react/jsx-runtime";
+var FilterButton = ({
+  isSubmitting,
+  show,
+  title,
+  icon,
+  sx,
+  iconSx
+}) => {
+  return /* @__PURE__ */ jsx5(
+    LoadingButton,
+    {
+      type: "submit",
+      variant: "contained",
+      loading: isSubmitting,
+      disabled: !show,
+      disableRipple: true,
+      color: "primary",
+      sx: {
+        display: "flex",
+        alignItems: "center",
+        ...sx
+      },
+      startIcon: /* @__PURE__ */ jsx5(Badge, { color: "error", variant: "standard", children: icon ? icon : /* @__PURE__ */ jsx5(FilterAltIcon, { width: "20", height: "20", sx: iconSx }) }),
+      children: title?.trim() === "" || !title ? "Filter" : title
+    }
+  );
+};
+
+// src/core/components/FilterDisplay/FilterChip.tsx
+import Chip from "@mui/material/Chip";
+import { memo } from "react";
+import { jsx as jsx6 } from "react/jsx-runtime";
+var FilterChip = memo(
+  ({
+    fieldKey,
+    filter,
+    onDelete
+  }) => {
+    const hasValue = filter.Value !== null && filter.Value !== void 0 && filter.Value !== "";
+    const label = `${fieldKey.replace("PK", "")}: ${filter.Label}`;
+    return /* @__PURE__ */ jsx6(
+      Chip,
+      {
+        label,
+        variant: hasValue ? "filled" : "outlined",
+        size: "small",
+        onDelete: hasValue ? onDelete : void 0
+      },
+      fieldKey
+    );
+  }
+);
+FilterChip.displayName = "FilterChip";
+
+// src/core/components/FilterDisplay/FilterDisplay.tsx
+import { Card, CardContent, Typography, Box } from "@mui/material";
+import { memo as memo2, useMemo } from "react";
+import { jsx as jsx7, jsxs } from "react/jsx-runtime";
+var ProgramsFilterDisplay = memo2(
+  (props) => {
+    const { friendlyFilter, onFriendlyFilterChange } = props;
+    const deleteHandlers = useMemo(() => {
+      if (!onFriendlyFilterChange) return {};
+      const handlers = {};
+      for (const key of Object.keys(friendlyFilter)) {
+        handlers[key] = () => onFriendlyFilterChange(key);
+      }
+      return handlers;
+    }, [onFriendlyFilterChange, friendlyFilter]);
+    const chipList = useMemo(() => {
+      return Object.entries(friendlyFilter).map(([key, filter]) => /* @__PURE__ */ jsx7(
+        FilterChip,
+        {
+          fieldKey: key,
+          filter,
+          onDelete: deleteHandlers[key]
+        },
+        key
+      ));
+    }, [friendlyFilter, deleteHandlers]);
+    return /* @__PURE__ */ jsx7(Card, { sx: { mb: 2 }, children: /* @__PURE__ */ jsxs(CardContent, { children: [
+      /* @__PURE__ */ jsx7(Typography, { variant: "h6", gutterBottom: true, children: "Active Filters" }),
+      /* @__PURE__ */ jsx7(Box, { display: "flex", gap: 1, flexWrap: "wrap", children: chipList })
+    ] }) });
+  }
+);
+ProgramsFilterDisplay.displayName = "FilterDisplay";
+
+// src/core/components/FilterWrapper/FilterWrapper.tsx
+import ManageSearchIcon from "@mui/icons-material/ManageSearch";
+import {
+  Box as Box2,
+  Card as Card2,
+  CardContent as CardContent2,
+  CardHeader,
+  Divider,
+  Grid,
+  Typography as Typography2,
+  useTheme
+} from "@mui/material";
+import { Fragment as Fragment2, jsx as jsx8, jsxs as jsxs2 } from "react/jsx-runtime";
+var FilterWrapper = ({
+  children,
+  title,
+  filterCount,
+  cardSx,
+  textSx,
+  icon,
+  iconSx,
+  showCount
+}) => {
+  const theme = useTheme();
+  return /* @__PURE__ */ jsxs2(
+    Card2,
+    {
+      sx: {
+        position: "relative",
+        borderRadius: "0px",
+        mb: 2,
+        ...cardSx
+      },
+      children: [
+        /* @__PURE__ */ jsx8(
+          CardHeader,
+          {
+            sx: {
+              display: "flex",
+              flexWrap: "wrap",
+              p: "1rem",
+              ".MuiCardHeader-action": {
+                margin: 0,
+                alignSelf: "center"
+              },
+              alignItems: "center"
+            },
+            title: /* @__PURE__ */ jsxs2(Box2, { sx: { display: "flex", alignItems: "center", gap: 0.5 }, children: [
+              icon ? icon : /* @__PURE__ */ jsx8(
+                ManageSearchIcon,
+                {
+                  sx: {
+                    height: "2.5rem",
+                    color: theme.palette.primary.main,
+                    ...iconSx
+                  }
+                }
+              ),
+              /* @__PURE__ */ jsxs2(
+                Typography2,
+                {
+                  variant: "h5",
+                  sx: {
+                    fontWeight: "bold",
+                    color: theme.palette.primary.main,
+                    ...textSx
+                  },
+                  children: [
+                    title ? title : "Filter",
+                    " ",
+                    showCount ? `(${filterCount ? filterCount : 0})` : /* @__PURE__ */ jsx8(Fragment2, {})
+                  ]
+                }
+              )
+            ] })
+          }
+        ),
+        /* @__PURE__ */ jsx8(Divider, {}),
+        /* @__PURE__ */ jsx8(CardContent2, { sx: { py: 2 }, children: /* @__PURE__ */ jsx8(Grid, { container: true, spacing: 2, children }) })
+      ]
+    }
+  );
+};
+
+// src/core/components/Footer/Footer.tsx
+import { Box as Box3, Typography as Typography3 } from "@mui/material";
+import { jsx as jsx9 } from "react/jsx-runtime";
+var Footer = () => {
+  const currentYear = (/* @__PURE__ */ new Date()).getFullYear();
+  return /* @__PURE__ */ jsx9(
+    Box3,
+    {
+      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__ */ jsx9(Typography3, { variant: "body2", color: "text.secondary", align: "center", children: `\xA9 Copyright ${currentYear} GN. All rights reserved by Parul University.` })
+    }
+  );
+};
+
+// src/core/components/LabelText/LabelText.tsx
+import { Grid as Grid2, Tooltip, Typography as Typography4 } from "@mui/material";
+import { jsx as jsx10, jsxs as jsxs3 } from "react/jsx-runtime";
+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__ */ jsxs3(
+    Grid2,
+    {
+      size: container,
+      sx: {
+        display: "flex",
+        flexDirection: { xs: "column", sm: "row", md: "row" },
+        "&:hover": { bgcolor: "#efefef", overflow: "hidden" }
+      },
+      children: [
+        /* @__PURE__ */ jsxs3(
+          Grid2,
+          {
+            size: size.labelSize,
+            sx: {
+              padding: "5px",
+              fontSize: "14px",
+              textAlign: { xs: "left", sm: "right", md: "right" },
+              ...labelSx
+            },
+            children: [
+              label,
+              " :"
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsx10(
+          Grid2,
+          {
+            size: size.valueSize,
+            sx: { padding: "5px", display: "flex", flexWrap: "wrap" },
+            children: /* @__PURE__ */ jsx10(Tooltip, { title: value, arrow: true, children: /* @__PURE__ */ jsx10(
+              Typography4,
+              {
+                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
+import { Fragment as Fragment3, jsx as jsx11 } from "react/jsx-runtime";
+var RenderIf = ({
+  show,
+  children
+}) => {
+  return show ? /* @__PURE__ */ jsx11(Fragment3, { children }) : null;
+};
+
+// src/core/components/SectionBox/SectionBox.tsx
+import { Box as Box4, Divider as Divider2, Grid as Grid3, Stack, Typography as Typography5 } from "@mui/material";
+import { memo as memo3, useMemo as useMemo2 } from "react";
+import { Fragment as Fragment4, jsx as jsx12, jsxs as jsxs4 } from "react/jsx-runtime";
+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 = memo3(
+  ({
+    title,
+    children,
+    spacing = 0,
+    containerSx,
+    titleSx,
+    variant = "default",
+    icon,
+    actions
+  }) => {
+    const themeColors = useMemo2(() => getSectionTheme(variant), [variant]);
+    const headerSx = useMemo2(
+      () => ({
+        px: 1.5,
+        py: 0.1,
+        width: "fit-content",
+        ...themeColors,
+        ...titleSx
+      }),
+      [themeColors, titleSx]
+    );
+    const contentSx = useMemo2(
+      () => ({
+        padding: "16px",
+        ...containerSx
+      }),
+      [containerSx]
+    );
+    return /* @__PURE__ */ jsxs4(Fragment4, { children: [
+      /* @__PURE__ */ jsxs4(Box4, { sx: { display: "flex", flexDirection: "column", width: "100%" }, children: [
+        /* @__PURE__ */ jsxs4(
+          Stack,
+          {
+            direction: "row",
+            justifyContent: "space-between",
+            alignItems: "center",
+            sx: headerSx,
+            children: [
+              /* @__PURE__ */ jsxs4(Stack, { direction: "row", alignItems: "center", spacing: 1, children: [
+                icon,
+                /* @__PURE__ */ jsx12(Typography5, { sx: { fontSize: "15px", fontWeight: 400 }, children: title })
+              ] }),
+              actions
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsx12(Divider2, {})
+      ] }),
+      /* @__PURE__ */ jsx12(Grid3, { container: true, spacing, sx: contentSx, children })
+    ] });
+  }
+);
+
+// src/core/components/SimpleTabs/SimpleTabs.tsx
+import { TabContext } from "@mui/lab";
+import { Box as Box5, Tab, Tabs } from "@mui/material";
+import { useState } from "react";
+import { jsx as jsx13, jsxs as jsxs5 } from "react/jsx-runtime";
+var SimpleTabs = ({
+  tabs,
+  defaultValue = 1,
+  onTabChange,
+  children,
+  tabSx,
+  tabsSx
+}) => {
+  const [value, setValue] = useState(defaultValue);
+  const handleChange = (event, newValue) => {
+    setValue(newValue);
+    if (onTabChange) onTabChange(newValue);
+  };
+  return /* @__PURE__ */ jsxs5(TabContext, { value, children: [
+    /* @__PURE__ */ jsx13(Box5, { sx: { borderBottom: 1, borderColor: "divider", width: "100%" }, children: /* @__PURE__ */ jsx13(
+      Tabs,
+      {
+        value,
+        onChange: handleChange,
+        sx: { px: 2, py: 0, ...tabsSx },
+        children: tabs.map((tab) => /* @__PURE__ */ jsx13(
+          Tab,
+          {
+            label: tab.label,
+            value: tab.value,
+            disabled: tab.permission === false,
+            sx: { fontSize: "1rem", ...tabSx }
+          },
+          tab.value
+        ))
+      }
+    ) }),
+    children
+  ] });
+};
+
+// src/core/components/SubmitButton/SubmitButton.tsx
+import { LoadingButton as LoadingButton2 } from "@mui/lab";
+import { jsx as jsx14 } from "react/jsx-runtime";
+var SubmitButton = ({
+  loading = false,
+  ...rest
+}) => /* @__PURE__ */ jsx14(
+  LoadingButton2,
+  {
+    loading,
+    variant: "contained",
+    color: "primary",
+    type: "submit",
+    ...rest,
+    sx: { fontWeight: 400 },
+    children: "Submit"
+  }
+);
+
+// src/core/components/WithRef/WithRef.tsx
+import { forwardRef } from "react";
+function withDataModal(component) {
+  return forwardRef(
+    (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
+import { useMemo as useMemo3 } from "react";
+function useApiClient(config = {}) {
+  return useMemo3(() => {
+    return createApiClient(config);
+  }, [
+    config.baseURL,
+    config.timeout,
+    config.correlationIdPrefix,
+    config.includeCorrelationId,
+    config.authToken,
+    config.requestInterceptors,
+    config.responseInterceptors,
+    config.errorInterceptors
+  ]);
+}
+
+// src/core/hooks/useFormErrorHandler.ts
+import { useCallback as useCallback2 } from "react";
+import { toast } from "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 = useCallback2(
+    (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 = useCallback2(
+    (isEditing, rowsAffected) => {
+      if (rowsAffected !== void 0 && rowsAffected > 0) {
+        toast.success(isEditing ? successMessage.update : successMessage.create);
+        return true;
+      } else if (rowsAffected === 0) {
+        toast.error(errorMessage.noChanges);
+        return false;
+      }
+      toast.success(isEditing ? successMessage.update : successMessage.create);
+      return true;
+    },
+    [successMessage, errorMessage]
+  );
+  const handleError = useCallback2(
+    (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
+            });
+          }
+        });
+        toast.error(processedError.title || "Please check the form for validation errors");
+      } else {
+        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
+import { useQueryClient } from "@tanstack/react-query";
+import { useMemo as useMemo4 } from "react";
+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 = useQueryClient();
+  return useMemo4(() => new CacheUtility(queryClient), [queryClient]);
+}
+
+// src/core/utils/watch/core.ts
+import { useWatch } from "react-hook-form";
+var useWatchForm = (control) => useWatch({ control });
+var useWatchField = (control, name) => useWatch({ control, name });
+var useWatchFields = (control, names) => useWatch({ control, name: names });
+
+// src/core/utils/watch/utilities.ts
+import { useEffect, useMemo as useMemo5, useState as useState2 } from "react";
+import { useWatch as useWatch2 } from "react-hook-form";
+var useWatchTransform = (control, name, transform) => {
+  const value = useWatch2({ control, name });
+  return useMemo5(() => transform(value), [value, transform]);
+};
+var useWatchDefault = (control, name, defaultValue) => {
+  const value = useWatch2({ control, name });
+  return value ?? defaultValue;
+};
+var useWatchBoolean = (control, name, defaultValue = false) => {
+  const value = useWatch2({ control, name });
+  return Boolean(value ?? defaultValue);
+};
+var useWatchBatch = (control, fields) => {
+  const values = useWatch2({ control, name: fields });
+  return useMemo5(() => {
+    const result = {};
+    fields.forEach((field, index) => {
+      result[field] = values[index];
+    });
+    return result;
+  }, [values, fields]);
+};
+var useWatchConditional = (control, name, shouldWatch, fallback) => {
+  const activeValue = useWatch2({
+    control,
+    name,
+    disabled: !shouldWatch
+  });
+  return shouldWatch ? activeValue : fallback;
+};
+var useWatchDebounced = (control, name, delay = 300) => {
+  const value = useWatch2({ control, name });
+  const [debouncedValue, setDebouncedValue] = useState2(value);
+  useEffect(() => {
+    const timer = setTimeout(() => {
+      setDebouncedValue(value);
+    }, delay);
+    return () => clearTimeout(timer);
+  }, [value, delay]);
+  return debouncedValue;
+};
+var useWatchSelector = (control, name, selector, deps = []) => {
+  const value = useWatch2({ control, name });
+  return useMemo5(
+    () => 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
+import dayjs from "dayjs";
+import duration from "dayjs/plugin/duration";
+import relativeTime from "dayjs/plugin/relativeTime";
+dayjs.extend(duration);
+dayjs.extend(relativeTime);
+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 && dayjs(date).isValid();
+function today(template) {
+  return dayjs(/* @__PURE__ */ new Date()).startOf("day").format(template);
+}
+function fDateTime(date, template) {
+  if (!isValidDate(date)) {
+    return "Invalid date";
+  }
+  return dayjs(date).format(template ?? formatPatterns.dateTime);
+}
+function fDate(date, template) {
+  if (!isValidDate(date)) {
+    return "Invalid date";
+  }
+  return dayjs(date).format(template ?? formatPatterns.date);
+}
+function fTime(date, template) {
+  if (!isValidDate(date)) {
+    return "Invalid date";
+  }
+  return dayjs(date).format(template ?? formatPatterns.time);
+}
+function fTimestamp(date) {
+  if (!isValidDate(date)) {
+    return "Invalid date";
+  }
+  return dayjs(date).valueOf();
+}
+function fToNow(date) {
+  if (!isValidDate(date)) {
+    return "Invalid date";
+  }
+  return dayjs(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 dayjs(startDate).isAfter(endDate);
+}
+function fIsSame(startDate, endDate, unitToCompare) {
+  if (!isValidDate(startDate) || !isValidDate(endDate)) {
+    return false;
+  }
+  return dayjs(startDate).isSame(endDate, 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 = dayjs().add(
+    dayjs.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 = dayjs().subtract(
+    dayjs.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
+import { useRef, useMemo as useMemo6 } from "react";
+function useStableRowCount(currentTotal) {
+  const rowCountRef = useRef(currentTotal || 0);
+  const stableRowCount = useMemo6(() => {
+    if (currentTotal !== void 0) {
+      rowCountRef.current = currentTotal;
+    }
+    return rowCountRef.current;
+  }, [currentTotal]);
+  return stableRowCount;
+}
+
+export {
+  CorrelationIdGenerator,
+  RequestManager,
+  ApiClient,
+  createApiClient,
+  getGlobalApiClient,
+  setGlobalApiClient,
+  resetGlobalApiClient,
+  CancelToken,
+  useValidationErrors,
+  AuthorizedView,
+  CancelButton,
+  ClearButton,
+  SimpleContainer,
+  FilterButton,
+  FilterChip,
+  ProgramsFilterDisplay,
+  FilterWrapper,
+  Footer,
+  LabelText,
+  RenderIf,
+  SectionBox,
+  SimpleTabs,
+  SubmitButton,
+  withDataModal,
+  Config,
+  dateTimePatterns,
+  useApiClient,
+  useFormErrorHandler,
+  useDeleteHandler,
+  CacheUtility,
+  useCacheUtility,
+  useWatchForm,
+  useWatchField,
+  useWatchFields,
+  useWatchTransform,
+  useWatchDefault,
+  useWatchBoolean,
+  useWatchBatch,
+  useWatchConditional,
+  useWatchDebounced,
+  useWatchSelector,
+  typedWatch,
+  calculateFilterCount,
+  formatPatterns,
+  today,
+  fDateTime,
+  fDate,
+  fTime,
+  fTimestamp,
+  fToNow,
+  fIsBetween,
+  fIsAfter,
+  fIsSame,
+  fDateRangeShortLabel,
+  fAdd,
+  fSub,
+  getEmptyObject,
+  useStableRowCount
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/core/api/CorrelationIdGenerator.ts", "../src/core/api/RequestManager.ts", "../src/core/api/ApiClient.ts", "../src/core/api/createApiClient.ts", "../src/core/api/types/CancelToken.ts", "../src/core/api/useValidationErrors.ts", "../src/core/components/AuthorizedView/AuthorizedView.tsx", "../src/core/components/CancelButton/CancelButton.tsx", "../src/core/components/ClearButton/ClearButton.tsx", "../src/core/components/Containers/SimpleContainer.tsx", "../src/core/components/FilterButton/FilterButton.tsx", "../src/core/components/FilterDisplay/FilterChip.tsx", "../src/core/components/FilterDisplay/FilterDisplay.tsx", "../src/core/components/FilterWrapper/FilterWrapper.tsx", "../src/core/components/Footer/Footer.tsx", "../src/core/components/LabelText/LabelText.tsx", "../src/core/components/RenderIf/RenderIf.tsx", "../src/core/components/SectionBox/SectionBox.tsx", "../src/core/components/SimpleTabs/SimpleTabs.tsx", "../src/core/components/SubmitButton/SubmitButton.tsx", "../src/core/components/WithRef/WithRef.tsx", "../src/core/config.ts", "../src/core/hooks/useApiClient.ts", "../src/core/hooks/useFormErrorHandler.ts", "../src/core/utils/CacheUtility/index.ts", "../src/core/utils/watch/core.ts", "../src/core/utils/watch/utilities.ts", "../src/core/utils/watch/index.ts", "../src/core/utils/calculateFilterCount.ts", "../src/core/utils/format-time.ts", "../src/core/utils/getEmptyObject.ts", "../src/core/utils/useStableRowCount.ts"],
  "sourcesContent": ["// Correlation ID generator\r\nexport class CorrelationIdGenerator {\r\n  private static generateUUID(): string {\r\n    if (typeof crypto !== 'undefined' && crypto.randomUUID) {\r\n      return crypto.randomUUID();\r\n    }\r\n\r\n    // Fallback UUID v4 generator\r\n    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, c => {\r\n      const r = (Math.random() * 16) | 0;\r\n      const v = c === 'x' ? r : (r & 0x3) | 0x8;\r\n\r\n      return v.toString(16);\r\n    });\r\n  }\r\n\r\n  static generate(prefix?: string): string {\r\n    const uuid = this.generateUUID();\r\n\r\n    return prefix ? `${prefix}-${uuid}` : uuid;\r\n  }\r\n}\r\n", "// Request manager for tracking active requests\r\nexport class RequestManager {\r\n  private activeRequests: Map<string, AbortController> = new Map();\r\n  private correlationMap: Map<string, string> = new Map();\r\n\r\n  add(key: string, controller: AbortController, correlationId: string): void {\r\n    // Cancel existing request with same key if exists\r\n    this.cancel(key);\r\n    this.activeRequests.set(key, controller);\r\n    this.correlationMap.set(key, correlationId);\r\n  }\r\n\r\n  remove(key: string): void {\r\n    this.activeRequests.delete(key);\r\n    this.correlationMap.delete(key);\r\n  }\r\n\r\n  cancel(key: string): void {\r\n    const controller = this.activeRequests.get(key);\r\n\r\n    if (controller) {\r\n      controller.abort();\r\n      this.activeRequests.delete(key);\r\n      this.correlationMap.delete(key);\r\n    }\r\n  }\r\n\r\n  cancelAll(): void {\r\n    this.activeRequests.forEach(controller => controller.abort());\r\n    this.activeRequests.clear();\r\n    this.correlationMap.clear();\r\n  }\r\n\r\n  has(key: string): boolean {\r\n    return this.activeRequests.has(key);\r\n  }\r\n\r\n  getCorrelationId(key: string): string | undefined {\r\n    return this.correlationMap.get(key);\r\n  }\r\n}\r\n", "import type { GridSortModel } from '@mui/x-data-grid';\r\n\r\nimport { CorrelationIdGenerator } from './CorrelationIdGenerator';\r\nimport { RequestManager } from './RequestManager';\r\nimport type { ApiError } from './types/ApiError';\r\nimport type { ErrorInterceptor } from './types/ErrorInterceptor';\r\nimport type { RequestConfig } from './types/RequestConfig';\r\nimport type { RequestInterceptor } from './types/RequestInterceptor';\r\nimport type { ResponseInterceptor } from './types/ResponseInterceptor';\r\n\r\nimport type { ApiResponse } from '@/types';\r\n\r\nexport interface PostModel<TFilterModel> {\r\n  filterModel?: TFilterModel;\r\n  pageOffset: number;\r\n  pageSize: number;\r\n  sortField: string | null;\r\n  sortOrder: 'asc' | 'desc' | null | undefined;\r\n  sortModel?: GridSortModel;\r\n}\r\n\r\nexport interface ListResponse2<TListModel> {\r\n  Data: TListModel[];\r\n  Total: number;\r\n}\r\n\r\n// apiClient.ts\r\nexport class ApiClient {\r\n  private baseURL: string;\r\n  private defaultTimeout: number;\r\n  private requestInterceptors: RequestInterceptor[] = [];\r\n  private responseInterceptors: ResponseInterceptor[] = [];\r\n  private errorInterceptors: ErrorInterceptor[] = [];\r\n  private authToken: string | null = null;\r\n  private refreshTokenPromise: Promise<string> | null = null;\r\n  private requestManager: RequestManager = new RequestManager();\r\n  private correlationIdPrefix: string = 'api';\r\n  private includeCorrelationId: boolean = true;\r\n\r\n  constructor(baseURL: string = '', defaultTimeout: number = 30000) {\r\n    this.baseURL = baseURL;\r\n    this.defaultTimeout = defaultTimeout;\r\n  }\r\n\r\n  // Configuration methods\r\n  setCorrelationIdPrefix(prefix: string): void {\r\n    this.correlationIdPrefix = prefix;\r\n  }\r\n\r\n  setIncludeCorrelationId(include: boolean): void {\r\n    this.includeCorrelationId = include;\r\n  }\r\n\r\n  // Interceptor management\r\n  addRequestInterceptor(interceptor: RequestInterceptor): () => void {\r\n    this.requestInterceptors.push(interceptor);\r\n\r\n    return () => {\r\n      const index = this.requestInterceptors.indexOf(interceptor);\r\n\r\n      if (index > -1) this.requestInterceptors.splice(index, 1);\r\n    };\r\n  }\r\n\r\n  addResponseInterceptor(interceptor: ResponseInterceptor): () => void {\r\n    this.responseInterceptors.push(interceptor);\r\n\r\n    return () => {\r\n      const index = this.responseInterceptors.indexOf(interceptor);\r\n\r\n      if (index > -1) this.responseInterceptors.splice(index, 1);\r\n    };\r\n  }\r\n\r\n  addErrorInterceptor(interceptor: ErrorInterceptor): () => void {\r\n    this.errorInterceptors.push(interceptor);\r\n\r\n    return () => {\r\n      const index = this.errorInterceptors.indexOf(interceptor);\r\n\r\n      if (index > -1) this.errorInterceptors.splice(index, 1);\r\n    };\r\n  }\r\n\r\n  // Auth token management\r\n  setAuthToken(token: string | null): void {\r\n    this.authToken = token;\r\n  }\r\n\r\n  getAuthToken(): string | null {\r\n    return this.authToken;\r\n  }\r\n\r\n  // Request cancellation\r\n  cancelRequest(key: string): void {\r\n    this.requestManager.cancel(key);\r\n  }\r\n\r\n  cancelAllRequests(): void {\r\n    this.requestManager.cancelAll();\r\n  }\r\n\r\n  // URL and params handling\r\n  private buildURL(endpoint: string, params?: Record<string, any>): string {\r\n    const url = new URL(endpoint, this.baseURL);\r\n\r\n    if (params) {\r\n      Object.keys(params).forEach(key => {\r\n        const value = params[key];\r\n\r\n        if (value !== undefined && value !== null) {\r\n          if (Array.isArray(value)) {\r\n            value.forEach(v => url.searchParams.append(key, String(v)));\r\n          } else {\r\n            url.searchParams.append(key, String(value));\r\n          }\r\n        }\r\n      });\r\n    }\r\n\r\n    return url.toString();\r\n  }\r\n\r\n  // Apply request interceptors\r\n  private async applyRequestInterceptors(\r\n    config: RequestConfig\r\n  ): Promise<RequestConfig> {\r\n    let modifiedConfig = { ...config };\r\n\r\n    for (const interceptor of this.requestInterceptors) {\r\n      modifiedConfig = await interceptor(modifiedConfig);\r\n    }\r\n\r\n    return modifiedConfig;\r\n  }\r\n\r\n  // Apply response interceptors\r\n  private async applyResponseInterceptors<T>(\r\n    response: ApiResponse<T>\r\n  ): Promise<ApiResponse<T>> {\r\n    let modifiedResponse = response;\r\n\r\n    for (const interceptor of this.responseInterceptors) {\r\n      modifiedResponse = await interceptor(modifiedResponse);\r\n    }\r\n\r\n    return modifiedResponse;\r\n  }\r\n\r\n  // Apply error interceptors\r\n  private async applyErrorInterceptors(error: ApiError): Promise<ApiError> {\r\n    let modifiedError = error;\r\n\r\n    for (const interceptor of this.errorInterceptors) {\r\n      try {\r\n        modifiedError = await interceptor(modifiedError);\r\n      } catch (e) {\r\n        modifiedError = e as ApiError;\r\n      }\r\n    }\r\n\r\n    throw modifiedError;\r\n  }\r\n\r\n  // Create combined abort signal\r\n  private createCombinedSignal(\r\n    signals: Array<AbortSignal | undefined>\r\n  ): AbortController {\r\n    const controller = new AbortController();\r\n\r\n    for (const signal of signals) {\r\n      if (signal) {\r\n        if (signal.aborted) {\r\n          controller.abort(signal.reason);\r\n          break;\r\n        }\r\n\r\n        signal.addEventListener(\r\n          'abort',\r\n          () => {\r\n            controller.abort(signal.reason);\r\n          },\r\n          { once: true }\r\n        );\r\n      }\r\n    }\r\n\r\n    return controller;\r\n  }\r\n\r\n  // Timeout handling with AbortSignal\r\n  private createTimeoutSignal(timeout: number): AbortController {\r\n    const controller = new AbortController();\r\n\r\n    const timeoutId = setTimeout(() => {\r\n      controller.abort(`Request timeout after ${timeout}ms`);\r\n    }, timeout);\r\n\r\n    // Clean up timeout when signal is aborted\r\n    controller.signal.addEventListener(\r\n      'abort',\r\n      () => {\r\n        clearTimeout(timeoutId);\r\n      },\r\n      { once: true }\r\n    );\r\n\r\n    return controller;\r\n  }\r\n\r\n  // Retry logic with abort support\r\n  private async retryRequest<T>(\r\n    fn: () => Promise<T>,\r\n    retries: number,\r\n    delay: number,\r\n    signal?: AbortSignal\r\n  ): Promise<T> {\r\n    try {\r\n      // Check if already aborted\r\n      if (signal?.aborted) {\r\n        throw new Error(signal.reason || 'Request aborted');\r\n      }\r\n\r\n      return await fn();\r\n    } catch (error: any) {\r\n      // Don't retry if aborted\r\n      if (error.name === 'AbortError' || signal?.aborted) {\r\n        throw error;\r\n      }\r\n\r\n      // Don't retry validation errors\r\n      if (error.type === 'validation_error' || error.status === 400) {\r\n        throw error;\r\n      }\r\n\r\n      if (retries === 0) throw error;\r\n\r\n      // Wait with abort support\r\n      await new Promise((resolve, reject) => {\r\n        const timeoutId = setTimeout(resolve, delay);\r\n\r\n        if (signal) {\r\n          signal.addEventListener(\r\n            'abort',\r\n            () => {\r\n              clearTimeout(timeoutId);\r\n              reject(new Error(signal.reason || 'Request aborted'));\r\n            },\r\n            { once: true }\r\n          );\r\n        }\r\n      });\r\n\r\n      return this.retryRequest(fn, retries - 1, delay * 2, signal);\r\n    }\r\n  }\r\n\r\n  // Overloaded request method signatures\r\n  async request<T = any>(\r\n    endpoint: string,\r\n    config: RequestConfig & { throwErrors: false }\r\n  ): Promise<ApiResponse<T, ApiError>>;\r\n  async request<T = any>(\r\n    endpoint: string,\r\n    config?: RequestConfig & { throwErrors?: true }\r\n  ): Promise<ApiResponse<T, ApiError>>;\r\n  async request<T = any>(\r\n    endpoint: string,\r\n    config?: RequestConfig\r\n  ): Promise<ApiResponse<T, ApiError>>;\r\n\r\n  // Main request method implementation\r\n  async request<T = any>(\r\n    endpoint: string,\r\n    config: RequestConfig = {}\r\n  ): Promise<ApiResponse<T, ApiError>> {\r\n    // Generate correlation ID\r\n    const correlationId =\r\n      config.correlationId ||\r\n      (!config.skipCorrelationId && this.includeCorrelationId\r\n        ? CorrelationIdGenerator.generate(this.correlationIdPrefix)\r\n        : undefined);\r\n\r\n    // Generate request key for tracking\r\n    const requestKey = `${config.method || 'GET'}_${endpoint}_${Date.now()}`;\r\n\r\n    // Create master controller for this request\r\n    const masterController = new AbortController();\r\n\r\n    try {\r\n      // Combine all abort signals\r\n      const signals: Array<AbortSignal | undefined> = [\r\n        config.signal,\r\n        config.cancelToken?.signal,\r\n        masterController.signal,\r\n      ];\r\n\r\n      // Add timeout signal if configured\r\n      const timeout = config.timeout || this.defaultTimeout;\r\n      const timeoutController = this.createTimeoutSignal(timeout);\r\n\r\n      signals.push(timeoutController.signal);\r\n\r\n      // Create combined signal\r\n      const combinedController = this.createCombinedSignal(signals);\r\n\r\n      // Track this request\r\n      if (correlationId) {\r\n        this.requestManager.add(requestKey, masterController, correlationId);\r\n      }\r\n\r\n      // Apply request interceptors\r\n      const finalConfig = await this.applyRequestInterceptors({\r\n        ...config,\r\n        signal: combinedController.signal,\r\n        correlationId,\r\n      });\r\n\r\n      // Build full URL\r\n      const url = this.buildURL(endpoint, finalConfig.params);\r\n\r\n      // Add default headers\r\n      const headers = new Headers(finalConfig.headers);\r\n\r\n      // Add correlation ID header\r\n      if (correlationId) {\r\n        headers.set('X-Correlation-Id', correlationId);\r\n        headers.set('X-Request-Id', correlationId);\r\n      }\r\n\r\n      // Add auth header if token exists\r\n      if (this.authToken && !finalConfig.skipAuthRefresh) {\r\n        headers.set('Authorization', `Bearer ${this.authToken}`);\r\n      }\r\n\r\n      // Set content-type for JSON payloads\r\n      if (\r\n        finalConfig.body &&\r\n        typeof finalConfig.body === 'object' &&\r\n        !(finalConfig.body instanceof FormData)\r\n      ) {\r\n        headers.set('Content-Type', 'application/json');\r\n        finalConfig.body = JSON.stringify(finalConfig.body);\r\n      }\r\n\r\n      finalConfig.headers = headers;\r\n\r\n      // Create fetch promise\r\n      const fetchPromise = async () => {\r\n        try {\r\n          const response = await fetch(url, {\r\n            ...finalConfig,\r\n            signal: combinedController.signal,\r\n          });\r\n\r\n          // Parse response data\r\n          const responseData = await this.parseResponseData(response);\r\n\r\n          // Handle error responses\r\n          if (!response.ok) {\r\n            const error: ApiError = Object.assign(\r\n              new Error(\r\n                responseData.title ||\r\n                  `HTTP ${response.status}: ${response.statusText}`\r\n              ),\r\n              {\r\n                type: responseData.type || this.getErrorType(response.status),\r\n                title:\r\n                  responseData.title || this.getErrorTitle(response.status),\r\n                status: response.status,\r\n                traceId: responseData.traceId || correlationId,\r\n                errors: responseData.errors,\r\n                isAborted: false,\r\n                config: finalConfig,\r\n              }\r\n            );\r\n\r\n            // Check if we should throw or return error in response\r\n            if (finalConfig.throwErrors !== false) {\r\n              throw error;\r\n            } else {\r\n              // Return error in ApiResponse.error field\r\n              return await this.applyResponseInterceptors({\r\n                error,\r\n              } as ApiResponse<T, ApiError>);\r\n            }\r\n          }\r\n\r\n          // Format successful response\r\n          const apiResponse: ApiResponse<T> = {\r\n            data: responseData as T,\r\n          };\r\n\r\n          // Apply response interceptors\r\n          return await this.applyResponseInterceptors(apiResponse);\r\n        } catch (error: any) {\r\n          // Handle abort errors\r\n          if (error.name === 'AbortError') {\r\n            const abortError = Object.assign(\r\n              new Error(error.message || 'Request aborted'),\r\n              {\r\n                type: 'request_cancelled',\r\n                title: 'Request was cancelled',\r\n                status: 0,\r\n                traceId: correlationId,\r\n                isAborted: true,\r\n                config: finalConfig,\r\n              }\r\n            );\r\n\r\n            // Check if we should throw or return error in response\r\n            if (finalConfig.throwErrors !== false) {\r\n              throw abortError;\r\n            } else {\r\n              // Return error in ApiResponse.error field\r\n              return await this.applyResponseInterceptors({\r\n                error: abortError,\r\n              } as ApiResponse<T, ApiError>);\r\n            }\r\n          }\r\n\r\n          throw error;\r\n        }\r\n      };\r\n\r\n      // Handle retries if configured\r\n      if (finalConfig.retries && finalConfig.retries > 0) {\r\n        return await this.retryRequest(\r\n          fetchPromise,\r\n          finalConfig.retries,\r\n          finalConfig.retryDelay || 1000,\r\n          combinedController.signal\r\n        );\r\n      }\r\n\r\n      return await fetchPromise();\r\n    } catch (error) {\r\n      // Handle errors\r\n      const apiError: ApiError = this.normalizeError(\r\n        error,\r\n        config,\r\n        correlationId\r\n      );\r\n\r\n      // Check if we should throw or return error in response\r\n      if (config.throwErrors !== false) {\r\n        await this.applyErrorInterceptors(apiError);\r\n        // This line will never be reached as applyErrorInterceptors always throws,\r\n        // but TypeScript requires a return statement\r\n        throw apiError;\r\n      } else {\r\n        // Return error in ApiResponse.error field\r\n        return {\r\n          error: apiError,\r\n        } as ApiResponse<T, ApiError>;\r\n      }\r\n    } finally {\r\n      // Clean up request tracking\r\n      this.requestManager.remove(requestKey);\r\n    }\r\n  }\r\n\r\n  // Get error type based on status code\r\n  private getErrorType(status: number): string {\r\n    if (status >= 400 && status < 500) {\r\n      return status === 400 ? 'validation_error' : 'client_error';\r\n    } else if (status >= 500) {\r\n      return 'server_error';\r\n    }\r\n\r\n    return 'unknown_error';\r\n  }\r\n\r\n  // Get error title based on status code\r\n  private getErrorTitle(status: number): string {\r\n    const titles: Record<number, string> = {\r\n      400: 'Bad Request',\r\n      401: 'Unauthorized',\r\n      403: 'Forbidden',\r\n      404: 'Not Found',\r\n      405: 'Method Not Allowed',\r\n      408: 'Request Timeout',\r\n      409: 'Conflict',\r\n      422: 'Unprocessable Entity',\r\n      429: 'Too Many Requests',\r\n      500: 'Internal Server Error',\r\n      502: 'Bad Gateway',\r\n      503: 'Service Unavailable',\r\n      504: 'Gateway Timeout',\r\n    };\r\n\r\n    return titles[status] || `HTTP Error ${status}`;\r\n  }\r\n\r\n  // Parse response data based on content type\r\n  private async parseResponseData(response: Response): Promise<any> {\r\n    const contentType = response.headers.get('content-type');\r\n\r\n    if (contentType?.includes('application/json')) {\r\n      return response.json();\r\n    } else if (contentType?.includes('text/')) {\r\n      return response.text();\r\n    } else if (contentType?.includes('application/octet-stream')) {\r\n      return response.blob();\r\n    } else {\r\n      // Try JSON first, fallback to text\r\n      const text = await response.text();\r\n\r\n      try {\r\n        return JSON.parse(text);\r\n      } catch {\r\n        return text;\r\n      }\r\n    }\r\n  }\r\n\r\n  // Normalize errors\r\n  private normalizeError(\r\n    error: any,\r\n    config: RequestConfig,\r\n    correlationId?: string\r\n  ): ApiError {\r\n    // If error already has ApiError structure, enhance it\r\n    if (error.type || error.title || error.errors) {\r\n      return Object.assign(\r\n        error instanceof Error\r\n          ? error\r\n          : new Error(error.message || 'Unknown error'),\r\n        {\r\n          type: error.type,\r\n          title: error.title,\r\n          status: error.status,\r\n          traceId: error.traceId || correlationId,\r\n          errors: error.errors,\r\n          isAborted: error.isAborted || false,\r\n          config,\r\n        }\r\n      );\r\n    }\r\n\r\n    if (error.name === 'AbortError' || error.isAborted) {\r\n      return Object.assign(new Error(error.message || 'Request was aborted'), {\r\n        type: 'request_cancelled',\r\n        title: 'Request was cancelled',\r\n        status: 0,\r\n        traceId: correlationId,\r\n        isAborted: true,\r\n        config,\r\n      } as ApiError);\r\n    }\r\n\r\n    if (error.message?.includes('timeout')) {\r\n      return Object.assign(new Error(error.message), {\r\n        type: 'timeout_error',\r\n        title: 'Request Timeout',\r\n        status: 408,\r\n        traceId: correlationId,\r\n        isAborted: true,\r\n        config,\r\n      } as ApiError);\r\n    }\r\n\r\n    if (error.message?.includes('network')) {\r\n      return Object.assign(\r\n        new Error(error.message || 'Network request failed'),\r\n        {\r\n          type: 'network_error',\r\n          title: 'Network Error',\r\n          status: 0,\r\n          traceId: correlationId,\r\n          isAborted: false,\r\n          config,\r\n        } as ApiError\r\n      );\r\n    }\r\n\r\n    return Object.assign(\r\n      new Error(error.message || 'An unknown error occurred'),\r\n      {\r\n        type: 'unknown_error',\r\n        title: 'Unknown Error',\r\n        status: 0,\r\n        traceId: correlationId,\r\n        isAborted: false,\r\n        config,\r\n      } as ApiError\r\n    );\r\n  }\r\n\r\n  // Convenience methods with abort support and overloads for error handling\r\n\r\n  // GET method overloads\r\n  get<T = any>(\r\n    endpoint: string,\r\n    config: RequestConfig & { throwErrors: false }\r\n  ): Promise<ApiResponse<T, ApiError>>;\r\n  get<T = any>(\r\n    endpoint: string,\r\n    config?: RequestConfig & { throwErrors?: true }\r\n  ): Promise<ApiResponse<T, ApiError>>;\r\n  get<T = any>(\r\n    endpoint: string,\r\n    config?: RequestConfig\r\n  ): Promise<ApiResponse<T, ApiError>>;\r\n  get<T = any>(\r\n    endpoint: string,\r\n    config?: RequestConfig\r\n  ): Promise<ApiResponse<T, ApiError>> {\r\n    return this.request<T>(endpoint, { ...config, method: 'GET' });\r\n  }\r\n\r\n  // POST method overloads\r\n  post<T = any>(\r\n    endpoint: string,\r\n    data: any,\r\n    config: RequestConfig & { throwErrors: false }\r\n  ): Promise<ApiResponse<T, ApiError>>;\r\n  post<T = any>(\r\n    endpoint: string,\r\n    data?: any,\r\n    config?: RequestConfig & { throwErrors?: true }\r\n  ): Promise<ApiResponse<T, ApiError>>;\r\n  post<T = any>(\r\n    endpoint: string,\r\n    data?: any,\r\n    config?: RequestConfig\r\n  ): Promise<ApiResponse<T, ApiError>>;\r\n  post<T = any>(\r\n    endpoint: string,\r\n    data?: any,\r\n    config?: RequestConfig\r\n  ): Promise<ApiResponse<T, ApiError>> {\r\n    return this.request<T>(endpoint, { ...config, method: 'POST', body: data });\r\n  }\r\n\r\n  // PUT method overloads\r\n  put<T = any>(\r\n    endpoint: string,\r\n    data: any,\r\n    config: RequestConfig & { throwErrors: false }\r\n  ): Promise<ApiResponse<T, ApiError>>;\r\n  put<T = any>(\r\n    endpoint: string,\r\n    data?: any,\r\n    config?: RequestConfig & { throwErrors?: true }\r\n  ): Promise<ApiResponse<T, ApiError>>;\r\n  put<T = any>(\r\n    endpoint: string,\r\n    data?: any,\r\n    config?: RequestConfig\r\n  ): Promise<ApiResponse<T, ApiError>>;\r\n  put<T = any>(\r\n    endpoint: string,\r\n    data?: any,\r\n    config?: RequestConfig\r\n  ): Promise<ApiResponse<T, ApiError>> {\r\n    return this.request<T>(endpoint, { ...config, method: 'PUT', body: data });\r\n  }\r\n\r\n  // PATCH method overloads\r\n  patch<T = any>(\r\n    endpoint: string,\r\n    data: any,\r\n    config: RequestConfig & { throwErrors: false }\r\n  ): Promise<ApiResponse<T, ApiError>>;\r\n  patch<T = any>(\r\n    endpoint: string,\r\n    data?: any,\r\n    config?: RequestConfig & { throwErrors?: true }\r\n  ): Promise<ApiResponse<T, ApiError>>;\r\n  patch<T = any>(\r\n    endpoint: string,\r\n    data?: any,\r\n    config?: RequestConfig\r\n  ): Promise<ApiResponse<T, ApiError>>;\r\n  patch<T = any>(\r\n    endpoint: string,\r\n    data?: any,\r\n    config?: RequestConfig\r\n  ): Promise<ApiResponse<T, ApiError>> {\r\n    return this.request<T>(endpoint, {\r\n      ...config,\r\n      method: 'PATCH',\r\n      body: data,\r\n    });\r\n  }\r\n\r\n  // DELETE method overloads\r\n  delete<T = any>(\r\n    endpoint: string,\r\n    config: RequestConfig & { throwErrors: false }\r\n  ): Promise<ApiResponse<T, ApiError>>;\r\n  delete<T = any>(\r\n    endpoint: string,\r\n    config?: RequestConfig & { throwErrors?: true }\r\n  ): Promise<ApiResponse<T, ApiError>>;\r\n  delete<T = any>(\r\n    endpoint: string,\r\n    config?: RequestConfig\r\n  ): Promise<ApiResponse<T, ApiError>>;\r\n  delete<T = any>(\r\n    endpoint: string,\r\n    config?: RequestConfig\r\n  ): Promise<ApiResponse<T, ApiError>> {\r\n    return this.request<T>(endpoint, { ...config, method: 'DELETE' });\r\n  }\r\n\r\n  // Filter method overloads\r\n  filter<TListModel, TFilter>(\r\n    url: string,\r\n    data: PostModel<TFilter>,\r\n    config: RequestConfig & { throwErrors: false }\r\n  ): Promise<ApiResponse<ListResponse2<TListModel>, ApiError>>;\r\n  filter<TListModel, TFilter>(\r\n    url: string,\r\n    data: PostModel<TFilter>,\r\n    config?: RequestConfig & { throwErrors?: true }\r\n  ): Promise<ApiResponse<ListResponse2<TListModel>, ApiError>>;\r\n  filter<TListModel, TFilter>(\r\n    url: string,\r\n    data: PostModel<TFilter>,\r\n    config?: RequestConfig\r\n  ): Promise<ApiResponse<ListResponse2<TListModel>, ApiError>>;\r\n  filter<TListModel, TFilter>(\r\n    url: string,\r\n    data: PostModel<TFilter>,\r\n    config?: RequestConfig\r\n  ): Promise<ApiResponse<ListResponse2<TListModel>, ApiError>> {\r\n    // Merge body: { ...postModel, ...postModel.filterModel }\r\n    const mergedData = { ...data, ...data.filterModel };\r\n\r\n    return this.request<ListResponse2<TListModel>>(url, {\r\n      ...config,\r\n      method: 'POST',\r\n      body: mergedData,\r\n    });\r\n  }\r\n}\r\n", "import { ApiClient } from './ApiClient';\r\nimport type { ErrorInterceptor } from './types/ErrorInterceptor';\r\nimport type { RequestInterceptor } from './types/RequestInterceptor';\r\nimport type { ResponseInterceptor } from './types/ResponseInterceptor';\r\n\r\nexport interface ApiClientConfig {\r\n  baseURL?: string;\r\n  timeout?: number;\r\n  correlationIdPrefix?: string;\r\n  includeCorrelationId?: boolean;\r\n  authToken?: string | null;\r\n  requestInterceptors?: RequestInterceptor[];\r\n  responseInterceptors?: ResponseInterceptor[];\r\n  errorInterceptors?: ErrorInterceptor[];\r\n}\r\n\r\nlet globalApiClient: ApiClient | null = null;\r\n\r\nexport function createApiClient(config: ApiClientConfig = {}): ApiClient {\r\n  const {\r\n    baseURL = import.meta.env.VITE_API_URL,\r\n    timeout = 30000,\r\n    correlationIdPrefix = 'api',\r\n    includeCorrelationId = true,\r\n    requestInterceptors = [],\r\n    responseInterceptors = [],\r\n    errorInterceptors = [],\r\n  } = config;\r\n\r\n  const client = new ApiClient(baseURL, timeout);\r\n\r\n  client.addRequestInterceptor(config => {\r\n    const token = localStorage.getItem('serviceToken');\r\n\r\n    if (token && !config.skipAuthRefresh) {\r\n      config.headers = {\r\n        ...config.headers,\r\n        Authorization: `Bearer ${token}`,\r\n      };\r\n    }\r\n\r\n    return config;\r\n  });\r\n\r\n  // Configure correlation ID\r\n  client.setCorrelationIdPrefix(correlationIdPrefix);\r\n  client.setIncludeCorrelationId(includeCorrelationId);\r\n\r\n  // // Set auth token if provided\r\n  // if (authToken !== undefined) {\r\n  //   client.setAuthToken(authToken);\r\n  // }\r\n\r\n  // Add interceptors\r\n  requestInterceptors.forEach(interceptor => {\r\n    client.addRequestInterceptor(interceptor);\r\n  });\r\n\r\n  responseInterceptors.forEach(interceptor => {\r\n    client.addResponseInterceptor(interceptor);\r\n  });\r\n\r\n  errorInterceptors.forEach(interceptor => {\r\n    client.addErrorInterceptor(interceptor);\r\n  });\r\n\r\n  return client;\r\n}\r\n\r\nexport function getGlobalApiClient(config?: ApiClientConfig): ApiClient {\r\n  if (!globalApiClient) {\r\n    globalApiClient = createApiClient(config);\r\n  }\r\n\r\n  return globalApiClient;\r\n}\r\n\r\nexport function setGlobalApiClient(client: ApiClient): void {\r\n  globalApiClient = client;\r\n}\r\n\r\nexport function resetGlobalApiClient(): void {\r\n  globalApiClient = null;\r\n}\r\n", "// CancelToken implementation\r\nexport class CancelToken {\r\n  private abortController: AbortController;\r\n  private cancelPromise: Promise<void>;\r\n  private cancelResolve?: () => void;\r\n\r\n  constructor() {\r\n    this.abortController = new AbortController();\r\n    this.cancelPromise = new Promise(resolve => {\r\n      this.cancelResolve = resolve;\r\n    });\r\n  }\r\n\r\n  get signal(): AbortSignal {\r\n    return this.abortController.signal;\r\n  }\r\n\r\n  cancel(reason?: string): void {\r\n    this.abortController.abort(reason);\r\n    this.cancelResolve?.();\r\n  }\r\n\r\n  get isCancelled(): boolean {\r\n    return this.abortController.signal.aborted;\r\n  }\r\n\r\n  throwIfCancelled(): void {\r\n    if (this.isCancelled) {\r\n      throw new Error('Request cancelled');\r\n    }\r\n  }\r\n\r\n  static source(): { token: CancelToken; cancel: (reason?: string) => void } {\r\n    const token = new CancelToken();\r\n\r\n    return {\r\n      token,\r\n      cancel: (reason?: string) => token.cancel(reason),\r\n    };\r\n  }\r\n}\r\n", "// React Hooks with ApiResponse format\r\nimport { useCallback } from 'react';\r\n\r\nimport type { ApiError } from './types';\r\n\r\n// Export factory methods and types\r\nexport {\r\n  createApiClient,\r\n  getGlobalApiClient,\r\n  setGlobalApiClient,\r\n  resetGlobalApiClient,\r\n} from './createApiClient';\r\n\r\nexport type { ApiClientConfig } from './createApiClient';\r\n\r\nexport { ApiClient } from './ApiClient';\r\n\r\n// Helper hook for form validation errors\r\nexport function useValidationErrors(error: ApiError | null) {\r\n  const getFieldError = useCallback(\r\n    (field: string): string | null => {\r\n      if (!error?.errors || !error.errors[field]) return null;\r\n\r\n      const fieldError = error.errors[field];\r\n\r\n      if (typeof fieldError === 'string') return fieldError;\r\n      if (Array.isArray(fieldError)) return fieldError[0];\r\n      if (typeof fieldError === 'object' && 'message' in fieldError) {\r\n        return fieldError.message;\r\n      }\r\n\r\n      return null;\r\n    },\r\n    [error]\r\n  );\r\n\r\n  const hasFieldError = useCallback(\r\n    (field: string): boolean => {\r\n      return !!getFieldError(field);\r\n    },\r\n    [getFieldError]\r\n  );\r\n\r\n  const getAllErrors = useCallback((): Record<string, string> => {\r\n    if (!error?.errors) return {};\r\n\r\n    const result: Record<string, string> = {};\r\n\r\n    Object.entries(error.errors).forEach(([key, value]) => {\r\n      if (typeof value === 'string') {\r\n        result[key] = value;\r\n      } else if (Array.isArray(value)) {\r\n        result[key] = value.join(', ');\r\n      } else if (typeof value === 'object' && value && 'message' in value) {\r\n        result[key] = value.message;\r\n      }\r\n    });\r\n\r\n    return result;\r\n  }, [error]);\r\n\r\n  return {\r\n    getFieldError,\r\n    hasFieldError,\r\n    getAllErrors,\r\n    hasErrors: error?.errors,\r\n  };\r\n}\r\n", "import type { PropsWithChildren } from 'react';\n\ntype AuthorizedViewProps = PropsWithChildren & {\n  show: boolean;\n};\n\nexport const AuthorizedView = ({ children, show }: AuthorizedViewProps) => {\n  if (!show) return <></>;\n\n  return <>{children}</>;\n};\n", "import type { ButtonProps } from '@mui/material';\nimport { Button } from '@mui/material';\nimport React from 'react';\n\nexport const CancelButton: React.FC<ButtonProps> = ({\n  children = 'Cancel',\n  variant = 'outlined',\n  sx,\n  ...rest\n}) => (\n  <Button variant={variant} sx={{ width: '6rem', ...sx }} {...rest}>\n    {children}\n  </Button>\n);\n", "import type { SxProps } from '@mui/material';\nimport { Button } from '@mui/material';\n\n/**\n * Props for the ClearButton component.\n *\n * @public\n */\ninterface ClearButtonProps {\n  /**\n   * Indicates if a form or operation is currently being submitted.\n   * When true, the button is disabled to prevent multiple clear actions.\n   */\n  isSubmitting: boolean;\n  /**\n   * Callback function executed when the clear button is clicked.\n   * Should handle the clearing logic (e.g., form reset, data clearing).\n   */\n  handleClear: () => void;\n  /**\n   * Optional MUI sx prop for custom styling.\n   * @example { mt: 2, color: 'warning.main' }\n   */\n  sx?: SxProps;\n  /**\n   * Optional localStorage key to remove when clearing.\n   * If provided, the corresponding localStorage item will be removed on click.\n   * @example \"user-preferences\" or \"form-data\"\n   */\n  storeKey?: string;\n}\n\n/**\n * Standardized clear button component with localStorage integration.\n *\n * This component provides a consistent clear button implementation that handles\n * both callback execution and optional localStorage cleanup. It automatically\n * disables during form submissions and can clear stored data when needed.\n *\n * @example\n * Basic usage:\n * ```tsx\n * <ClearButton\n *   isSubmitting={isLoading}\n *   handleClear={() => form.reset()}\n * />\n * ```\n *\n * @example\n * With localStorage cleanup:\n * ```tsx\n * <ClearButton\n *   isSubmitting={form.formState.isSubmitting}\n *   handleClear={() => setFilters({})}\n *   storeKey=\"user-filters\"\n * />\n * ```\n *\n * @param props - Component props for clear button configuration\n * @returns MUI Button component configured as a clear button\n *\n * @public\n */\nexport const ClearButton = ({\n  isSubmitting,\n  handleClear,\n  sx,\n  storeKey,\n}: ClearButtonProps) => {\n  const onClick = () => {\n    handleClear();\n    if (storeKey != null) {\n      localStorage.removeItem(storeKey);\n    }\n  };\n\n  return (\n    <Button\n      variant=\"outlined\"\n      onClick={onClick}\n      disabled={isSubmitting}\n      sx={sx}\n    >\n      Clear\n    </Button>\n  );\n};\n", "import { Container, type SxProps } from '@mui/material';\r\nimport type { ReactNode } from 'react';\r\n\r\ninterface SimpleContainerProps {\r\n  children: ReactNode;\r\n  className?: string;\r\n  sx?: SxProps;\r\n}\r\n\r\nexport const SimpleContainer = ({\r\n  children,\r\n  className,\r\n  sx,\r\n}: SimpleContainerProps) => (\r\n  <Container className={className} sx={{ ...sx }}>\r\n    {children}\r\n  </Container>\r\n);\r\n", "import FilterAltIcon from '@mui/icons-material/FilterAlt';\nimport { LoadingButton } from '@mui/lab';\nimport type { SxProps } from '@mui/material';\nimport { Badge } from '@mui/material';\n\n/**\n * Props for the FilterButton component.\n *\n * @public\n */\ninterface FilterButtonProps {\n  /**\n   * Indicates if a filter operation is currently being processed.\n   * When true, shows loading spinner and disables the button.\n   */\n  isSubmitting: boolean;\n  /**\n   * Controls button visibility and enabled state.\n   * When false, the button is disabled.\n   * @defaultValue true\n   */\n  show?: boolean;\n  /**\n   * Custom text to display on the button.\n   * @defaultValue \"Filter\"\n   * @example \"Apply Filters\" or \"Search\"\n   */\n  title?: string;\n  /**\n   * Custom icon to display instead of the default filter icon.\n   * @example <SearchIcon />\n   */\n  icon?: React.ReactNode;\n  /**\n   * Optional MUI sx prop for custom button styling.\n   * @example { mt: 2, minWidth: 120 }\n   */\n  sx?: SxProps;\n  /**\n   * Optional MUI sx prop for custom icon styling.\n   * @example { color: 'primary.main', fontSize: 18 }\n   */\n  iconSx?: SxProps;\n}\n\n/**\n * Filter button component with loading states and customizable appearance.\n *\n * This component provides a standardized filter/submit button with integrated loading\n * states, icon support, and badge styling. It's designed for use in filter forms\n * and search interfaces where users need to apply filtering criteria.\n *\n * @example\n * Basic usage:\n * ```tsx\n * <FilterButton\n *   isSubmitting={isLoading}\n *   show={hasFilters}\n * />\n * ```\n *\n * @example\n * Custom title and icon:\n * ```tsx\n * <FilterButton\n *   isSubmitting={form.formState.isSubmitting}\n *   title=\"Apply Search\"\n *   icon={<SearchIcon />}\n *   show={true}\n * />\n * ```\n *\n * @example\n * With custom styling:\n * ```tsx\n * <FilterButton\n *   isSubmitting={isProcessing}\n *   title=\"Filter Results\"\n *   sx={{ minWidth: 150, mt: 2 }}\n *   iconSx={{ fontSize: 20 }}\n * />\n * ```\n *\n * @param props - Component props for filter button configuration\n * @returns MUI LoadingButton component configured as a filter button\n *\n * @public\n */\nexport const FilterButton = ({\n  isSubmitting,\n  show,\n  title,\n  icon,\n  sx,\n  iconSx,\n}: FilterButtonProps) => {\n  return (\n    <LoadingButton\n      type=\"submit\"\n      variant=\"contained\"\n      loading={isSubmitting}\n      disabled={!show}\n      disableRipple\n      color=\"primary\"\n      sx={{\n        display: 'flex',\n        alignItems: 'center',\n        ...sx,\n      }}\n      startIcon={\n        <Badge color=\"error\" variant=\"standard\">\n          {icon ? icon : <FilterAltIcon width=\"20\" height=\"20\" sx={iconSx} />}\n        </Badge>\n      }\n    >\n      {title?.trim() === '' || !title ? 'Filter' : title}\n    </LoadingButton>\n  );\n};\n", "import Chip from '@mui/material/Chip';\r\nimport { memo } from 'react';\r\n\r\n// Individual chip component to prevent unnecessary rerenders of sibling chips\r\nexport const FilterChip = memo(\r\n  ({\r\n    fieldKey,\r\n    filter,\r\n    onDelete,\r\n  }: {\r\n    fieldKey: string;\r\n    filter: { Label: string; Value: unknown };\r\n    onDelete?: () => void;\r\n  }) => {\r\n    const hasValue =\r\n      filter.Value !== null &&\r\n      filter.Value !== undefined &&\r\n      filter.Value !== '';\r\n    const label = `${fieldKey.replace('PK', '')}: ${filter.Label}`;\r\n\r\n    return (\r\n      <Chip\r\n        key={fieldKey}\r\n        label={label}\r\n        variant={hasValue ? 'filled' : 'outlined'}\r\n        size=\"small\"\r\n        onDelete={hasValue ? onDelete : undefined}\r\n      />\r\n    );\r\n  }\r\n);\r\n\r\nFilterChip.displayName = 'FilterChip';\r\n", "import { Card, CardContent, Typography, Box } from '@mui/material';\r\nimport { memo, useMemo } from 'react';\r\n\r\nimport { FilterChip } from './FilterChip';\r\n\r\ninterface FilterDisplayProps<TFilterModel> {\r\n  friendlyFilter: Record<string, { Label: string; Value: unknown }>;\r\n  onFriendlyFilterChange?: (fieldKey: keyof TFilterModel) => void;\r\n}\r\n\r\nexport const ProgramsFilterDisplay = memo(\r\n  <TFilterModel extends Record<string, unknown>>(\r\n    props: FilterDisplayProps<TFilterModel>\r\n  ) => {\r\n    const { friendlyFilter, onFriendlyFilterChange } = props;\r\n\r\n    // Memoize delete handlers to prevent recreation\r\n    const deleteHandlers = useMemo(() => {\r\n      if (!onFriendlyFilterChange) return {};\r\n\r\n      const handlers: Record<string, () => void> = {};\r\n\r\n      for (const key of Object.keys(friendlyFilter)) {\r\n        handlers[key] = () => onFriendlyFilterChange(key as keyof TFilterModel);\r\n      }\r\n\r\n      return handlers;\r\n    }, [onFriendlyFilterChange, friendlyFilter]);\r\n\r\n    // Memoize chip list to prevent unnecessary recalculations\r\n    const chipList = useMemo(() => {\r\n      return Object.entries(friendlyFilter).map(([key, filter]) => (\r\n        <FilterChip\r\n          key={key}\r\n          fieldKey={key}\r\n          filter={filter as { Label: string; Value: unknown }}\r\n          onDelete={deleteHandlers[key]}\r\n        />\r\n      ));\r\n    }, [friendlyFilter, deleteHandlers]);\r\n\r\n    return (\r\n      <Card sx={{ mb: 2 }}>\r\n        <CardContent>\r\n          <Typography variant=\"h6\" gutterBottom>\r\n            Active Filters\r\n          </Typography>\r\n          <Box display=\"flex\" gap={1} flexWrap=\"wrap\">\r\n            {chipList}\r\n          </Box>\r\n        </CardContent>\r\n      </Card>\r\n    );\r\n  }\r\n);\r\n\r\nProgramsFilterDisplay.displayName = 'FilterDisplay';\r\n\r\nexport type { FilterDisplayProps };\r\n", "import ManageSearchIcon from '@mui/icons-material/ManageSearch';\nimport type { SxProps } from '@mui/material';\nimport {\n  Box,\n  Card,\n  CardContent,\n  CardHeader,\n  Divider,\n  Grid,\n  Typography,\n  useTheme,\n} from '@mui/material';\nimport type { PropsWithChildren, ReactNode } from 'react';\n\n/**\n * Props for the FilterWrapper component.\n *\n * @public\n */\ntype FilterWrapperProps = PropsWithChildren<{\n  /**\n   * Title text displayed in the card header.\n   * @defaultValue \"Filter\"\n   * @example \"Search Criteria\" or \"Advanced Filters\"\n   */\n  title?: string;\n  /**\n   * Number of active filters to display in the header.\n   * Only shown when showCount is true.\n   * @example 3 for \"Filter (3)\"\n   */\n  filterCount?: number;\n  /**\n   * Optional MUI sx prop for custom card styling.\n   * @example { mt: 2, boxShadow: 2 }\n   */\n  cardSx?: SxProps;\n  /**\n   * Optional MUI sx prop for custom title text styling.\n   * @example { fontSize: 18, fontWeight: 'bold' }\n   */\n  textSx?: SxProps;\n  /**\n   * Custom icon to display instead of the default search icon.\n   * @example <FilterListIcon />\n   */\n  icon?: ReactNode;\n  /**\n   * Optional MUI sx prop for custom icon styling.\n   * @example { color: 'secondary.main', fontSize: 24 }\n   */\n  iconSx?: SxProps;\n  /**\n   * Whether to display the filter count in the header.\n   * @defaultValue false\n   */\n  showCount?: boolean;\n}>;\n\n/**\n * Card-based wrapper component for organizing filter controls and form elements.\n *\n * This component provides a consistent layout for filter interfaces with a header,\n * optional filter count display, and a grid-based content area. It's designed to\n * contain form controls and filter elements in a visually organized manner.\n *\n * @example\n * Basic usage:\n * ```tsx\n * <FilterWrapper>\n *   <Grid item xs={12} md={6}>\n *     <TextField label=\"Search\" />\n *   </Grid>\n *   <Grid item xs={12} md={6}>\n *     <Select label=\"Category\" />\n *   </Grid>\n * </FilterWrapper>\n * ```\n *\n * @example\n * With custom title and count:\n * ```tsx\n * <FilterWrapper\n *   title=\"Advanced Search\"\n *   filterCount={activeFilters.length}\n *   showCount={true}\n * >\n *   {filterControls}\n * </FilterWrapper>\n * ```\n *\n * @example\n * With custom styling:\n * ```tsx\n * <FilterWrapper\n *   title=\"Product Filters\"\n *   icon={<FilterListIcon />}\n *   cardSx={{ mt: 3, borderRadius: 2 }}\n *   textSx={{ color: 'secondary.main' }}\n * >\n *   {children}\n * </FilterWrapper>\n * ```\n *\n * @param props - Component props including children and styling options\n * @returns MUI Card component with structured filter layout\n *\n * @public\n */\nexport const FilterWrapper = ({\n  children,\n  title,\n  filterCount,\n  cardSx,\n  textSx,\n  icon,\n  iconSx,\n  showCount,\n}: FilterWrapperProps) => {\n  const theme = useTheme();\n\n  return (\n    <Card\n      sx={{\n        position: 'relative',\n        borderRadius: '0px',\n        mb: 2,\n        ...cardSx,\n      }}\n    >\n      <CardHeader\n        sx={{\n          display: 'flex',\n          flexWrap: 'wrap',\n          p: '1rem',\n          '.MuiCardHeader-action': {\n            margin: 0,\n            alignSelf: 'center',\n          },\n          alignItems: 'center',\n        }}\n        title={\n          <Box sx={{ display: 'flex', alignItems: 'center', gap: 0.5 }}>\n            {icon ? (\n              icon\n            ) : (\n              <ManageSearchIcon\n                sx={{\n                  height: '2.5rem',\n                  color: theme.palette.primary.main,\n                  ...iconSx,\n                }}\n              />\n            )}\n            <Typography\n              variant=\"h5\"\n              sx={{\n                fontWeight: 'bold',\n                color: theme.palette.primary.main,\n                ...textSx,\n              }}\n            >\n              {title ? title : 'Filter'}{' '}\n              {showCount ? `(${filterCount ? filterCount : 0})` : <></>}\n            </Typography>\n          </Box>\n        }\n      ></CardHeader>\n      <Divider />\n      <CardContent sx={{ py: 2 }}>\n        <Grid container spacing={2}>\n          {children}\n        </Grid>\n      </CardContent>\n    </Card>\n  );\n};\n", "// core/components/Footer/index.tsx\r\nimport { Box, Typography } from '@mui/material';\r\nimport React from 'react';\r\n\r\nexport const Footer: React.FC = () => {\r\n  const currentYear = new Date().getFullYear();\r\n\r\n  return (\r\n    <Box\r\n      component=\"footer\"\r\n      sx={{\r\n        py: 2,\r\n        px: 4,\r\n        mt: 'auto',\r\n        backgroundColor: theme =>\r\n          theme.palette.mode === 'light'\r\n            ? theme.palette.grey[200]\r\n            : theme.palette.grey[800],\r\n      }}\r\n    >\r\n      <Typography variant=\"body2\" color=\"text.secondary\" align=\"center\">\r\n        {`\u00A9 Copyright ${currentYear} GN. All rights reserved by Parul University.`}\r\n      </Typography>\r\n    </Box>\r\n  );\r\n};\r\n", "import type { SxProps } from '@mui/material';\nimport { Grid, Tooltip, Typography } from '@mui/material';\n\n/**\n * Props for the LabelText component.\n *\n * @public\n */\ninterface LabelTextProps {\n  /**\n   * Label text to display on the left side.\n   * @example \"Name\" or \"Email Address\"\n   */\n  label: string;\n  /**\n   * Value content to display on the right side.\n   * Can be text, numbers, or React elements.\n   * @example \"John Doe\" or <Link>View Details</Link>\n   */\n  value: React.ReactNode;\n  /**\n   * Custom grid sizing for label and value sections.\n   * @defaultValue { labelSize: { xs: 6, sm: 6, md: 6 }, valueSize: { xs: 12, sm: 6, md: 6 } }\n   */\n  gridSize?: {\n    /** Grid size configuration for the label section */\n    labelSize: { xs: number; sm: number; md: number };\n    /** Grid size configuration for the value section */\n    valueSize: { xs: number; sm: number; md: number };\n  };\n  /**\n   * Grid size configuration for the entire container.\n   * @defaultValue { xs: 12, sm: 6, md: 6 }\n   */\n  containerSize?: { xs: number; sm: number; md: number };\n  /**\n   * Optional MUI sx prop for custom label styling.\n   * @example { fontWeight: 'bold', color: 'primary.main' }\n   */\n  labelSx?: SxProps;\n  /**\n   * Optional MUI sx prop for custom value styling.\n   * @example { color: 'text.secondary', fontStyle: 'italic' }\n   */\n  valueSx?: SxProps;\n}\n\n/**\n * Responsive label-value display component with hover effects and text truncation.\n *\n * This component creates a consistent label-value pair layout that adapts to different\n * screen sizes. It includes hover effects, text truncation with tooltips, and\n * customizable grid sizing for flexible layouts.\n *\n * @example\n * Basic usage:\n * ```tsx\n * <LabelText\n *   label=\"Full Name\"\n *   value=\"John Doe\"\n * />\n * ```\n *\n * @example\n * With React element value:\n * ```tsx\n * <LabelText\n *   label=\"Profile\"\n *   value={<Link href=\"/profile\">View Profile</Link>}\n * />\n * ```\n *\n * @example\n * Custom grid sizing:\n * ```tsx\n * <LabelText\n *   label=\"Description\"\n *   value={longDescription}\n *   gridSize={{\n *     labelSize: { xs: 12, sm: 3, md: 2 },\n *     valueSize: { xs: 12, sm: 9, md: 10 }\n *   }}\n *   containerSize={{ xs: 12, sm: 12, md: 12 }}\n * />\n * ```\n *\n * @param props - Component props for label-value configuration\n * @returns Grid-based layout with label and value sections\n *\n * @public\n */\nexport const LabelText = ({\n  label,\n  value,\n  gridSize,\n  containerSize,\n  labelSx,\n  valueSx,\n}: LabelTextProps) => {\n  const defaultGridSize = {\n    labelSize: { xs: 6, sm: 6, md: 6 },\n    valueSize: { xs: 12, sm: 6, md: 6 },\n  };\n  const defaultContainerSize = { xs: 12, sm: 6, md: 6 };\n  const size = gridSize || defaultGridSize;\n  const container = containerSize || defaultContainerSize;\n\n  return (\n    <Grid\n      size={container}\n      sx={{\n        display: 'flex',\n        flexDirection: { xs: 'column', sm: 'row', md: 'row' },\n        '&:hover': { bgcolor: '#efefef', overflow: 'hidden' },\n      }}\n    >\n      <Grid\n        size={size.labelSize}\n        sx={{\n          padding: '5px',\n          fontSize: '14px',\n          textAlign: { xs: 'left', sm: 'right', md: 'right' },\n          ...labelSx,\n        }}\n      >\n        {label} :\n      </Grid>\n      <Grid\n        size={size.valueSize}\n        sx={{ padding: '5px', display: 'flex', flexWrap: 'wrap' }}\n      >\n        <Tooltip title={value} arrow>\n          <Typography\n            sx={{\n              fontSize: '14px',\n              wordBreak: 'break-word',\n              overflow: 'hidden',\n              display: '-webkit-box',\n              textOverflow: 'ellipsis',\n              WebkitLineClamp: 2,\n              WebkitBoxOrient: 'vertical',\n              ...valueSx,\n              color: '#078dee',\n            }}\n          >\n            {value ? value : '-'}\n          </Typography>\n        </Tooltip>\n      </Grid>\n    </Grid>\n  );\n};\n", "import type { PropsWithChildren } from 'react';\r\n\r\ninterface RenderIfProps {\r\n  show: boolean;\r\n}\r\n\r\nexport const RenderIf = ({\r\n  show,\r\n  children,\r\n}: PropsWithChildren<RenderIfProps>) => {\r\n  return show ? <>{children}</> : null;\r\n};\r\n", "import type { SxProps, Theme } from '@mui/material';\r\nimport { Box, Divider, Grid, Stack, Typography } from '@mui/material';\r\nimport type { PropsWithChildren, ReactNode } from 'react';\r\nimport { memo, useMemo } from 'react';\r\n\r\n// Section box configuration\r\nexport interface SectionBoxProps extends PropsWithChildren {\r\n  title: string;\r\n  spacing?: number;\r\n  containerSx?: SxProps<Theme>;\r\n  titleSx?: SxProps<Theme>;\r\n  variant?: 'default' | 'form' | 'info' | 'warning' | 'error';\r\n  icon?: ReactNode;\r\n  actions?: ReactNode;\r\n  collapsible?: boolean;\r\n  defaultExpanded?: boolean;\r\n}\r\n\r\n// Theme configuration for section variants\r\nconst getSectionTheme = (variant: SectionBoxProps['variant'] = 'default') => {\r\n  const themes = {\r\n    default: {\r\n      bgcolor: '#faebd7',\r\n      color: '#925d21',\r\n    },\r\n    form: {\r\n      bgcolor: '#cdced1',\r\n      color: 'black',\r\n    },\r\n    info: {\r\n      bgcolor: '#e3f2fd',\r\n      color: '#1976d2',\r\n    },\r\n    warning: {\r\n      bgcolor: '#fff3e0',\r\n      color: '#f57c00',\r\n    },\r\n    error: {\r\n      bgcolor: '#ffebee',\r\n      color: '#d32f2f',\r\n    },\r\n  };\r\n\r\n  return themes[variant];\r\n};\r\n\r\n// Memoized SectionBox component for performance\r\nexport const SectionBox = memo<SectionBoxProps>(\r\n  ({\r\n    title,\r\n    children,\r\n    spacing = 0,\r\n    containerSx,\r\n    titleSx,\r\n    variant = 'default',\r\n    icon,\r\n    actions,\r\n  }) => {\r\n    const themeColors = useMemo(() => getSectionTheme(variant), [variant]);\r\n\r\n    const headerSx = useMemo(\r\n      () => ({\r\n        px: 1.5,\r\n        py: 0.1,\r\n        width: 'fit-content',\r\n        ...themeColors,\r\n        ...titleSx,\r\n      }),\r\n      [themeColors, titleSx]\r\n    );\r\n\r\n    const contentSx = useMemo(\r\n      () => ({\r\n        padding: '16px',\r\n        ...containerSx,\r\n      }),\r\n      [containerSx]\r\n    );\r\n\r\n    return (\r\n      <>\r\n        <Box sx={{ display: 'flex', flexDirection: 'column', width: '100%' }}>\r\n          <Stack\r\n            direction=\"row\"\r\n            justifyContent=\"space-between\"\r\n            alignItems=\"center\"\r\n            sx={headerSx}\r\n          >\r\n            <Stack direction=\"row\" alignItems=\"center\" spacing={1}>\r\n              {icon}\r\n              <Typography sx={{ fontSize: '15px', fontWeight: 400 }}>\r\n                {title}\r\n              </Typography>\r\n            </Stack>\r\n            {actions}\r\n          </Stack>\r\n          <Divider />\r\n        </Box>\r\n        <Grid container spacing={spacing} sx={contentSx}>\r\n          {children}\r\n        </Grid>\r\n      </>\r\n    );\r\n  }\r\n);\r\n", "import { TabContext } from '@mui/lab';\r\nimport type { SxProps } from '@mui/material';\r\nimport { Box, Tab, Tabs } from '@mui/material';\r\nimport type { PropsWithChildren } from 'react';\r\nimport React, { useState } from 'react';\r\n\r\nexport interface TabItem {\r\n  label: string;\r\n  value: number;\r\n  permission?: boolean;\r\n}\r\n\r\ninterface CustomTabsProps {\r\n  tabs: TabItem[];\r\n  defaultValue?: number;\r\n  onTabChange?: (newValue: number) => void;\r\n  tabSx?: SxProps;\r\n  tabsSx?: SxProps;\r\n}\r\n\r\nexport const SimpleTabs = ({\r\n  tabs,\r\n  defaultValue = 1,\r\n  onTabChange,\r\n  children,\r\n  tabSx,\r\n  tabsSx,\r\n}: CustomTabsProps & PropsWithChildren) => {\r\n  const [value, setValue] = useState<number>(defaultValue);\r\n\r\n  const handleChange = (event: React.SyntheticEvent, newValue: number) => {\r\n    setValue(newValue);\r\n    if (onTabChange) onTabChange(newValue);\r\n  };\r\n\r\n  return (\r\n    <TabContext value={value}>\r\n      <Box sx={{ borderBottom: 1, borderColor: 'divider', width: '100%' }}>\r\n        <Tabs\r\n          value={value}\r\n          onChange={handleChange}\r\n          sx={{ px: 2, py: 0, ...tabsSx }}\r\n        >\r\n          {tabs.map(tab => (\r\n            <Tab\r\n              key={tab.value}\r\n              label={tab.label}\r\n              value={tab.value}\r\n              disabled={tab.permission === false}\r\n              sx={{ fontSize: '1rem', ...tabSx }}\r\n            />\r\n          ))}\r\n        </Tabs>\r\n      </Box>\r\n\r\n      {children}\r\n    </TabContext>\r\n  );\r\n};\r\n", "import type { LoadingButtonProps } from '@mui/lab';\r\nimport { LoadingButton } from '@mui/lab';\r\nimport React from 'react';\r\n\r\ntype SubmitButtonProps = Omit<\r\n  LoadingButtonProps,\r\n  'children' | 'variant' | 'color' | 'type'\r\n>;\r\n\r\nexport const SubmitButton: React.FC<SubmitButtonProps> = ({\r\n  loading = false,\r\n  ...rest\r\n}) => (\r\n  <LoadingButton\r\n    loading={loading}\r\n    variant=\"contained\"\r\n    color=\"primary\"\r\n    type=\"submit\"\r\n    {...rest}\r\n    sx={{ fontWeight: 400 }}\r\n  >\r\n    Submit\r\n  </LoadingButton>\r\n);\r\n", "import type React from 'react';\r\nimport { forwardRef } from 'react';\r\n\r\n// ----------------------\r\n// Shared types\r\n// ----------------------\r\nexport interface DataModalButtons {\r\n  onSubmit?: () => void;\r\n  onCancel?: () => void;\r\n  isPending?: boolean;\r\n  isSuccess?: boolean;\r\n}\r\n\r\nexport interface DataModalComponentProps<TData> {\r\n  data?: TData;\r\n  isEditing?: boolean;\r\n  ref?: React.Ref<DataModalButtons>; // \uD83D\uDC48 put ref into props\r\n}\r\n\r\n// ----------------------\r\n// Project-specific HOC\r\n// ----------------------\r\nexport function withDataModal<TData>(\r\n  component: (\r\n    props: DataModalComponentProps<TData>\r\n  ) => React.ReactElement | null\r\n) {\r\n  return forwardRef<DataModalButtons, DataModalComponentProps<TData>>(\r\n    (props, ref) => component({ ...props, ref })\r\n  );\r\n}\r\n", "export interface ConfigValue {\r\n  apiBaseUrl: string;\r\n  defaultPageSize: number;\r\n}\r\n\r\nexport const Config: ConfigValue = {\r\n  defaultPageSize: 20,\r\n  apiBaseUrl: 'http://localhost:5143',\r\n  // apiBaseUrl: 'http://192.168.1.246:5143',\r\n};\r\n\r\nexport const dateTimePatterns = {\r\n  dateTime: 'DD MMM YYYY h:mm A', // 17 Apr 2022 12:00 am\r\n  date: 'DD MMM YYYY', // 17 Apr 2022\r\n  month_year_short_format: 'MMM YYYY',\r\n  month_year_full_format: 'MMMM YYYY',\r\n  year: 'YYYY',\r\n  time: 'h:mm a', // 12:00 am\r\n  split: {\r\n    dateTime: 'DD/MM/YYYY h:mm A', // 17/04/2022 12:00 am\r\n    date: 'DD/MM/YYYY', // 17/04/2022\r\n  },\r\n  paramCase: {\r\n    dateTime: 'DD-MM-YYYY h:mm A', // 17-04-2022 12:00 am\r\n    date: 'DD-MM-YYYY', // 17-04-2022\r\n    dateReverse: 'YYYY-MM-DD', // 2022-04-17 for compare date\r\n    MonthYear: 'MMM-YYYY',\r\n  },\r\n};\r\n", "import { useMemo } from 'react';\r\n\r\nimport { createApiClient } from '../api/createApiClient';\r\nimport type { ApiClientConfig } from '../api/createApiClient';\r\n\r\nexport function useApiClient(config: ApiClientConfig = {}) {\r\n  return useMemo(() => {\r\n    return createApiClient(config);\r\n  }, [\r\n    config.baseURL,\r\n    config.timeout,\r\n    config.correlationIdPrefix,\r\n    config.includeCorrelationId,\r\n    config.authToken,\r\n    config.requestInterceptors,\r\n    config.responseInterceptors,\r\n    config.errorInterceptors,\r\n  ]);\r\n}\r\n", "import type { ValidationErrors } from '@gnwebsoft/ui';\r\nimport { useCallback } from 'react';\r\nimport type { UseFormSetError, FieldValues, Path } from 'react-hook-form';\r\nimport { toast } from 'sonner';\r\n\r\nimport type { ApiError } from '../api/types';\r\n\r\nexport interface SuccessMessage {\r\n  create: string;\r\n  update: string;\r\n}\r\n\r\nexport interface ErrorMessage {\r\n  noChanges: string;\r\n  general: string;\r\n}\r\n\r\nexport interface UseFormErrorHandlerOptions<TFieldValues extends FieldValues> {\r\n  setError?: UseFormSetError<TFieldValues>;\r\n  successMessage?: SuccessMessage;\r\n  errorMessage?: ErrorMessage;\r\n}\r\n\r\nexport type SuccessHandler = (isEditing: boolean, rowsAffected?: number) => boolean;\n\r\nexport type ErrorHandler = (processedError: ApiError) => void;\r\n\r\nexport interface UseFormErrorHandlerReturn {\r\n  handleSuccess: SuccessHandler;\r\n  handleError: ErrorHandler;\r\n}\r\n\r\nexport interface UseDeleteHandlerOptions {\r\n  successMessage?: string;\r\n  errorMessage?: string;\r\n}\r\n\r\n/**\r\n * Hook to handle API errors in forms with standardized error handling and toast messages\r\n */\r\nexport const useFormErrorHandler = <TFieldValues extends FieldValues>({\r\n  setError,\r\n  successMessage = {\r\n    create: 'Created successfully',\r\n    update: 'Updated successfully',\r\n  },\r\n  errorMessage = {\r\n    noChanges: 'No changes were made',\r\n    general: 'Failed to save. Please try again.',\r\n  },\r\n}: UseFormErrorHandlerOptions<TFieldValues>): UseFormErrorHandlerReturn => {\r\n  const getFieldError = useCallback(\r\n    (fields: ValidationErrors | undefined, fieldName: string): string | undefined => {\r\n      if (!fields || !fields[fieldName]) return undefined;\r\n\r\n      const fieldError = fields[fieldName];\r\n\r\n      if (typeof fieldError === 'string') {\r\n        return fieldError;\r\n      }\r\n\r\n      if (Array.isArray(fieldError)) {\r\n        return fieldError.join(', ');\r\n      }\r\n\r\n      if (typeof fieldError === 'object' && 'message' in fieldError) {\r\n        return fieldError.message;\r\n      }\r\n\r\n      return undefined;\r\n    },\r\n    []\r\n  );\r\n\r\n  const handleSuccess = useCallback(\r\n    (isEditing: boolean, rowsAffected?: number) => {\r\n      if (rowsAffected !== undefined && rowsAffected > 0) {\r\n        toast.success(isEditing ? successMessage.update : successMessage.create);\n\r\n        return true;\r\n      } else if (rowsAffected === 0) {\r\n        toast.error(errorMessage.noChanges);\n\r\n        return false;\r\n      }\n\r\n      // If rowsAffected is undefined, assume success\r\n      toast.success(isEditing ? successMessage.update : successMessage.create);\n\r\n      return true;\r\n    },\r\n    [successMessage, errorMessage]\r\n  );\r\n\r\n  const handleError = useCallback(\r\n    (processedError: ApiError) => {\r\n      if (processedError.type === 'validation_error' && processedError.errors && setError) {\r\n        // Set field-specific errors using react-hook-form's setError (only if setError is provided)\r\n        Object.keys(processedError.errors).forEach(fieldName => {\r\n          const fieldError = getFieldError(processedError.errors, fieldName);\n\r\n          if (fieldError) {\r\n            setError(fieldName as Path<TFieldValues>, {\r\n              type: 'server',\r\n              message: fieldError,\r\n            });\r\n          }\r\n        });\r\n\r\n        // Show general validation error toast\r\n        toast.error(processedError.title || 'Please check the form for validation errors');\r\n      } else {\r\n        // Show general error toast for non-validation errors or when setError is not available\r\n        toast.error(processedError.title || errorMessage.general);\r\n      }\r\n    },\r\n    [errorMessage.general, getFieldError, setError]\r\n  );\r\n\r\n  return {\r\n    handleSuccess,\r\n    handleError,\r\n  };\r\n};\r\n\r\n/**\r\n * Convenience hook for delete operations that don't need form field validation\r\n * Uses useFormErrorHandler internally but with simplified options\r\n */\r\nexport const useDeleteHandler = ({\r\n  successMessage = 'Deleted successfully',\r\n  errorMessage = 'Failed to delete. Please try again.',\r\n}: UseDeleteHandlerOptions = {}): UseFormErrorHandlerReturn => {\r\n  return useFormErrorHandler({\r\n    successMessage: {\r\n      create: successMessage, // Not used for delete, but required for type\r\n      update: successMessage,\r\n    },\r\n    errorMessage: {\r\n      noChanges: 'No changes were made', // Not typically used for delete\r\n      general: errorMessage,\r\n    },\r\n    // setError is omitted (undefined) for delete operations\r\n  });\r\n};\r\n", "import type { QueryClient, QueryKey } from '@tanstack/react-query';\r\nimport { useQueryClient } from '@tanstack/react-query';\r\nimport { useMemo } from 'react';\r\n\r\n// Minimal type-safe cache utility for query key factories\r\nexport class CacheUtility {\r\n  constructor(private queryClient: QueryClient) {}\r\n\r\n  /**\r\n   * Get cached data using only the queryKey from query factory\r\n   */\r\n  getCachedData<T>(queryKey: QueryKey): T | undefined {\r\n    return this.queryClient.getQueryData<T>(queryKey);\r\n  }\r\n\r\n  /**\r\n   * Get cached data with transformation using select function\r\n   */\r\n  getCachedDataWithSelect<T, R>(\r\n    queryKey: QueryKey,\r\n    select: (data: T) => R\r\n  ): R | undefined {\r\n    const cachedData = this.queryClient.getQueryData<T>(queryKey);\r\n\r\n    if (cachedData === undefined) {\r\n      return undefined;\r\n    }\r\n\r\n    return select(cachedData);\r\n  }\r\n}\r\n\r\nexport function useCacheUtility(): CacheUtility {\r\n  const queryClient = useQueryClient();\r\n\r\n  return useMemo(() => new CacheUtility(queryClient), [queryClient]);\r\n}\r\n", "import type {\r\n  Control,\r\n  DeepPartialSkipArrayKey,\r\n  FieldValues,\r\n  Path,\r\n  PathValue,\r\n} from 'react-hook-form';\r\nimport { useWatch } from 'react-hook-form';\r\n\r\n/**\r\n * Core watch functions for React Hook Form\r\n * These are the primary building blocks for form watching\r\n */\r\n\r\n/**\r\n * Utility type to ensure array elements are all Path<T>\r\n */\r\nexport type PathArray<T extends FieldValues> = ReadonlyArray<Path<T>>;\r\n\r\n/**\r\n * Hook to watch entire form - returns all form values\r\n */\r\nexport const useWatchForm = <TFieldValues extends FieldValues>(\r\n  control: Control<TFieldValues>\r\n): DeepPartialSkipArrayKey<TFieldValues> => useWatch({ control });\r\n\r\n/**\r\n * Hook to watch single field by path - supports any nested path\r\n */\r\nexport const useWatchField = <\r\n  TFieldValues extends FieldValues,\r\n  TName extends Path<TFieldValues>,\r\n>(\r\n  control: Control<TFieldValues>,\r\n  name: TName\r\n): PathValue<TFieldValues, TName> => useWatch({ control, name });\r\n\r\n/**\r\n * Hook to watch multiple fields by paths - returns array of values\r\n */\r\nexport const useWatchFields = <\r\n  TFieldValues extends FieldValues,\r\n  TNames extends ReadonlyArray<Path<TFieldValues>>,\r\n>(\r\n  control: Control<TFieldValues>,\r\n  names: TNames\r\n): Array<PathValue<TFieldValues, TNames[number]>> =>\r\n  useWatch({ control, name: names }) as Array<\r\n    PathValue<TFieldValues, TNames[number]>\r\n  >;\r\n", "import { useEffect, useMemo, useState } from 'react';\r\nimport type { Control, FieldValues, Path, PathValue } from 'react-hook-form';\r\nimport { useWatch } from 'react-hook-form';\r\n\r\n/**\r\n * Utility watch functions for React Hook Form\r\n * Enhanced functionality for specific use cases\r\n */\r\n\r\n/**\r\n * Watch field with transformation/selector\r\n */\r\nexport const useWatchTransform = <\r\n  TFieldValues extends FieldValues,\r\n  TName extends Path<TFieldValues>,\r\n  TOutput,\r\n>(\r\n  control: Control<TFieldValues>,\r\n  name: TName,\r\n  transform: (value: PathValue<TFieldValues, TName>) => TOutput\r\n): TOutput => {\r\n  const value = useWatch({ control, name });\r\n\r\n  return useMemo(() => transform(value), [value, transform]);\r\n};\r\n\r\n/**\r\n * Watch field with default fallback value\r\n */\r\nexport const useWatchDefault = <\r\n  TFieldValues extends FieldValues,\r\n  TName extends Path<TFieldValues>,\r\n>(\r\n  control: Control<TFieldValues>,\r\n  name: TName,\r\n  defaultValue: PathValue<TFieldValues, TName>\r\n): PathValue<TFieldValues, TName> => {\r\n  const value = useWatch({ control, name });\r\n\r\n  return value ?? defaultValue;\r\n};\r\n\r\n/**\r\n * Watch field as boolean with guaranteed boolean return\r\n */\r\nexport const useWatchBoolean = <\r\n  TFieldValues extends FieldValues,\r\n  TName extends Path<TFieldValues>,\r\n>(\r\n  control: Control<TFieldValues>,\r\n  name: TName,\r\n  defaultValue = false\r\n): boolean => {\r\n  const value = useWatch({ control, name });\r\n\r\n  return Boolean(value ?? defaultValue);\r\n};\r\n\r\n/**\r\n * Watch multiple fields and return an object with field paths as keys\r\n */\r\nexport const useWatchBatch = <\r\n  TFieldValues extends FieldValues,\r\n  TFields extends ReadonlyArray<Path<TFieldValues>>,\r\n>(\r\n  control: Control<TFieldValues>,\r\n  fields: TFields\r\n): { [K in TFields[number]]: PathValue<TFieldValues, K> } => {\r\n  const values = useWatch({ control, name: fields });\r\n\r\n  return useMemo(() => {\r\n    const result = {} as { [K in TFields[number]]: PathValue<TFieldValues, K> };\r\n\r\n    fields.forEach((field, index) => {\r\n      result[field as TFields[number]] = values[index];\r\n    });\r\n\r\n    return result;\r\n  }, [values, fields]);\r\n};\r\n\r\n/**\r\n * Watch field conditionally based on boolean flag\r\n */\r\nexport const useWatchConditional = <\r\n  TFieldValues extends FieldValues,\r\n  TName extends Path<TFieldValues>,\r\n>(\r\n  control: Control<TFieldValues>,\r\n  name: TName,\r\n  shouldWatch: boolean,\r\n  fallback?: PathValue<TFieldValues, TName>\r\n): PathValue<TFieldValues, TName> | undefined => {\r\n  const activeValue = useWatch({\r\n    control,\r\n    name,\r\n    disabled: !shouldWatch,\r\n  });\r\n\r\n  return shouldWatch ? activeValue : fallback;\r\n};\r\n\r\n/**\r\n * Watch field with debounced updates\r\n */\r\nexport const useWatchDebounced = <\r\n  TFieldValues extends FieldValues,\r\n  TName extends Path<TFieldValues>,\r\n>(\r\n  control: Control<TFieldValues>,\r\n  name: TName,\r\n  delay = 300\r\n): PathValue<TFieldValues, TName> => {\r\n  const value = useWatch({ control, name });\r\n  const [debouncedValue, setDebouncedValue] =\r\n    useState<PathValue<TFieldValues, TName>>(value);\r\n\r\n  useEffect(() => {\r\n    const timer = setTimeout(() => {\r\n      setDebouncedValue(value);\r\n    }, delay);\r\n\r\n    return () => clearTimeout(timer);\r\n  }, [value, delay]);\r\n\r\n  return debouncedValue;\r\n};\r\n\r\n/**\r\n * Watch field with memoized selector function\r\n */\r\nexport const useWatchSelector = <\r\n  TFieldValues extends FieldValues,\r\n  TName extends Path<TFieldValues>,\r\n  TOutput,\r\n>(\r\n  control: Control<TFieldValues>,\r\n  name: TName,\r\n  selector: (value: PathValue<TFieldValues, TName>) => TOutput,\r\n  deps: React.DependencyList = []\r\n): TOutput => {\r\n  const value = useWatch({ control, name });\r\n\r\n  return useMemo(\r\n    () => selector(value),\r\n    [value, selector, ...deps] // eslint-disable-line react-hooks/exhaustive-deps\r\n  );\r\n};\r\n", "/**\r\n * Enhanced TypeScript utilities for React Hook Form's useWatch\r\n *\r\n * This module provides a comprehensive set of type-safe watch functions\r\n * with better ergonomics and additional functionality.\r\n *\r\n * @example\r\n * ```typescript\r\n * import { useWatchField, useWatchBoolean, typedWatch } from 'src/utils/watch';\r\n *\r\n * // Direct usage (inside React components)\r\n * const email = useWatchField(control, 'user.email');\r\n * const isAdmin = useWatchBoolean(control, 'user.isAdmin');\r\n *\r\n * // Object-based usage (inside React components)\r\n * const email = typedWatch.field(control, 'user.email');\r\n * const isAdmin = typedWatch.boolean(control, 'user.isAdmin');\r\n * ```\r\n */\r\n\r\n// Core functions\r\nexport { useWatchField, useWatchFields, useWatchForm } from './core';\r\n\r\n// Utility functions\r\nexport {\r\n  useWatchBatch,\r\n  useWatchBoolean,\r\n  useWatchConditional,\r\n  useWatchDebounced,\r\n  useWatchDefault,\r\n  useWatchSelector,\r\n  useWatchTransform,\r\n} from './utilities';\r\n\r\nexport type { PathArray } from './core';\r\n\r\n// Import all functions for default export\r\nimport { useWatchField, useWatchFields, useWatchForm } from './core';\r\nimport {\r\n  useWatchBatch,\r\n  useWatchBoolean,\r\n  useWatchConditional,\r\n  useWatchDebounced,\r\n  useWatchDefault,\r\n  useWatchSelector,\r\n  useWatchTransform,\r\n} from './utilities';\r\n\r\n/**\r\n * Organized utilities by use case\r\n * Provides a convenient object-based API for all watch functions\r\n */\r\nexport const typedWatch = {\r\n  // === CORE FUNCTIONS ===\r\n  /** Watch entire form */\r\n  form: useWatchForm,\r\n  /** Watch single field */\r\n  field: useWatchField,\r\n  /** Watch multiple fields */\r\n  fields: useWatchFields,\r\n\r\n  // === UTILITY FUNCTIONS ===\r\n  /** Watch with transformation */\r\n  transform: useWatchTransform,\r\n  /** Watch with default value */\r\n  withDefault: useWatchDefault,\r\n  /** Watch as boolean */\r\n  boolean: useWatchBoolean,\r\n  /** Watch multiple with custom keys */\r\n  batch: useWatchBatch,\r\n  /** Watch conditionally */\r\n  conditional: useWatchConditional,\r\n  /** Watch with debouncing */\r\n  debounced: useWatchDebounced,\r\n  /** Watch with selector */\r\n  selector: useWatchSelector,\r\n} as const;\r\n", "export const calculateFilterCount = (model: object): number =>\r\n  Object.values(model).filter(\r\n    v => v !== null && v !== undefined && String(v).trim() !== ''\r\n  ).length;\r\n", "import type { Dayjs, OpUnitType } from 'dayjs';\r\nimport dayjs from 'dayjs';\r\nimport duration from 'dayjs/plugin/duration';\r\nimport relativeTime from 'dayjs/plugin/relativeTime';\r\n\r\n// ----------------------------------------------------------------------\r\n\r\n/**\r\n * @Docs\r\n * https://day.js.org/docs/en/display/format\r\n */\r\n\r\n/**\r\n * Default timezones\r\n * https://day.js.org/docs/en/timezone/set-default-timezone#docsNav\r\n *\r\n */\r\n\r\n/**\r\n * UTC\r\n * https://day.js.org/docs/en/plugin/utc\r\n * @install\r\n * import utc from 'dayjs/plugin/utc';\r\n * dayjs.extend(utc);\r\n * @usage\r\n * dayjs().utc().format()\r\n *\r\n */\r\n\r\ndayjs.extend(duration);\r\ndayjs.extend(relativeTime);\r\n\r\n// ----------------------------------------------------------------------\r\n\r\nexport type DatePickerFormat =\r\n  | Dayjs\r\n  | Date\r\n  | string\r\n  | number\r\n  | null\r\n  | undefined;\r\n\r\nexport const formatPatterns = {\r\n  dateTime: 'DD MMM YYYY h:mm A', // 17 Apr 2022 12:00 am\r\n  date: 'DD MMM YYYY', // 17 Apr 2022\r\n  month_year_short_format: 'MMM YYYY',\r\n  month_year_full_format: 'MMMM YYYY',\r\n  year: 'YYYY',\r\n  time: 'h:mm a', // 12:00 am\r\n  split: {\r\n    dateTime: 'DD/MM/YYYY h:mm A', // 17/04/2022 12:00 am\r\n    date: 'DD/MM/YYYY', // 17/04/2022\r\n  },\r\n  paramCase: {\r\n    dateTime: 'DD-MM-YYYY h:mm A', // 17-04-2022 12:00 am\r\n    date: 'DD-MM-YYYY', // 17-04-2022\r\n    dateReverse: 'YYYY-MM-DD', // 2022-04-17 for compare date\r\n    MonthYear: 'MMM-YYYY',\r\n  },\r\n};\r\n\r\nconst isValidDate = (date: DatePickerFormat) =>\r\n  date !== null && date !== undefined && dayjs(date).isValid();\r\n\r\n// ----------------------------------------------------------------------\r\n\r\nexport function today(template?: string): string {\r\n  return dayjs(new Date()).startOf('day').format(template);\r\n}\r\n\r\n// ----------------------------------------------------------------------\r\n\r\n/**\r\n * @output 17 Apr 2022 12:00 am\r\n */\r\nexport function fDateTime(date: DatePickerFormat, template?: string): string {\r\n  if (!isValidDate(date)) {\r\n    return 'Invalid date';\r\n  }\r\n\r\n  return dayjs(date).format(template ?? formatPatterns.dateTime);\r\n}\r\n\r\n// ----------------------------------------------------------------------\r\n\r\n/**\r\n * @output 17 Apr 2022\r\n */\r\nexport function fDate(date: DatePickerFormat, template?: string): string {\r\n  if (!isValidDate(date)) {\r\n    return 'Invalid date';\r\n  }\r\n\r\n  return dayjs(date).format(template ?? formatPatterns.date);\r\n}\r\n\r\n// ----------------------------------------------------------------------\r\n\r\n/**\r\n * @output 12:00 am\r\n */\r\nexport function fTime(date: DatePickerFormat, template?: string): string {\r\n  if (!isValidDate(date)) {\r\n    return 'Invalid date';\r\n  }\r\n\r\n  return dayjs(date).format(template ?? formatPatterns.time);\r\n}\r\n\r\n// ----------------------------------------------------------------------\r\n\r\n/**\r\n * @output 1713250100\r\n */\r\nexport function fTimestamp(date: DatePickerFormat): number | 'Invalid date' {\r\n  if (!isValidDate(date)) {\r\n    return 'Invalid date';\r\n  }\r\n\r\n  return dayjs(date).valueOf();\r\n}\r\n\r\n// ----------------------------------------------------------------------\r\n\r\n/**\r\n * @output a few seconds, 2 years\r\n */\r\nexport function fToNow(date: DatePickerFormat): string {\r\n  if (!isValidDate(date)) {\r\n    return 'Invalid date';\r\n  }\r\n\r\n  return dayjs(date).toNow(true);\r\n}\r\n\r\n// ----------------------------------------------------------------------\r\n\r\n/**\r\n * @output boolean\r\n */\r\nexport function fIsBetween(\r\n  inputDate: DatePickerFormat,\r\n  startDate: DatePickerFormat,\r\n  endDate: DatePickerFormat\r\n): boolean {\r\n  if (\r\n    !isValidDate(inputDate) ||\r\n    !isValidDate(startDate) ||\r\n    !isValidDate(endDate)\r\n  ) {\r\n    return false;\r\n  }\r\n\r\n  const formattedInputDate = fTimestamp(inputDate);\r\n  const formattedStartDate = fTimestamp(startDate);\r\n  const formattedEndDate = fTimestamp(endDate);\r\n\r\n  if (\r\n    formattedInputDate === 'Invalid date' ||\r\n    formattedStartDate === 'Invalid date' ||\r\n    formattedEndDate === 'Invalid date'\r\n  ) {\r\n    return false;\r\n  }\r\n\r\n  return (\r\n    formattedInputDate >= formattedStartDate &&\r\n    formattedInputDate <= formattedEndDate\r\n  );\r\n}\r\n\r\n// ----------------------------------------------------------------------\r\n\r\n/**\r\n * @output boolean\r\n */\r\nexport function fIsAfter(\r\n  startDate: DatePickerFormat,\r\n  endDate: DatePickerFormat\r\n): boolean {\r\n  if (!isValidDate(startDate) || !isValidDate(endDate)) {\r\n    return false;\r\n  }\r\n\r\n  return dayjs(startDate).isAfter(endDate);\r\n}\r\n\r\n// ----------------------------------------------------------------------\r\n\r\n/**\r\n * @output boolean\r\n */\r\nexport function fIsSame(\r\n  startDate: DatePickerFormat,\r\n  endDate: DatePickerFormat,\r\n  unitToCompare?: OpUnitType\r\n): boolean {\r\n  if (!isValidDate(startDate) || !isValidDate(endDate)) {\r\n    return false;\r\n  }\r\n\r\n  return dayjs(startDate).isSame(endDate, unitToCompare ?? 'year');\r\n}\r\n\r\n/**\r\n * @output\r\n * Same day: 26 Apr 2024\r\n * Same month: 25 - 26 Apr 2024\r\n * Same month: 25 - 26 Apr 2024\r\n * Same year: 25 Apr - 26 May 2024\r\n */\r\nexport function fDateRangeShortLabel(\r\n  startDate: DatePickerFormat,\r\n  endDate: DatePickerFormat,\r\n  initial?: boolean\r\n): string {\r\n  if (\r\n    !isValidDate(startDate) ||\r\n    !isValidDate(endDate) ||\r\n    fIsAfter(startDate, endDate)\r\n  ) {\r\n    return 'Invalid date';\r\n  }\r\n\r\n  let label = `${fDate(startDate)} - ${fDate(endDate)}`;\r\n\r\n  if (initial) {\r\n    return label;\r\n  }\r\n\r\n  const isSameYear = fIsSame(startDate, endDate, 'year');\r\n  const isSameMonth = fIsSame(startDate, endDate, 'month');\r\n  const isSameDay = fIsSame(startDate, endDate, 'day');\r\n\r\n  if (isSameYear && !isSameMonth) {\r\n    label = `${fDate(startDate, 'DD MMM')} - ${fDate(endDate)}`;\r\n  } else if (isSameYear && isSameMonth && !isSameDay) {\r\n    label = `${fDate(startDate, 'DD')} - ${fDate(endDate)}`;\r\n  } else if (isSameYear && isSameMonth && isSameDay) {\r\n    label = `${fDate(endDate)}`;\r\n  }\r\n\r\n  return label;\r\n}\r\n\r\n// ----------------------------------------------------------------------\r\n\r\n/**\r\n * @output 2024-05-28T05:55:31+00:00\r\n */\r\nexport interface DurationProps {\r\n  years?: number;\r\n  months?: number;\r\n  days?: number;\r\n  hours?: number;\r\n  minutes?: number;\r\n  seconds?: number;\r\n  milliseconds?: number;\r\n}\r\n\r\nexport function fAdd({\r\n  years = 0,\r\n  months = 0,\r\n  days = 0,\r\n  hours = 0,\r\n  minutes = 0,\r\n  seconds = 0,\r\n  milliseconds = 0,\r\n}: DurationProps) {\r\n  const result = dayjs()\r\n    .add(\r\n      dayjs.duration({\r\n        years,\r\n        months,\r\n        days,\r\n        hours,\r\n        minutes,\r\n        seconds,\r\n        milliseconds,\r\n      })\r\n    )\r\n    .format();\r\n\r\n  return result;\r\n}\r\n\r\n/**\r\n * @output 2024-05-28T05:55:31+00:00\r\n */\r\nexport function fSub({\r\n  years = 0,\r\n  months = 0,\r\n  days = 0,\r\n  hours = 0,\r\n  minutes = 0,\r\n  seconds = 0,\r\n  milliseconds = 0,\r\n}: DurationProps) {\r\n  const result = dayjs()\r\n    .subtract(\r\n      dayjs.duration({\r\n        years,\r\n        months,\r\n        days,\r\n        hours,\r\n        minutes,\r\n        seconds,\r\n        milliseconds,\r\n      })\r\n    )\r\n    .format();\r\n\r\n  return result;\r\n}\r\n", "type EmptyValue<T> = T extends number\r\n  ? 0\r\n  : T extends string\r\n    ? null\r\n    : T extends boolean\r\n      ? null\r\n      : T extends Date\r\n        ? null\r\n        : T extends object\r\n          ? null\r\n          : null;\r\n\r\ntype EmptyObject<T extends object> = {\r\n  [K in keyof T]: EmptyValue<T[K]>;\r\n};\r\n\r\nexport function getEmptyObject<T extends object>(\r\n  data: T,\r\n  defaultValues: Partial<T> = {}\r\n): EmptyObject<T> & Partial<T> {\r\n  const obj = {} as Record<string, unknown>;\r\n\r\n  for (const key of Object.keys(data) as Array<keyof T>) {\r\n    const value = data[key];\r\n    const type = typeof value;\r\n\r\n    if (type === 'number') {\r\n      obj[key as string] = 0;\r\n    } else if (type === 'string' || type === 'boolean') {\r\n      obj[key as string] = null;\r\n    } else if (value instanceof Date) {\r\n      obj[key as string] = null;\r\n    } else {\r\n      obj[key as string] = null;\r\n    }\r\n  }\r\n\r\n  return { ...obj, ...defaultValues } as EmptyObject<T> & Partial<T>;\r\n}\r\n", "import { useRef, useMemo } from 'react';\r\n\r\n/**\r\n * Hook to maintain stable row count for data grids during loading states.\r\n * Prevents pagination jumping by preserving the last known total count.\r\n *\r\n * @param currentTotal - Current total from API response\r\n * @returns Stable row count that persists during loading\r\n */\r\nexport function useStableRowCount(currentTotal: number | undefined): number {\r\n  const rowCountRef = useRef(currentTotal || 0);\r\n\r\n  const stableRowCount = useMemo(() => {\r\n    if (currentTotal !== undefined) {\r\n      rowCountRef.current = currentTotal;\r\n    }\r\n\r\n    return rowCountRef.current;\r\n  }, [currentTotal]);\r\n\r\n  return stableRowCount;\r\n}\r\n"],
  "mappings": "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",
  "names": ["config", "jsx", "Button", "jsx", "jsx", "jsx", "jsx", "memo", "jsx", "memo", "Box", "Card", "CardContent", "Typography", "Fragment", "jsx", "jsxs", "Box", "Typography", "jsx", "Grid", "Typography", "jsx", "jsxs", "Fragment", "jsx", "Box", "Divider", "Grid", "Typography", "memo", "useMemo", "Fragment", "jsx", "jsxs", "Box", "jsx", "jsxs", "LoadingButton", "jsx", "useMemo", "useMemo", "useCallback", "useMemo", "useMemo", "useState", "useWatch", "useMemo"]
}
