@indusaction/cms-design-system 0.1.0 → 0.2.0

package/dist/index.cjs

@@ -3,26 +3,24 @@
 var React = require('react');
 var antd = require('antd');
 var jsxRuntime = require('react/jsx-runtime');
+var reactDom = require('react-dom');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
 var React__default = /*#__PURE__*/_interopDefault(React);
 
 // src/components/Button/Button.tsx
-var Button = React__default.default.forwardRef(
-  function Button2({ variant = "default", size = "middle", children, ...rest }, ref) {
-    return /* @__PURE__ */ jsxRuntime.jsx(antd.Button, { ref, type: variant, size, ...rest, children });
-  }
-);
+var Button = React__default.default.forwardRef(function Button2({ variant = "default", size = "middle", children, ...rest }, ref) {
+  return /* @__PURE__ */ jsxRuntime.jsx(antd.Button, { ref, type: variant, size, ...rest, children });
+});
 Button.displayName = "Button";
-
-// src/theme/colors.ts
 var colors = {
   brand: {
     primary: "#596993",
     primaryHover: "#6B7BA5",
     primaryActive: "#4A587C",
-    primaryLight: "#E8EBF2"
+    primaryLight: "#E8EBF2",
+    accent: "#F69120"
   },
   neutral: {
     white: "#FFFFFF",
@@ -45,32 +43,1627 @@ var colors = {
     info: "#596993"
   }
 };
-
-// src/theme/theme.ts
+var spacing = {
+  none: 0,
+  xxs: 4,
+  xs: 8,
+  sm: 12,
+  md: 16,
+  lg: 24,
+  xl: 32,
+  xxl: 48
+};
+var fontSize = {
+  xxs: 11,
+  xs: 12,
+  sm: 14,
+  md: 16,
+  lg: 20,
+  xl: 24,
+  xxl: 30
+};
+var breakpoints = {
+  xs: 480,
+  sm: 576,
+  md: 768,
+  lg: 992,
+  xl: 1200,
+  xxl: 1600
+};
 var theme = {
+  algorithm: antd.theme.defaultAlgorithm,
   token: {
     colorPrimary: colors.brand.primary,
+    colorPrimaryHover: colors.brand.primaryHover,
+    colorPrimaryActive: colors.brand.primaryActive,
+    colorPrimaryBg: colors.brand.primaryLight,
+    colorLink: colors.brand.primary,
     colorInfo: colors.semantic.info,
     colorSuccess: colors.semantic.success,
     colorWarning: colors.semantic.warning,
     colorError: colors.semantic.error,
-    colorLink: colors.brand.primary
-  },
-  components: {
-    Button: {
-      colorPrimary: colors.brand.primary,
-      colorPrimaryHover: colors.brand.primaryHover,
-      colorPrimaryActive: colors.brand.primaryActive
-    }
+    paddingXXS: spacing.xxs,
+    paddingXS: spacing.xs,
+    paddingSM: spacing.sm,
+    padding: spacing.md,
+    paddingMD: spacing.md,
+    paddingLG: spacing.lg,
+    paddingXL: spacing.xl,
+    marginXXS: spacing.xxs,
+    marginXS: spacing.xs,
+    marginSM: spacing.sm,
+    margin: spacing.md,
+    marginMD: spacing.md,
+    marginLG: spacing.lg,
+    marginXL: spacing.xl,
+    marginXXL: spacing.xxl,
+    fontSizeSM: fontSize.xs,
+    fontSize: fontSize.sm,
+    fontSizeLG: fontSize.md,
+    fontSizeXL: fontSize.lg,
+    fontSizeHeading5: fontSize.md,
+    fontSizeHeading4: fontSize.lg,
+    fontSizeHeading3: fontSize.xl,
+    fontSizeHeading2: fontSize.xxl,
+    screenXS: breakpoints.xs,
+    screenSM: breakpoints.sm,
+    screenMD: breakpoints.md,
+    screenLG: breakpoints.lg,
+    screenXL: breakpoints.xl,
+    screenXXL: breakpoints.xxl
   }
 };
 function ThemeProvider({ children }) {
-  return /* @__PURE__ */ jsxRuntime.jsx(antd.ConfigProvider, { theme, children });
+  return React__default.default.createElement(antd.ConfigProvider, { theme }, children);
+}
+var Tabs = ({ type = "line", ...rest }) => {
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    antd.ConfigProvider,
+    {
+      theme: {
+        components: {
+          Tabs: {
+            titleFontSizeSM: fontSize.sm,
+            titleFontSize: fontSize.md,
+            titleFontSizeLG: fontSize.lg
+          }
+        }
+      },
+      children: /* @__PURE__ */ jsxRuntime.jsx(antd.Tabs, { type, ...rest })
+    }
+  );
+};
+Tabs.displayName = "Tabs";
+var DropdownButton = ({
+  children,
+  ...rest
+}) => {
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    antd.ConfigProvider,
+    {
+      theme: {
+        components: {
+          Dropdown: {
+            paddingXXS: spacing.xxs,
+            paddingXS: spacing.xs
+          }
+        }
+      },
+      children: /* @__PURE__ */ jsxRuntime.jsx(antd.Dropdown.Button, { ...rest, children })
+    }
+  );
+};
+DropdownButton.displayName = "Dropdown.Button";
+var Dropdown = ({ children, ...rest }) => {
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    antd.ConfigProvider,
+    {
+      theme: {
+        components: {
+          Dropdown: {
+            paddingXXS: spacing.xxs,
+            paddingXS: spacing.xs
+          }
+        }
+      },
+      children: /* @__PURE__ */ jsxRuntime.jsx(antd.Dropdown, { ...rest, children })
+    }
+  );
+};
+Dropdown.Button = DropdownButton;
+Dropdown.displayName = "Dropdown";
+function DetailsSkeleton({ rows = 5, avatar = false }) {
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { "aria-busy": "true", "aria-live": "polite", children: [
+    avatar ? /* @__PURE__ */ jsxRuntime.jsxs(
+      "div",
+      {
+        style: {
+          display: "flex",
+          alignItems: "center",
+          gap: spacing.md,
+          marginBottom: spacing.lg
+        },
+        children: [
+          /* @__PURE__ */ jsxRuntime.jsx(antd.Skeleton.Avatar, { active: true, size: 48 }),
+          /* @__PURE__ */ jsxRuntime.jsxs("div", { style: { flex: 1, minWidth: 0 }, children: [
+            /* @__PURE__ */ jsxRuntime.jsx(
+              antd.Skeleton.Input,
+              {
+                active: true,
+                size: "small",
+                style: { width: 180, maxWidth: "70%", height: 16, marginBottom: spacing.xs }
+              }
+            ),
+            /* @__PURE__ */ jsxRuntime.jsx(
+              antd.Skeleton.Input,
+              {
+                active: true,
+                size: "small",
+                style: { width: 120, maxWidth: "50%", height: 12 }
+              }
+            )
+          ] })
+        ]
+      }
+    ) : null,
+    Array.from({ length: rows }, (_, index) => /* @__PURE__ */ jsxRuntime.jsxs(
+      "div",
+      {
+        style: {
+          display: "flex",
+          alignItems: "center",
+          gap: spacing.lg,
+          marginBottom: spacing.md
+        },
+        children: [
+          /* @__PURE__ */ jsxRuntime.jsx(
+            antd.Skeleton.Input,
+            {
+              active: true,
+              size: "small",
+              style: { width: 88, height: 12, flex: "0 0 88px" }
+            }
+          ),
+          /* @__PURE__ */ jsxRuntime.jsx(
+            antd.Skeleton.Input,
+            {
+              active: true,
+              size: "small",
+              style: {
+                width: `${58 + index % 3 * 14}%`,
+                maxWidth: 280,
+                height: 14,
+                minWidth: 0,
+                flex: 1
+              }
+            }
+          )
+        ]
+      },
+      index
+    ))
+  ] });
+}
+DetailsSkeleton.displayName = "Skeleton.Details";
+var Skeleton = ({ active = true, ...rest }) => {
+  return /* @__PURE__ */ jsxRuntime.jsx(antd.Skeleton, { active, ...rest });
+};
+Skeleton.Button = antd.Skeleton.Button;
+Skeleton.Avatar = antd.Skeleton.Avatar;
+Skeleton.Input = antd.Skeleton.Input;
+Skeleton.Image = antd.Skeleton.Image;
+Skeleton.Node = antd.Skeleton.Node;
+Skeleton.Details = DetailsSkeleton;
+Skeleton.displayName = "Skeleton";
+var DEFAULT_PAGE_SIZE = 10;
+function isColumnGroup(column) {
+  return "children" in column && Array.isArray(column.children);
+}
+function getByDataIndex(record, dataIndex) {
+  if (dataIndex == null) return void 0;
+  const path = Array.isArray(dataIndex) ? dataIndex : [dataIndex];
+  let current = record;
+  for (const key of path) {
+    if (current == null || typeof current !== "object") return void 0;
+    current = current[key];
+  }
+  return current;
+}
+function compareValues(a, b) {
+  if (a == null && b == null) return 0;
+  if (a == null) return -1;
+  if (b == null) return 1;
+  if (typeof a === "number" && typeof b === "number") return a - b;
+  return String(a).localeCompare(String(b), void 0, {
+    numeric: true,
+    sensitivity: "base"
+  });
+}
+function flattenColumns(columns) {
+  const result = [];
+  for (const column of columns) {
+    if (isColumnGroup(column)) {
+      result.push(...flattenColumns(column.children));
+    } else {
+      result.push(column);
+    }
+  }
+  return result;
+}
+function matchesSearch(record, search, columns) {
+  const query = search.trim().toLowerCase();
+  if (!query) return true;
+  const leaves = flattenColumns(columns);
+  const optedIn = leaves.filter((column) => column.searchable === true);
+  const pool = optedIn.length > 0 ? optedIn : leaves.filter((column) => column.searchable !== false);
+  return pool.some((column) => {
+    const value = getByDataIndex(record, column.dataIndex);
+    if (value == null) return false;
+    return String(value).toLowerCase().includes(query);
+  });
+}
+function defaultCompare(dataIndex) {
+  return (a, b) => compareValues(getByDataIndex(a, dataIndex), getByDataIndex(b, dataIndex));
+}
+function enhanceColumnsForClient(columns) {
+  return columns.map((column) => {
+    if (isColumnGroup(column)) {
+      return { ...column, children: enhanceColumnsForClient(column.children) };
+    }
+    const next = { ...column };
+    if (next.sorter === true && next.dataIndex != null) {
+      next.sorter = defaultCompare(next.dataIndex);
+    }
+    if (next.filters && !next.onFilter && next.dataIndex != null) {
+      next.onFilter = (value, record) => String(getByDataIndex(record, next.dataIndex)) === String(value);
+    }
+    return next;
+  });
+}
+function adaptColumnsForServer(columns) {
+  return columns.map((column) => {
+    if (isColumnGroup(column)) {
+      return { ...column, children: adaptColumnsForServer(column.children) };
+    }
+    const next = { ...column };
+    if (typeof next.sorter === "function") {
+      next.sorter = true;
+    } else if (next.sorter && typeof next.sorter === "object" && "compare" in next.sorter) {
+      const { compare: _compare, ...rest } = next.sorter;
+      next.sorter = Object.keys(rest).length > 0 ? rest : true;
+    }
+    if (next.onFilter) {
+      delete next.onFilter;
+    }
+    return next;
+  });
+}
+var SKELETON_WIDTHS = [72, 88, 64, 80, 56];
+function skeletonizeColumns(columns) {
+  return columns.map((column, index) => {
+    if (isColumnGroup(column)) {
+      return { ...column, children: skeletonizeColumns(column.children) };
+    }
+    const widthPct = SKELETON_WIDTHS[index % SKELETON_WIDTHS.length];
+    return {
+      ...column,
+      sorter: false,
+      filters: void 0,
+      onFilter: void 0,
+      filterDropdown: void 0,
+      render: () => /* @__PURE__ */ jsxRuntime.jsx(
+        Skeleton.Input,
+        {
+          active: true,
+          size: "small",
+          style: { width: `${widthPct}%`, height: 14, minWidth: 40 }
+        }
+      )
+    };
+  });
+}
+function isTableLoading(loading) {
+  if (loading == null) return false;
+  if (typeof loading === "boolean") return loading;
+  return loading.spinning !== false;
+}
+function firstSorter(sorter) {
+  return Array.isArray(sorter) ? sorter[0] : sorter;
+}
+function getTableLayout() {
+  if (typeof window === "undefined") {
+    return { isPhone: false, isTablet: false };
+  }
+  const width = window.innerWidth;
+  return {
+    isPhone: width < breakpoints.md,
+    isTablet: width >= breakpoints.md && width < breakpoints.lg
+  };
+}
+function useTableLayout() {
+  const [layout, setLayout] = React.useState(getTableLayout);
+  React.useEffect(() => {
+    const phoneQuery = window.matchMedia(`(max-width: ${breakpoints.md - 1}px)`);
+    const tabletQuery = window.matchMedia(
+      `(min-width: ${breakpoints.md}px) and (max-width: ${breakpoints.lg - 1}px)`
+    );
+    const update = () => setLayout(getTableLayout());
+    update();
+    phoneQuery.addEventListener("change", update);
+    tabletQuery.addEventListener("change", update);
+    return () => {
+      phoneQuery.removeEventListener("change", update);
+      tabletQuery.removeEventListener("change", update);
+    };
+  }, []);
+  return layout;
+}
+function resolveSearchConfig(search, mode) {
+  if (search === false) return { enabled: false };
+  const config = search === true || search == null ? {} : search;
+  return {
+    enabled: true,
+    placeholder: "Search",
+    debounceMs: mode === "server" ? 300 : 0,
+    ...config
+  };
+}
+function Table({
+  columns = [],
+  dataSource,
+  mode = "client",
+  search = true,
+  pagination,
+  onChange,
+  onQueryChange,
+  scroll,
+  size,
+  loading = false,
+  rowKey,
+  ...rest
+}) {
+  const { isPhone, isTablet } = useTableLayout();
+  const paginationObj = pagination === false ? void 0 : pagination;
+  const searchConfig = resolveSearchConfig(search, mode);
+  const [query, setQuery] = React.useState(() => ({
+    search: searchConfig.enabled && (searchConfig.value ?? searchConfig.defaultValue) || "",
+    page: paginationObj?.current ?? 1,
+    pageSize: paginationObj?.pageSize ?? DEFAULT_PAGE_SIZE,
+    filters: {},
+    sortOrder: null
+  }));
+  const [inputSearch, setInputSearch] = React.useState(query.search);
+  const [clientFilteredCount, setClientFilteredCount] = React.useState(null);
+  const queryRef = React.useRef(query);
+  queryRef.current = query;
+  const onQueryChangeRef = React.useRef(onQueryChange);
+  onQueryChangeRef.current = onQueryChange;
+  const searchOnChangeRef = React.useRef(
+    searchConfig.enabled ? searchConfig.onChange : void 0
+  );
+  searchOnChangeRef.current = searchConfig.enabled ? searchConfig.onChange : void 0;
+  const debounceMs = searchConfig.enabled ? searchConfig.debounceMs ?? 0 : 0;
+  const debounceTimer = React.useRef(null);
+  const controlledSearch = searchConfig.enabled ? searchConfig.value : void 0;
+  React.useEffect(() => {
+    if (controlledSearch === void 0) return;
+    setInputSearch(controlledSearch);
+    setQuery(
+      (prev) => prev.search === controlledSearch ? prev : { ...prev, search: controlledSearch }
+    );
+  }, [controlledSearch]);
+  React.useEffect(() => {
+    if (paginationObj?.current != null) {
+      setQuery(
+        (prev) => prev.page === paginationObj.current ? prev : { ...prev, page: paginationObj.current }
+      );
+    }
+  }, [paginationObj?.current]);
+  React.useEffect(() => {
+    if (paginationObj?.pageSize != null) {
+      setQuery(
+        (prev) => prev.pageSize === paginationObj.pageSize ? prev : { ...prev, pageSize: paginationObj.pageSize }
+      );
+    }
+  }, [paginationObj?.pageSize]);
+  React.useEffect(() => {
+    return () => {
+      if (debounceTimer.current) clearTimeout(debounceTimer.current);
+    };
+  }, []);
+  const resolvedQuery = {
+    ...query,
+    search: controlledSearch ?? query.search,
+    page: paginationObj?.current ?? query.page,
+    pageSize: paginationObj?.pageSize ?? query.pageSize
+  };
+  const emitQuery = React.useCallback((next) => {
+    setQuery(next);
+    queryRef.current = next;
+    onQueryChangeRef.current?.(next);
+  }, []);
+  const commitSearch = React.useCallback(
+    (value, immediate = false) => {
+      const run = () => {
+        searchOnChangeRef.current?.(value);
+        emitQuery({ ...queryRef.current, search: value, page: 1 });
+      };
+      if (debounceTimer.current) {
+        clearTimeout(debounceTimer.current);
+        debounceTimer.current = null;
+      }
+      if (immediate || debounceMs <= 0) {
+        run();
+        return;
+      }
+      debounceTimer.current = setTimeout(run, debounceMs);
+    },
+    [debounceMs, emitQuery]
+  );
+  const rows = React.useMemo(() => {
+    const source = dataSource ?? [];
+    if (mode === "server" || !searchConfig.enabled) return source;
+    return source.filter((record) => matchesSearch(record, resolvedQuery.search, columns));
+  }, [columns, dataSource, mode, resolvedQuery.search, searchConfig.enabled]);
+  React.useEffect(() => {
+    setClientFilteredCount(null);
+  }, [resolvedQuery.search, dataSource]);
+  const resolvedColumns = React.useMemo(
+    () => mode === "server" ? adaptColumnsForServer(columns) : enhanceColumnsForClient(columns),
+    [columns, mode]
+  );
+  const tableLoading = isTableLoading(loading);
+  const skeletonRowCount = resolvedQuery.pageSize || DEFAULT_PAGE_SIZE;
+  const displayColumns = React.useMemo(
+    () => tableLoading ? skeletonizeColumns(resolvedColumns) : resolvedColumns,
+    [resolvedColumns, tableLoading]
+  );
+  const displayRows = React.useMemo(() => {
+    if (!tableLoading) return rows;
+    return Array.from({ length: skeletonRowCount }, (_, index) => ({
+      __skeletonKey: `skeleton-${index}`
+    }));
+  }, [rows, skeletonRowCount, tableLoading]);
+  const displayRowKey = tableLoading ? (record) => String(record.__skeletonKey) : rowKey;
+  const paginationTotal = mode === "server" ? paginationObj?.total ?? rows.length : clientFilteredCount ?? rows.length;
+  const resolvedPagination = React.useMemo(() => {
+    if (pagination === false) return false;
+    const merged = {
+      showSizeChanger: true,
+      showQuickJumper: true,
+      pageSizeOptions: ["10", "20", "50"],
+      showTotal: (total, range) => `${range[0]}\u2013${range[1]} of ${total}`,
+      ...paginationObj,
+      current: resolvedQuery.page,
+      pageSize: resolvedQuery.pageSize,
+      style: { display: "none" }
+    };
+    if (mode === "server") {
+      merged.total = paginationTotal;
+    }
+    return merged;
+  }, [
+    mode,
+    pagination,
+    paginationObj,
+    paginationTotal,
+    resolvedQuery.page,
+    resolvedQuery.pageSize
+  ]);
+  const handleTableChange = (nextPagination, filters, sorter, extra) => {
+    const active = firstSorter(sorter);
+    const next = {
+      ...queryRef.current,
+      page: extra.action === "paginate" ? nextPagination.current ?? 1 : 1,
+      pageSize: nextPagination.pageSize ?? queryRef.current.pageSize,
+      filters,
+      sortField: active?.field,
+      sortOrder: active?.order ?? null
+    };
+    if (mode === "client") {
+      setClientFilteredCount(extra.currentDataSource.length);
+    }
+    emitQuery(next);
+    onChange?.(nextPagination, filters, sorter, extra);
+  };
+  const handlePaginationChange = (page, pageSize) => {
+    const next = {
+      ...queryRef.current,
+      page,
+      pageSize
+    };
+    emitQuery(next);
+    onChange?.(
+      { current: page, pageSize, total: paginationTotal },
+      next.filters,
+      {
+        field: next.sortField,
+        order: next.sortOrder
+      },
+      { currentDataSource: rows, action: "paginate" }
+    );
+  };
+  const bothControls = searchConfig.enabled && pagination !== false;
+  const compactPager = isPhone || isTablet;
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    antd.ConfigProvider,
+    {
+      theme: {
+        components: {
+          Table: {
+            headerBg: colors.neutral.gray50
+          }
+        }
+      },
+      children: /* @__PURE__ */ jsxRuntime.jsxs("div", { style: { minWidth: 0, width: "100%" }, children: [
+        searchConfig.enabled || pagination !== false ? /* @__PURE__ */ jsxRuntime.jsxs(
+          "div",
+          {
+            style: isPhone ? {
+              display: "flex",
+              flexDirection: "column",
+              alignItems: "stretch",
+              gap: spacing.sm,
+              marginBottom: spacing.md
+            } : {
+              display: "flex",
+              alignItems: "center",
+              justifyContent: bothControls ? "space-between" : searchConfig.enabled ? "flex-start" : "flex-end",
+              gap: spacing.md,
+              flexWrap: isTablet ? "wrap" : "nowrap",
+              marginBottom: spacing.md
+            },
+            children: [
+              searchConfig.enabled ? /* @__PURE__ */ jsxRuntime.jsx(
+                antd.Input.Search,
+                {
+                  allowClear: true,
+                  disabled: tableLoading,
+                  placeholder: searchConfig.placeholder,
+                  value: inputSearch,
+                  onChange: (event) => {
+                    const value = event.target.value;
+                    setInputSearch(value);
+                    commitSearch(value);
+                  },
+                  onSearch: (value) => {
+                    setInputSearch(value);
+                    commitSearch(value, true);
+                  },
+                  style: isPhone ? { width: "100%" } : isTablet ? {
+                    width: 240,
+                    maxWidth: "100%",
+                    flex: "0 1 240px",
+                    minWidth: 160
+                  } : { width: 320, flex: "0 0 320px", maxWidth: "100%" }
+                }
+              ) : null,
+              pagination !== false ? /* @__PURE__ */ jsxRuntime.jsx(
+                "div",
+                {
+                  style: {
+                    display: "flex",
+                    justifyContent: isPhone ? "center" : "flex-end",
+                    maxWidth: "100%",
+                    minWidth: 0,
+                    overflowX: "auto",
+                    flex: isPhone ? void 0 : "1 1 auto"
+                  },
+                  children: /* @__PURE__ */ jsxRuntime.jsx(
+                    antd.Pagination,
+                    {
+                      current: resolvedQuery.page,
+                      pageSize: resolvedQuery.pageSize,
+                      total: paginationTotal,
+                      size: compactPager ? "small" : void 0,
+                      simple: isPhone,
+                      showLessItems: compactPager,
+                      responsive: true,
+                      showSizeChanger: paginationObj?.showSizeChanger ?? !isPhone,
+                      showQuickJumper: paginationObj?.showQuickJumper ?? !compactPager,
+                      pageSizeOptions: paginationObj?.pageSizeOptions ?? ["10", "20", "50"],
+                      showTotal: paginationObj?.showTotal ?? (isPhone ? (total, range) => `${range[0]}\u2013${range[1]} of ${total}` : compactPager ? void 0 : (total, range) => `${range[0]}\u2013${range[1]} of ${total}`),
+                      disabled: paginationObj?.disabled || tableLoading,
+                      onChange: handlePaginationChange,
+                      style: { margin: 0, flexShrink: 0 }
+                    }
+                  )
+                }
+              ) : null
+            ]
+          }
+        ) : null,
+        /* @__PURE__ */ jsxRuntime.jsx(
+          antd.Table,
+          {
+            ...rest,
+            size: size ?? (isPhone ? "small" : "middle"),
+            scroll: { x: "max-content", ...scroll },
+            columns: displayColumns,
+            dataSource: displayRows,
+            rowKey: displayRowKey,
+            pagination: resolvedPagination,
+            onChange: handleTableChange
+          }
+        )
+      ] })
+    }
+  );
+}
+Table.displayName = "Table";
+var Tag = React__default.default.forwardRef(function Tag2({ children, ...rest }, ref) {
+  return /* @__PURE__ */ jsxRuntime.jsx(antd.Tag, { ref, ...rest, children });
+});
+var { Link: AntLink } = antd.Typography;
+var Link = React__default.default.forwardRef(function Link2({ children, ...rest }, ref) {
+  return /* @__PURE__ */ jsxRuntime.jsx(AntLink, { ref, ...rest, children });
+});
+var Card = React__default.default.forwardRef(
+  ({
+    title,
+    description,
+    tags,
+    extraInfo,
+    ctas,
+    layout = "inline",
+    children,
+    className = "",
+    loading = false,
+    loadingRows = 5,
+    ...rest
+  }, ref) => {
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      antd.Card,
+      {
+        ref,
+        className: `cms-card cms-card-${layout} ${className}`,
+        ...rest,
+        children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "cms-card-content", children: [
+          /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "cms-card-main", children: [
+            title && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "cms-card-title", children: title }),
+            description && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "cms-card-description", children: description }),
+            tags && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "cms-card-tags", children: tags }),
+            extraInfo && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "cms-card-extra-info", children: extraInfo }),
+            loading ? /* @__PURE__ */ jsxRuntime.jsx(Skeleton.Details, { rows: loadingRows }) : children
+          ] }),
+          ctas && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "cms-card-ctas", children: ctas })
+        ] })
+      }
+    );
+  }
+);
+Card.displayName = "Card";
+var Modal = ({ children, ...rest }) => {
+  return /* @__PURE__ */ jsxRuntime.jsx(antd.Modal, { ...rest, children });
+};
+Modal.info = antd.Modal.info;
+Modal.success = antd.Modal.success;
+Modal.error = antd.Modal.error;
+Modal.warning = antd.Modal.warning;
+Modal.warn = antd.Modal.warn;
+Modal.confirm = antd.Modal.confirm;
+Modal.destroyAll = antd.Modal.destroyAll;
+Modal.config = antd.Modal.config;
+Modal.useModal = antd.Modal.useModal;
+Modal.displayName = "Modal";
+var { Text, Title } = antd.Typography;
+function getInitials(name) {
+  const parts = name.trim().split(/\s+/).filter(Boolean);
+  if (parts.length === 0) return "";
+  if (parts.length === 1) return parts[0].charAt(0).toUpperCase();
+  return `${parts[0].charAt(0)}${parts[parts.length - 1].charAt(0)}`.toUpperCase();
+}
+var Header = React__default.default.forwardRef(
+  ({
+    title,
+    description,
+    subtitle,
+    breadcrumbs,
+    actions,
+    extra,
+    leading,
+    user,
+    userMenu,
+    onLogout,
+    sticky = true,
+    className,
+    style
+  }, ref) => {
+    const descriptionText = description ?? subtitle;
+    const hasActions = Boolean(actions?.length || extra || user);
+    const defaultUserItems = [
+      {
+        key: "profile",
+        label: user?.name,
+        disabled: true
+      },
+      ...user?.role ? [{ key: "role", label: user.role, disabled: true }] : [],
+      ...onLogout ? [{ type: "divider" }, { key: "logout", label: "Logout", danger: true }] : []
+    ];
+    const menu = user ? userMenu ?? {
+      items: defaultUserItems,
+      onClick: ({ key }) => {
+        if (key === "logout") onLogout?.();
+      }
+    } : void 0;
+    const breadcrumbItems = breadcrumbs?.map((item) => ({
+      title: item.href || item.onClick ? /* @__PURE__ */ jsxRuntime.jsx(
+        "a",
+        {
+          href: item.href ?? "#",
+          onClick: (event) => {
+            if (!item.href) event.preventDefault();
+            item.onClick?.();
+          },
+          children: item.title
+        }
+      ) : item.title
+    }));
+    return /* @__PURE__ */ jsxRuntime.jsxs(
+      "header",
+      {
+        ref,
+        className: ["cms-ds-header", className].filter(Boolean).join(" "),
+        style: {
+          display: "flex",
+          alignItems: "flex-start",
+          justifyContent: "space-between",
+          gap: spacing.lg,
+          flexWrap: "nowrap",
+          padding: `${spacing.lg}px ${spacing.xl}px`,
+          background: colors.neutral.white,
+          borderBottom: `1px solid ${colors.neutral.gray200}`,
+          position: sticky ? "sticky" : void 0,
+          top: sticky ? 0 : void 0,
+          zIndex: sticky ? 20 : void 0,
+          ...style
+        },
+        children: [
+          /* @__PURE__ */ jsxRuntime.jsxs(
+            "div",
+            {
+              style: {
+                display: "flex",
+                alignItems: "flex-start",
+                gap: spacing.sm,
+                flex: "1 1 auto",
+                minWidth: 0
+              },
+              children: [
+                leading ? /* @__PURE__ */ jsxRuntime.jsx(
+                  "div",
+                  {
+                    style: {
+                      flexShrink: 0,
+                      display: "flex",
+                      alignItems: "center",
+                      paddingTop: 2
+                    },
+                    children: leading
+                  }
+                ) : null,
+                /* @__PURE__ */ jsxRuntime.jsxs("div", { style: { flex: 1, minWidth: 0 }, children: [
+                  breadcrumbItems && breadcrumbItems.length > 0 ? /* @__PURE__ */ jsxRuntime.jsx(
+                    antd.Breadcrumb,
+                    {
+                      items: breadcrumbItems,
+                      style: {
+                        fontSize: fontSize.xs,
+                        marginBottom: spacing.xs
+                      }
+                    }
+                  ) : null,
+                  title ? /* @__PURE__ */ jsxRuntime.jsx(
+                    Title,
+                    {
+                      level: 3,
+                      ellipsis: { tooltip: typeof title === "string" ? title : void 0 },
+                      style: {
+                        margin: 0,
+                        color: colors.neutral.gray900,
+                        fontSize: fontSize.xl,
+                        lineHeight: "32px",
+                        fontWeight: 600
+                      },
+                      children: title
+                    }
+                  ) : null,
+                  descriptionText ? /* @__PURE__ */ jsxRuntime.jsx(
+                    Text,
+                    {
+                      style: {
+                        display: "block",
+                        marginTop: spacing.xxs,
+                        color: colors.neutral.gray600,
+                        fontSize: fontSize.sm,
+                        lineHeight: "22px",
+                        maxWidth: 720
+                      },
+                      children: descriptionText
+                    }
+                  ) : null
+                ] })
+              ]
+            }
+          ),
+          hasActions ? /* @__PURE__ */ jsxRuntime.jsxs(
+            "div",
+            {
+              className: "cms-ds-header-actions",
+              style: {
+                display: "flex",
+                alignItems: "center",
+                justifyContent: "flex-end",
+                gap: spacing.sm,
+                flex: "0 0 auto",
+                flexWrap: "wrap",
+                paddingTop: title ? 2 : 0
+              },
+              children: [
+                extra,
+                actions?.map((action) => /* @__PURE__ */ jsxRuntime.jsx(
+                  Button,
+                  {
+                    variant: action.variant ?? "default",
+                    icon: action.icon,
+                    onClick: action.onClick,
+                    href: action.href,
+                    disabled: action.disabled,
+                    danger: action.danger,
+                    children: action.label
+                  },
+                  action.key
+                )),
+                user && menu ? /* @__PURE__ */ jsxRuntime.jsx(Dropdown, { menu, trigger: ["click"], placement: "bottomRight", children: /* @__PURE__ */ jsxRuntime.jsx(
+                  "button",
+                  {
+                    type: "button",
+                    "aria-label": user.name,
+                    style: {
+                      display: "flex",
+                      alignItems: "center",
+                      gap: spacing.xs,
+                      border: "none",
+                      background: "transparent",
+                      cursor: "pointer",
+                      padding: spacing.xxs,
+                      borderRadius: 999,
+                      flexShrink: 0
+                    },
+                    children: /* @__PURE__ */ jsxRuntime.jsx(
+                      antd.Avatar,
+                      {
+                        size: 36,
+                        src: user.avatarSrc,
+                        alt: user.name,
+                        style: {
+                          backgroundColor: colors.brand.primary,
+                          color: colors.neutral.white,
+                          fontWeight: 600,
+                          fontSize: fontSize.xs
+                        },
+                        children: getInitials(user.name)
+                      }
+                    )
+                  }
+                ) }) : null
+              ]
+            }
+          ) : null,
+          /* @__PURE__ */ jsxRuntime.jsx("style", { children: `@media (max-width: ${breakpoints.md - 1}px) {
+            .cms-ds-header { flex-wrap: wrap; }
+            .cms-ds-header-actions { width: 100%; justify-content: flex-start; }
+          }` })
+        ]
+      }
+    );
+  }
+);
+Header.displayName = "Header";
+
+// src/assets/indusActionLogo.ts
+var indusActionLogo = "data:image/png;base64,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";
+function LogoutIcon({ size = 14, className, style }) {
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "svg",
+    {
+      width: size,
+      height: size,
+      viewBox: "0 0 24 24",
+      fill: "none",
+      stroke: "currentColor",
+      strokeWidth: "2",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      "aria-hidden": "true",
+      className,
+      style,
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M9 21H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h4" }),
+        /* @__PURE__ */ jsxRuntime.jsx("polyline", { points: "16 17 21 12 16 7" }),
+        /* @__PURE__ */ jsxRuntime.jsx("line", { x1: "21", y1: "12", x2: "9", y2: "12" })
+      ]
+    }
+  );
+}
+function CollapseIcon({
+  collapsed,
+  size = 14,
+  className,
+  style
+}) {
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "svg",
+    {
+      width: size,
+      height: size,
+      viewBox: "0 0 24 24",
+      fill: "none",
+      stroke: "currentColor",
+      strokeWidth: "2",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      "aria-hidden": "true",
+      className,
+      style: {
+        transform: collapsed ? "rotate(180deg)" : void 0,
+        ...style
+      },
+      children: /* @__PURE__ */ jsxRuntime.jsx("polyline", { points: "15 18 9 12 15 6" })
+    }
+  );
+}
+function MenuIcon({ size = 18, className, style }) {
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "svg",
+    {
+      width: size,
+      height: size,
+      viewBox: "0 0 24 24",
+      fill: "none",
+      stroke: "currentColor",
+      strokeWidth: "2",
+      strokeLinecap: "round",
+      "aria-hidden": "true",
+      className,
+      style,
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsx("line", { x1: "3", y1: "6", x2: "21", y2: "6" }),
+        /* @__PURE__ */ jsxRuntime.jsx("line", { x1: "3", y1: "12", x2: "21", y2: "12" }),
+        /* @__PURE__ */ jsxRuntime.jsx("line", { x1: "3", y1: "18", x2: "21", y2: "18" })
+      ]
+    }
+  );
+}
+function CloseIcon({ size = 14, className, style }) {
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "svg",
+    {
+      width: size,
+      height: size,
+      viewBox: "0 0 24 24",
+      fill: "none",
+      stroke: "currentColor",
+      strokeWidth: "2",
+      strokeLinecap: "round",
+      "aria-hidden": "true",
+      className,
+      style,
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsx("line", { x1: "18", y1: "6", x2: "6", y2: "18" }),
+        /* @__PURE__ */ jsxRuntime.jsx("line", { x1: "6", y1: "6", x2: "18", y2: "18" })
+      ]
+    }
+  );
+}
+var { Sider } = antd.Layout;
+var MOBILE_HEADER = spacing.xxl;
+var LOGO_HEIGHT = spacing.xxl + spacing.md;
+var LOGO_HEIGHT_COMPACT = spacing.lg;
+function useBelowBreakpoint(breakpoint) {
+  const screens = antd.Grid.useBreakpoint();
+  if (!breakpoint) return false;
+  if (Object.keys(screens).length === 0) {
+    if (typeof window === "undefined") return false;
+    return window.matchMedia(
+      `(max-width: ${breakpoints[breakpoint] - 1}px)`
+    ).matches;
+  }
+  return !screens[breakpoint];
+}
+function getInitials2(name) {
+  const parts = name.trim().split(/\s+/).filter(Boolean);
+  if (parts.length === 0) return "";
+  if (parts.length === 1) return parts[0].charAt(0).toUpperCase();
+  return `${parts[0].charAt(0)}${parts[parts.length - 1].charAt(0)}`.toUpperCase();
+}
+function SideNavFooter({
+  user,
+  collapsed = false,
+  onLogout,
+  logoutLabel = "Logout"
+}) {
+  if (!user && !onLogout) return null;
+  const initials = user ? getInitials2(user.name) : "";
+  const logoutButton = /* @__PURE__ */ jsxRuntime.jsx(
+    antd.Button,
+    {
+      type: "text",
+      size: "small",
+      icon: /* @__PURE__ */ jsxRuntime.jsx(LogoutIcon, {}),
+      "aria-label": logoutLabel,
+      style: {
+        color: colors.brand.primary,
+        width: 28,
+        height: 28,
+        padding: spacing.none,
+        flexShrink: 0
+      }
+    }
+  );
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "div",
+    {
+      style: {
+        flexShrink: 0,
+        borderTop: `1px solid ${colors.neutral.gray200}`,
+        padding: collapsed ? spacing.sm : spacing.md,
+        display: "flex",
+        flexDirection: collapsed ? "column" : "row",
+        alignItems: "center",
+        gap: spacing.xs,
+        background: colors.neutral.white
+      },
+      children: [
+        user ? /* @__PURE__ */ jsxRuntime.jsxs(
+          "div",
+          {
+            style: {
+              display: "flex",
+              alignItems: "center",
+              gap: spacing.xs,
+              justifyContent: collapsed ? "center" : "flex-start",
+              minWidth: 0,
+              flex: 1
+            },
+            children: [
+              /* @__PURE__ */ jsxRuntime.jsx(
+                antd.Avatar,
+                {
+                  size: 28,
+                  src: user.avatarSrc,
+                  alt: user.name,
+                  style: {
+                    backgroundColor: colors.brand.primary,
+                    color: colors.neutral.white,
+                    fontWeight: 600,
+                    fontSize: fontSize.xs,
+                    flexShrink: 0
+                  },
+                  children: initials
+                }
+              ),
+              collapsed ? null : /* @__PURE__ */ jsxRuntime.jsxs("div", { style: { minWidth: 0, flex: 1 }, children: [
+                /* @__PURE__ */ jsxRuntime.jsx(
+                  antd.Typography.Text,
+                  {
+                    strong: true,
+                    ellipsis: true,
+                    style: {
+                      display: "block",
+                      color: colors.neutral.gray800,
+                      fontSize: fontSize.sm,
+                      lineHeight: "18px"
+                    },
+                    children: user.name
+                  }
+                ),
+                user.role ? /* @__PURE__ */ jsxRuntime.jsx(
+                  antd.Typography.Text,
+                  {
+                    ellipsis: true,
+                    style: {
+                      display: "block",
+                      color: colors.neutral.gray500,
+                      fontSize: fontSize.xxs,
+                      lineHeight: "16px"
+                    },
+                    children: user.role
+                  }
+                ) : null
+              ] })
+            ]
+          }
+        ) : null,
+        onLogout ? /* @__PURE__ */ jsxRuntime.jsx(
+          antd.Popconfirm,
+          {
+            title: logoutLabel,
+            description: "Are you sure you want to logout?",
+            okText: "Yes",
+            cancelText: "No",
+            onConfirm: onLogout,
+            placement: "top",
+            children: logoutButton
+          }
+        ) : null
+      ]
+    }
+  );
+}
+function SideNavPanel({
+  collapsed,
+  items,
+  menuStyle,
+  menuTheme,
+  menuRest,
+  user,
+  onLogout,
+  logoutLabel,
+  logoSrc,
+  logoAlt,
+  logo,
+  headerButton
+}) {
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "div",
+    {
+      style: {
+        display: "flex",
+        flexDirection: "column",
+        height: "100%",
+        minHeight: 0,
+        background: colors.neutral.white,
+        overflow: "hidden"
+      },
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsxs(
+          "div",
+          {
+            style: {
+              flexShrink: 0,
+              background: colors.neutral.white,
+              display: "flex",
+              flexDirection: collapsed ? "column" : "row",
+              alignItems: "center",
+              gap: spacing.xs,
+              padding: collapsed ? spacing.sm : spacing.md,
+              borderBottom: `1px solid ${colors.neutral.gray200}`
+            },
+            children: [
+              /* @__PURE__ */ jsxRuntime.jsx(
+                "div",
+                {
+                  style: {
+                    flex: 1,
+                    display: "flex",
+                    alignItems: "center",
+                    justifyContent: collapsed ? "center" : "flex-start",
+                    minWidth: 0
+                  },
+                  children: logo ?? /* @__PURE__ */ jsxRuntime.jsx(
+                    "img",
+                    {
+                      src: logoSrc,
+                      alt: logoAlt,
+                      style: {
+                        display: "block",
+                        width: "auto",
+                        maxWidth: "100%",
+                        height: collapsed ? LOGO_HEIGHT_COMPACT : LOGO_HEIGHT,
+                        maxHeight: collapsed ? LOGO_HEIGHT_COMPACT : LOGO_HEIGHT,
+                        objectFit: "contain",
+                        objectPosition: collapsed ? "center" : "left center"
+                      }
+                    }
+                  )
+                }
+              ),
+              headerButton
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "div",
+          {
+            style: {
+              flex: "1 1 0%",
+              minHeight: 0,
+              overflow: "auto"
+            },
+            children: /* @__PURE__ */ jsxRuntime.jsx(
+              antd.ConfigProvider,
+              {
+                theme: {
+                  components: {
+                    Menu: {
+                      itemMarginInline: spacing.xxs,
+                      itemPaddingInline: spacing.md
+                    }
+                  }
+                },
+                children: /* @__PURE__ */ jsxRuntime.jsx(
+                  antd.Menu,
+                  {
+                    mode: "inline",
+                    inlineIndent: spacing.sm,
+                    theme: menuTheme,
+                    items,
+                    style: {
+                      borderInlineEnd: "none",
+                      paddingBlock: spacing.sm,
+                      ...menuStyle
+                    },
+                    ...menuRest
+                  }
+                )
+              }
+            )
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          SideNavFooter,
+          {
+            user,
+            collapsed,
+            onLogout,
+            logoutLabel
+          }
+        )
+      ]
+    }
+  );
+}
+function SideNav({
+  items,
+  menu,
+  user,
+  onLogout,
+  logoutLabel,
+  logoSrc = indusActionLogo,
+  logoAlt = "Indus Action",
+  logo,
+  width = 256,
+  theme: theme2 = "light",
+  collapsed: collapsedProp,
+  defaultCollapsed,
+  onCollapse,
+  collapsible,
+  trigger,
+  style,
+  breakpoint = "md",
+  showMobileBar = true,
+  mobileTrigger,
+  mobileOpen: mobileOpenProp,
+  onMobileOpenChange,
+  ...siderProps
+}) {
+  const isMobile = useBelowBreakpoint(breakpoint);
+  const [uncontrolledCollapsed, setUncontrolledCollapsed] = React.useState(
+    defaultCollapsed ?? false
+  );
+  const [uncontrolledMobileOpen, setUncontrolledMobileOpen] = React.useState(false);
+  const isCollapsedControlled = collapsedProp !== void 0;
+  const collapsed = isCollapsedControlled ? collapsedProp : uncontrolledCollapsed;
+  const isMobileOpenControlled = mobileOpenProp !== void 0;
+  const mobileOpen = isMobileOpenControlled ? mobileOpenProp : uncontrolledMobileOpen;
+  const setMobileOpen = (open) => {
+    if (!isMobileOpenControlled) setUncontrolledMobileOpen(open);
+    onMobileOpenChange?.(open);
+  };
+  const handleCollapse = (value, type) => {
+    if (!isCollapsedControlled) setUncontrolledCollapsed(value);
+    onCollapse?.(value, type);
+  };
+  React.useEffect(() => {
+    if (!isMobile) setMobileOpen(false);
+  }, [isMobile]);
+  React.useEffect(() => {
+    if (!isMobile || !showMobileBar) return;
+    const previous = document.body.style.paddingTop;
+    document.body.style.paddingTop = `${MOBILE_HEADER}px`;
+    return () => {
+      document.body.style.paddingTop = previous;
+    };
+  }, [isMobile, showMobileBar]);
+  const {
+    style: menuStyle,
+    theme: menuTheme,
+    onClick: menuOnClick,
+    ...menuRest
+  } = menu ?? {};
+  const handleMenuClick = (info) => {
+    menuOnClick?.(info);
+    if (isMobile) setMobileOpen(false);
+  };
+  const useHeaderToggle = Boolean(collapsible) && trigger === void 0;
+  const panelTheme = menuTheme ?? theme2;
+  const iconButtonStyle = {
+    color: colors.brand.primary,
+    width: 28,
+    height: 28,
+    padding: spacing.none,
+    flexShrink: 0
+  };
+  const panel = (headerButton, panelCollapsed) => /* @__PURE__ */ jsxRuntime.jsx(
+    SideNavPanel,
+    {
+      collapsed: panelCollapsed,
+      items,
+      menuStyle,
+      menuTheme: panelTheme,
+      menuRest: { ...menuRest, onClick: handleMenuClick },
+      user,
+      onLogout,
+      logoutLabel,
+      logoSrc,
+      logoAlt,
+      logo,
+      headerButton
+    }
+  );
+  if (isMobile) {
+    const hamburger = showMobileBar && mobileTrigger !== null ? mobileTrigger ?? /* @__PURE__ */ jsxRuntime.jsx(
+      antd.Button,
+      {
+        type: "text",
+        "aria-label": "Open navigation",
+        icon: /* @__PURE__ */ jsxRuntime.jsx(MenuIcon, {}),
+        onClick: () => setMobileOpen(true),
+        style: iconButtonStyle
+      }
+    ) : null;
+    return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+      showMobileBar ? reactDom.createPortal(
+        /* @__PURE__ */ jsxRuntime.jsxs(
+          "header",
+          {
+            style: {
+              position: "fixed",
+              top: 0,
+              left: 0,
+              right: 0,
+              height: MOBILE_HEADER,
+              zIndex: 1e3,
+              display: "flex",
+              alignItems: "center",
+              justifyContent: "space-between",
+              gap: spacing.xs,
+              paddingInline: spacing.md,
+              borderBottom: `1px solid ${colors.neutral.gray200}`,
+              background: colors.neutral.white
+            },
+            children: [
+              /* @__PURE__ */ jsxRuntime.jsx(
+                "div",
+                {
+                  style: {
+                    display: "flex",
+                    alignItems: "center",
+                    minWidth: 0,
+                    flex: 1
+                  },
+                  children: logo ?? /* @__PURE__ */ jsxRuntime.jsx(
+                    "img",
+                    {
+                      src: logoSrc,
+                      alt: logoAlt,
+                      style: {
+                        display: "block",
+                        height: LOGO_HEIGHT_COMPACT,
+                        width: "auto",
+                        maxWidth: "100%",
+                        objectFit: "contain",
+                        objectPosition: "left center"
+                      }
+                    }
+                  )
+                }
+              ),
+              hamburger
+            ]
+          }
+        ),
+        document.body
+      ) : null,
+      /* @__PURE__ */ jsxRuntime.jsx(
+        antd.Drawer,
+        {
+          placement: "left",
+          open: mobileOpen,
+          onClose: () => setMobileOpen(false),
+          width,
+          closable: false,
+          zIndex: 1100,
+          styles: {
+            body: {
+              padding: 0,
+              height: "100%",
+              display: "flex",
+              flexDirection: "column"
+            }
+          },
+          children: panel(
+            /* @__PURE__ */ jsxRuntime.jsx(
+              antd.Button,
+              {
+                type: "text",
+                size: "small",
+                "aria-label": "Close navigation",
+                icon: /* @__PURE__ */ jsxRuntime.jsx(CloseIcon, {}),
+                onClick: () => setMobileOpen(false),
+                style: iconButtonStyle
+              }
+            ),
+            false
+          )
+        }
+      )
+    ] });
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    Sider,
+    {
+      theme: theme2,
+      width,
+      collapsed,
+      collapsible,
+      trigger: useHeaderToggle ? null : trigger,
+      onCollapse: handleCollapse,
+      style: {
+        height: "100vh",
+        position: "sticky",
+        top: 0,
+        overflow: "hidden",
+        borderRight: `1px solid ${colors.neutral.gray200}`,
+        background: colors.neutral.white,
+        ...style
+      },
+      ...siderProps,
+      children: panel(
+        useHeaderToggle ? /* @__PURE__ */ jsxRuntime.jsx(
+          antd.Button,
+          {
+            type: "text",
+            size: "small",
+            "aria-label": collapsed ? "Expand navigation" : "Collapse navigation",
+            icon: /* @__PURE__ */ jsxRuntime.jsx(CollapseIcon, { collapsed }),
+            onClick: () => handleCollapse(!collapsed, "clickTrigger"),
+            style: iconButtonStyle
+          }
+        ) : null,
+        collapsed
+      )
+    }
+  );
+}
+SideNav.displayName = "SideNav";
+function StatusPage({
+  status,
+  title,
+  subTitle,
+  actionLabel,
+  onAction,
+  actionHref,
+  extra,
+  fullPage = true,
+  className,
+  style
+}) {
+  const action = extra ?? (actionLabel ? /* @__PURE__ */ jsxRuntime.jsx(
+    Button,
+    {
+      variant: "primary",
+      size: "large",
+      ...actionHref ? { href: actionHref } : {},
+      onClick: onAction,
+      children: actionLabel
+    }
+  ) : void 0);
+  const result = /* @__PURE__ */ jsxRuntime.jsx(
+    antd.Result,
+    {
+      status,
+      title,
+      subTitle,
+      extra: action
+    }
+  );
+  if (!fullPage) {
+    return /* @__PURE__ */ jsxRuntime.jsx("div", { className, style, children: result });
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "div",
+    {
+      className,
+      style: {
+        minHeight: "100vh",
+        display: "flex",
+        alignItems: "center",
+        justifyContent: "center",
+        background: colors.neutral.gray50,
+        ...style
+      },
+      children: result
+    }
+  );
+}
+StatusPage.displayName = "StatusPage";
+function NotFoundPage({
+  title = "404",
+  subTitle = "Sorry, the page you visited does not exist.",
+  actionLabel = "Home Page",
+  actionHref,
+  onAction,
+  extra,
+  ...rest
+}) {
+  const href = actionHref ?? (onAction || extra ? void 0 : "/");
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    StatusPage,
+    {
+      status: "404",
+      title,
+      subTitle,
+      actionLabel,
+      actionHref: href,
+      onAction,
+      extra,
+      ...rest
+    }
+  );
+}
+NotFoundPage.displayName = "NotFoundPage";
+function UnauthorizedPage({
+  title = "Unauthorized Access",
+  subTitle = "You don't have permission to access this. Please ask the site admin for access.",
+  actionLabel = "Back",
+  actionHref,
+  onAction,
+  extra,
+  ...rest
+}) {
+  const href = actionHref ?? (onAction || extra ? void 0 : "/");
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    StatusPage,
+    {
+      status: "403",
+      title,
+      subTitle,
+      actionLabel,
+      actionHref: href,
+      onAction,
+      extra,
+      ...rest
+    }
+  );
 }
+UnauthorizedPage.displayName = "UnauthorizedPage";
 
 exports.Button = Button;
+exports.Card = Card;
+exports.CloseIcon = CloseIcon;
+exports.CollapseIcon = CollapseIcon;
+exports.Dropdown = Dropdown;
+exports.Header = Header;
+exports.Link = Link;
+exports.LogoutIcon = LogoutIcon;
+exports.MenuIcon = MenuIcon;
+exports.Modal = Modal;
+exports.NotFoundPage = NotFoundPage;
+exports.SideNav = SideNav;
+exports.Skeleton = Skeleton;
+exports.StatusPage = StatusPage;
+exports.Table = Table;
+exports.Tabs = Tabs;
+exports.Tag = Tag;
 exports.ThemeProvider = ThemeProvider;
+exports.UnauthorizedPage = UnauthorizedPage;
+exports.breakpoints = breakpoints;
 exports.colors = colors;
+exports.fontSize = fontSize;
+exports.indusActionLogo = indusActionLogo;
+exports.spacing = spacing;
 exports.theme = theme;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map