silver-ui 0.1.0

package/dist/chunk-R2NQNVEV.js

@@ -0,0 +1,2476 @@
+import { TagsInput } from './chunk-2XCNB2O6.js';
+import { Select } from './chunk-XQMLA75S.js';
+import { MultiSelect } from './chunk-FVIEYPDB.js';
+import { NumberInput } from './chunk-3PSQDJQH.js';
+import { Pagination } from './chunk-YLXM3CGV.js';
+import { TextInput } from './chunk-H6OY6FLC.js';
+import { EmptyState } from './chunk-Y73472IA.js';
+import { CheckboxInput } from './chunk-RCAA2CZJ.js';
+import { TimeInput } from './chunk-NOZ6U6ZJ.js';
+import { DateInput } from './chunk-IWSS5745.js';
+import { plainDateToUnixSeconds } from './chunk-QSEDH7T2.js';
+import { createStaticSource } from './chunk-IT72TF72.js';
+import { Popover } from './chunk-2QK2NZN5.js';
+import { getBrowserTimezoneID } from './chunk-OX4ZMUF4.js';
+import { Button } from './chunk-VLIQPSPM.js';
+import { Text } from './chunk-PZO5MZ46.js';
+import { mergeRefs } from './chunk-SGLIDI6R.js';
+import { Icon } from './chunk-4W7L63LH.js';
+import { cx } from './chunk-PPNETWIP.js';
+import { css } from './chunk-UHQRL4OA.js';
+import { createContext, memo, useRef, useMemo, useEffect, useCallback, useState, use, useSyncExternalStore } from 'react';
+import { jsx, Fragment, jsxs } from 'react/jsx-runtime';
+import { Temporal } from '@js-temporal/polyfill';
+import { Filter, ArrowUp, ArrowDown, ChevronsUpDown } from 'lucide-react';
+
+function TableBody({
+  children,
+  className,
+  "data-testid": dataTestId,
+  ref,
+  style
+}) {
+  return /* @__PURE__ */ jsx(
+    "tbody",
+    {
+      className,
+      "data-testid": dataTestId,
+      ref,
+      style,
+      children
+    }
+  );
+}
+TableBody.displayName = "TableBody";
+var TableContext = createContext(null);
+TableContext.displayName = "TableContext";
+function useTableContext() {
+  return use(TableContext);
+}
+var styles = {
+  base: css({
+    boxSizing: "border-box",
+    maxWidth: 0
+  }),
+  density: {
+    balanced: css({ fontSize: "md", px: "3", py: "2" }),
+    compact: css({ fontSize: "md", px: "2", py: "1" }),
+    spacious: css({ fontSize: "md", px: "4", py: "3" })
+  },
+  dividerColumns: css({
+    borderInlineEndWidth: "default",
+    borderInlineEndStyle: "solid",
+    borderInlineEndColor: "border",
+    _last: {
+      borderInlineEndWidth: 0
+    }
+  }),
+  dividerRows: css({
+    borderBottomWidth: "default",
+    borderBottomStyle: "solid",
+    borderBottomColor: "border",
+    "tbody > tr:last-child > &": {
+      borderBottomWidth: 0
+    }
+  }),
+  truncate: css({
+    overflow: "hidden",
+    textOverflow: "ellipsis",
+    whiteSpace: "nowrap"
+  }),
+  verticalAlign: {
+    bottom: css({ verticalAlign: "bottom" }),
+    middle: css({ verticalAlign: "middle" }),
+    top: css({ verticalAlign: "top" })
+  },
+  wrap: css({
+    overflow: "hidden",
+    overflowWrap: "break-word",
+    whiteSpace: "normal",
+    wordBreak: "break-word"
+  })
+};
+function TableCell({
+  children,
+  className,
+  colSpan,
+  "data-testid": dataTestId,
+  headers,
+  ref,
+  rowSpan,
+  style
+}) {
+  const context = useTableContext();
+  return /* @__PURE__ */ jsx(
+    "td",
+    {
+      className: cx(
+        "silver-table-cell",
+        styles.base,
+        context == null ? void 0 : styles.density[context.density],
+        context == null ? void 0 : styles.verticalAlign[context.verticalAlign],
+        context?.textOverflow === "truncate" ? styles.truncate : styles.wrap,
+        context?.dividers === "rows" || context?.dividers === "grid" ? styles.dividerRows : void 0,
+        context?.dividers === "columns" || context?.dividers === "grid" ? styles.dividerColumns : void 0,
+        className
+      ),
+      colSpan,
+      "data-testid": dataTestId,
+      headers,
+      ref,
+      rowSpan,
+      style,
+      children
+    }
+  );
+}
+TableCell.displayName = "TableCell";
+function TableHeader({
+  children,
+  className,
+  "data-testid": dataTestId,
+  ref,
+  style
+}) {
+  return /* @__PURE__ */ jsx(
+    "thead",
+    {
+      className,
+      "data-testid": dataTestId,
+      ref,
+      style,
+      children
+    }
+  );
+}
+TableHeader.displayName = "TableHeader";
+var styles2 = {
+  base: css({
+    boxSizing: "border-box",
+    color: "fg.muted",
+    fontWeight: "semibold",
+    maxWidth: 0,
+    overflow: "hidden",
+    textAlign: "start",
+    textOverflow: "ellipsis",
+    whiteSpace: "nowrap"
+  }),
+  density: {
+    balanced: css({ fontSize: "md", px: "3", py: "2" }),
+    compact: css({ fontSize: "md", px: "2", py: "1" }),
+    spacious: css({ fontSize: "md", px: "4", py: "3" })
+  },
+  dividerBottom: css({
+    borderBottomWidth: "default",
+    borderBottomStyle: "solid",
+    borderBottomColor: "border"
+  }),
+  dividerColumns: css({
+    borderInlineEndWidth: "default",
+    borderInlineEndStyle: "solid",
+    borderInlineEndColor: "border",
+    _last: {
+      borderInlineEndWidth: 0
+    }
+  })
+};
+function TableHeaderCell({
+  children,
+  className,
+  "data-testid": dataTestId,
+  ref,
+  scope = "col",
+  style
+}) {
+  const context = useTableContext();
+  return /* @__PURE__ */ jsx(
+    "th",
+    {
+      className: cx(
+        "silver-table-header-cell",
+        styles2.base,
+        styles2.dividerBottom,
+        context == null ? void 0 : styles2.density[context.density],
+        context?.dividers === "columns" || context?.dividers === "grid" ? styles2.dividerColumns : void 0,
+        className
+      ),
+      "data-testid": dataTestId,
+      ref,
+      scope,
+      style,
+      children
+    }
+  );
+}
+TableHeaderCell.displayName = "TableHeaderCell";
+var styles3 = {
+  base: css({
+    transitionDuration: "fast",
+    transitionProperty: "background-color",
+    transitionTimingFunction: "default"
+  }),
+  hover: css({
+    _hover: {
+      "@media (hover: hover)": {
+        bg: "bg.subtle"
+      }
+    }
+  }),
+  striped: css({
+    _even: {
+      bg: "bg.subtle"
+    }
+  }),
+  stripedHover: css({
+    _even: {
+      bg: "bg.subtle"
+    },
+    _hover: {
+      "@media (hover: hover)": {
+        bg: "bg.hover"
+      }
+    }
+  })
+};
+function TableRow({
+  children,
+  className,
+  "data-testid": dataTestId,
+  ref,
+  style
+}) {
+  const context = useTableContext();
+  const rowClassName = context == null ? void 0 : context.isStriped && context.hasHover ? styles3.stripedHover : context.isStriped ? styles3.striped : context.hasHover ? styles3.hover : void 0;
+  return /* @__PURE__ */ jsx(
+    "tr",
+    {
+      className: cx("silver-table-row", styles3.base, rowClassName, className),
+      "data-testid": dataTestId,
+      ref,
+      style,
+      children
+    }
+  );
+}
+TableRow.displayName = "TableRow";
+var DEFAULT_MIN_COLUMN_WIDTH = 120;
+function proportional(value = 1, options) {
+  return {
+    minWidth: options?.minWidth ?? DEFAULT_MIN_COLUMN_WIDTH,
+    type: "proportional",
+    value
+  };
+}
+function pixel(value) {
+  return { type: "pixel", value };
+}
+function resolveColumnWidths(columns) {
+  let totalProportion = 0;
+  let pixelTotal = 0;
+  const proportionalColumns = [];
+  for (const column of columns) {
+    const width = column.width;
+    if (width?.type === "pixel") {
+      pixelTotal += width.value;
+    } else {
+      const proportion = width?.value ?? 1;
+      const minWidth = width == null ? 0 : width.minWidth ?? DEFAULT_MIN_COLUMN_WIDTH;
+      totalProportion += proportion;
+      proportionalColumns.push({ key: column.key, minWidth, proportion });
+    }
+  }
+  let proportionalMinSpace = 0;
+  if (totalProportion > 0) {
+    for (const column of proportionalColumns) {
+      proportionalMinSpace = Math.max(
+        proportionalMinSpace,
+        column.minWidth * totalProportion / column.proportion
+      );
+    }
+  }
+  const resolved = /* @__PURE__ */ new Map();
+  for (const column of columns) {
+    const width = column.width;
+    const style = {};
+    if (width?.type === "pixel") {
+      style.minWidth = `${width.value}px`;
+      style.width = `${width.value}px`;
+    } else {
+      const proportion = width?.value ?? 1;
+      if (totalProportion > 0) {
+        style.width = `${proportion / totalProportion * 100}%`;
+      }
+      if (width != null) {
+        style.minWidth = `${width.minWidth ?? DEFAULT_MIN_COLUMN_WIDTH}px`;
+      }
+    }
+    resolved.set(column.key, { style });
+  }
+  return {
+    columns: resolved,
+    tableMinWidth: pixelTotal + proportionalMinSpace
+  };
+}
+function capitalize(value) {
+  return value.length === 0 ? value : value.charAt(0).toUpperCase() + value.slice(1);
+}
+function defaultCellRenderer(item, key) {
+  const value = item[key];
+  if (value == null) {
+    return "";
+  }
+  if (value instanceof Temporal.Instant || value instanceof Temporal.PlainDate || value instanceof Temporal.PlainDateTime || value instanceof Temporal.PlainTime || value instanceof Temporal.ZonedDateTime) {
+    return value.toString();
+  }
+  if (typeof value === "bigint" || typeof value === "boolean" || typeof value === "number" || typeof value === "string") {
+    return String(value);
+  }
+  return "";
+}
+function estimateContentLength(value) {
+  if (value == null) {
+    return 0;
+  }
+  if (typeof value === "boolean" || typeof value === "number" || typeof value === "string") {
+    return String(value).length;
+  }
+  return 0;
+}
+function longestWord(value) {
+  if (value == null || typeof value !== "boolean" && typeof value !== "number" && typeof value !== "string") {
+    return 0;
+  }
+  return String(value).split(/\s+/).reduce((max, word) => Math.max(max, word.length), 0);
+}
+function generateColumns(data) {
+  if (data.length === 0) {
+    return [];
+  }
+  const sampleRows = data.slice(0, Math.min(5, data.length));
+  return Object.keys(data[0]).map((key) => {
+    const header = capitalize(key);
+    let maxContentLength = header.length;
+    let maxWordLength = header.length;
+    for (const row of sampleRows) {
+      maxContentLength = Math.max(
+        maxContentLength,
+        estimateContentLength(row[key])
+      );
+      maxWordLength = Math.max(maxWordLength, longestWord(row[key]));
+    }
+    const proportion = maxContentLength <= 6 ? 1 : maxContentLength <= 15 ? 2 : 3;
+    const minWidth = Math.max(Math.max(header.length, maxWordLength) * 8, 60);
+    return {
+      header,
+      key,
+      width: proportional(proportion, { minWidth })
+    };
+  });
+}
+var styles4 = {
+  headerLabelRow: css({
+    display: "inline-flex",
+    alignItems: "center",
+    gap: "1",
+    minW: 0
+  }),
+  table: css({
+    w: "full",
+    borderCollapse: "collapse",
+    borderSpacing: 0,
+    tableLayout: "fixed"
+  }),
+  tableAutoLayout: css({
+    tableLayout: "auto"
+  })
+};
+var EMPTY_PLUGINS = [];
+function areArraysShallowEqual(previous, next) {
+  if (previous === next) {
+    return true;
+  }
+  if (previous.length !== next.length) {
+    return false;
+  }
+  for (let index = 0; index < previous.length; index++) {
+    if (previous[index] !== next[index]) {
+      return false;
+    }
+  }
+  return true;
+}
+function applyPlugins(plugins, getter, initial, ...args) {
+  return plugins.reduce((accumulator, plugin, index) => {
+    const transform = getter(plugin);
+    if (transform == null) {
+      return accumulator;
+    }
+    try {
+      return transform(accumulator, ...args);
+    } catch (error) {
+      console.error(`[Table] Plugin at index ${index} threw:`, error);
+      return accumulator;
+    }
+  }, initial);
+}
+function DataRowInner({
+  CellComponent,
+  RowComponent,
+  columns,
+  item,
+  plugins,
+  rowIndex,
+  rowKey,
+  textOverflow
+}) {
+  const cells = columns.map((column) => {
+    const initialHtmlProps = {};
+    if (column.align) {
+      initialHtmlProps.style = { textAlign: column.align };
+    }
+    const cellProps = applyPlugins(
+      plugins,
+      (plugin) => plugin.transformBodyCell,
+      { htmlProps: initialHtmlProps },
+      column,
+      item
+    );
+    const isDefaultRenderer = column.renderCell == null;
+    const rawContent = isDefaultRenderer ? defaultCellRenderer(item, column.key) : column.renderCell?.(item) ?? null;
+    const content = isDefaultRenderer && textOverflow === "truncate" && typeof rawContent === "string" && rawContent.length > 0 ? /* @__PURE__ */ jsx(Text, { maxLines: 1, type: "body", children: rawContent }) : rawContent;
+    return /* @__PURE__ */ jsx(
+      CellComponent,
+      {
+        ...cellProps.htmlProps,
+        className: cx(cellProps.htmlProps.className, cellProps.className),
+        children: content
+      },
+      column.key
+    );
+  });
+  const rowProps = applyPlugins(
+    plugins,
+    (plugin) => plugin.transformBodyRow,
+    {
+      children: /* @__PURE__ */ jsx(Fragment, { children: cells }),
+      htmlProps: {}
+    },
+    item,
+    rowIndex
+  );
+  return /* @__PURE__ */ jsx(
+    RowComponent,
+    {
+      ...rowProps.htmlProps,
+      className: cx(rowProps.htmlProps.className, rowProps.className),
+      ref: rowProps.ref,
+      children: rowProps.children
+    },
+    rowKey
+  );
+}
+function areRowPropsEqual(previous, next) {
+  if (previous.CellComponent !== next.CellComponent || previous.RowComponent !== next.RowComponent || previous.columns !== next.columns || previous.plugins !== next.plugins || previous.rowIndex !== next.rowIndex || previous.rowKey !== next.rowKey || previous.textOverflow !== next.textOverflow) {
+    return false;
+  }
+  if (previous.item === next.item) {
+    return true;
+  }
+  return Object.keys(next.item).every(
+    (key) => previous.item[key] === next.item[key]
+  );
+}
+var MemoizedDataRow = memo(DataRowInner, areRowPropsEqual);
+function BaseTableInner({
+  children,
+  className,
+  columns: columnsProp,
+  data,
+  "data-testid": dataTestId,
+  emptyState,
+  idKey,
+  plugins: pluginsProp,
+  ref,
+  scrollWrapper: ScrollWrapper,
+  style,
+  tableProps,
+  textOverflow = "wrap"
+}) {
+  const plugins = pluginsProp ?? EMPTY_PLUGINS;
+  const RowComponent = TableRow;
+  const CellComponent = TableCell;
+  const HeaderCellComponent = TableHeaderCell;
+  const baseColumns = columnsProp ?? (data == null ? [] : generateColumns(data));
+  const transformedColumns = applyPlugins(
+    plugins,
+    (plugin) => plugin.transformColumns,
+    baseColumns
+  );
+  const columnsRef = useRef(transformedColumns);
+  const areColumnsStable = areArraysShallowEqual(
+    columnsRef.current,
+    transformedColumns
+  );
+  if (!areColumnsStable) {
+    columnsRef.current = transformedColumns;
+  }
+  const columns = columnsRef.current;
+  const widths = resolveColumnWidths(columns);
+  const tableRenderProps = applyPlugins(
+    plugins,
+    (plugin) => plugin.transformTable,
+    {
+      htmlProps: tableProps ?? {}
+    }
+  );
+  const headerCells = columns.map((column) => {
+    const headerContent = column.header ?? column.key;
+    const initialHtmlProps = {
+      "data-column-key": column.key
+    };
+    if (column.align) {
+      initialHtmlProps.style = { textAlign: column.align };
+    }
+    const headerCellProps = applyPlugins(
+      plugins,
+      (plugin) => plugin.transformHeaderCell,
+      {
+        content: headerContent,
+        htmlProps: initialHtmlProps
+      },
+      column
+    );
+    const widthStyle = widths.columns.get(column.key)?.style ?? {};
+    const mergedStyle = {
+      ...widthStyle,
+      ...headerCellProps.htmlProps.style
+    };
+    const resolvedContent = headerCellProps.content ?? headerContent;
+    const title = typeof resolvedContent === "string" && resolvedContent.length > 0 ? resolvedContent : void 0;
+    const renderedContent = typeof resolvedContent === "string" || typeof resolvedContent === "number" ? /* @__PURE__ */ jsx(
+      Text,
+      {
+        color: "secondary",
+        maxLines: 1,
+        size: "md",
+        type: "body",
+        weight: "semibold",
+        children: resolvedContent
+      }
+    ) : resolvedContent;
+    const hasSlots = headerCellProps.before != null || headerCellProps.after != null || headerCellProps.overlay != null || headerCellProps.below != null;
+    return /* @__PURE__ */ jsx(
+      HeaderCellComponent,
+      {
+        ...headerCellProps.htmlProps,
+        className: cx(
+          headerCellProps.htmlProps.className,
+          headerCellProps.className
+        ),
+        style: mergedStyle,
+        title,
+        children: hasSlots ? /* @__PURE__ */ jsxs(Fragment, { children: [
+          headerCellProps.before,
+          headerCellProps.after == null ? renderedContent : /* @__PURE__ */ jsxs("div", { className: styles4.headerLabelRow, children: [
+            renderedContent,
+            headerCellProps.after
+          ] }),
+          headerCellProps.overlay,
+          headerCellProps.below
+        ] }) : renderedContent
+      },
+      column.key
+    );
+  });
+  const headerRowProps = applyPlugins(
+    plugins,
+    (plugin) => plugin.transformHeaderRow,
+    {
+      children: /* @__PURE__ */ jsx(Fragment, { children: headerCells }),
+      htmlProps: {}
+    }
+  );
+  const tableStyle = {
+    ...style,
+    ...tableRenderProps.htmlProps.style,
+    minWidth: widths.tableMinWidth > 0 ? `${widths.tableMinWidth}px` : void 0
+  };
+  const hasData = data != null && data.length > 0;
+  const hasColumns = columns.length > 0;
+  let tableElement = /* @__PURE__ */ jsx(
+    "table",
+    {
+      ...tableRenderProps.htmlProps,
+      className: cx(
+        "silver-base-table",
+        styles4.table,
+        children != null ? styles4.tableAutoLayout : void 0,
+        tableRenderProps.htmlProps.className,
+        tableRenderProps.className,
+        className
+      ),
+      "data-testid": dataTestId,
+      ref,
+      style: tableStyle,
+      children: children ?? /* @__PURE__ */ jsxs(Fragment, { children: [
+        hasColumns ? /* @__PURE__ */ jsx(TableHeader, { children: /* @__PURE__ */ jsx(
+          RowComponent,
+          {
+            ...headerRowProps.htmlProps,
+            className: cx(
+              headerRowProps.htmlProps.className,
+              headerRowProps.className
+            ),
+            children: headerRowProps.children
+          }
+        ) }) : null,
+        /* @__PURE__ */ jsx(TableBody, { children: hasData ? data.map((item, rowIndex) => {
+          const rowKey = idKey == null ? rowIndex : typeof idKey === "function" ? idKey(item) : String(item[idKey]);
+          return /* @__PURE__ */ jsx(
+            MemoizedDataRow,
+            {
+              CellComponent,
+              columns,
+              item,
+              plugins,
+              RowComponent,
+              rowIndex,
+              rowKey,
+              textOverflow
+            },
+            rowKey
+          );
+        }) : data != null && emptyState !== false && /* @__PURE__ */ jsx("tr", { children: /* @__PURE__ */ jsx("td", { colSpan: Math.max(columns.length, 1), children: emptyState ?? /* @__PURE__ */ jsx(EmptyState, { isCompact: true, title: "No data" }) }) }) })
+      ] })
+    }
+  );
+  if (ScrollWrapper != null) {
+    tableElement = /* @__PURE__ */ jsx(ScrollWrapper, { children: tableElement });
+  }
+  for (let index = plugins.length - 1; index >= 0; index--) {
+    const plugin = plugins[index];
+    if (plugin.transformTableContext != null) {
+      try {
+        tableElement = plugin.transformTableContext(tableElement);
+      } catch (error) {
+        console.error("[Table] Plugin threw in transformTableContext:", error);
+      }
+    }
+  }
+  return tableElement;
+}
+var BaseTable = BaseTableInner;
+BaseTable.displayName = "BaseTable";
+var CANONICAL_PLUGIN_ORDER = [
+  "columnSettings",
+  "sort",
+  "selection",
+  "filtering",
+  "columnResize",
+  "pagination"
+];
+var CANONICAL_PLUGIN_KEYS = new Set(CANONICAL_PLUGIN_ORDER);
+function orderNamedPlugins(userPlugins) {
+  const entries = Object.entries(userPlugins);
+  const pluginsByName = new Map(entries);
+  const orderedPlugins = CANONICAL_PLUGIN_ORDER.filter(
+    (key) => pluginsByName.has(key)
+  ).map((key) => pluginsByName.get(key));
+  const customPlugins = entries.filter(([key]) => !CANONICAL_PLUGIN_KEYS.has(key)).map(([, plugin]) => plugin);
+  return [...orderedPlugins, ...customPlugins];
+}
+function useBaseTablePlugins(basePlugins, userPlugins) {
+  return useMemo(() => {
+    const plugins = Array.isArray(userPlugins) ? userPlugins : orderNamedPlugins(userPlugins ?? {});
+    return [...basePlugins, ...plugins];
+  }, [basePlugins, userPlugins]);
+}
+var styles5 = {
+  scrollWrapper: css({
+    overflowX: "auto",
+    WebkitOverflowScrolling: "touch"
+  }),
+  table: css({
+    color: "fg",
+    fontFamily: "body"
+  })
+};
+function TableScrollWrapper({
+  children
+}) {
+  return /* @__PURE__ */ jsx("div", { className: styles5.scrollWrapper, children });
+}
+function buildTableStylePlugin() {
+  return {
+    transformTable(props) {
+      return {
+        ...props,
+        className: cx(props.className, styles5.table, "silver-table")
+      };
+    }
+  };
+}
+function TableInner({
+  children,
+  className,
+  columns,
+  data,
+  "data-testid": dataTestId,
+  density = "balanced",
+  dividers = "rows",
+  emptyState,
+  hasHover = false,
+  idKey,
+  isStriped = false,
+  plugins: userPlugins,
+  ref,
+  style,
+  tableProps,
+  textOverflow = "wrap",
+  verticalAlign = "middle"
+}) {
+  const tablePlugin = useMemo(() => buildTableStylePlugin(), []);
+  const basePlugins = useMemo(() => [tablePlugin], [tablePlugin]);
+  const plugins = useBaseTablePlugins(basePlugins, userPlugins);
+  const contextValue = useMemo(
+    () => ({
+      density,
+      dividers,
+      hasHover,
+      isStriped,
+      textOverflow,
+      verticalAlign
+    }),
+    [density, dividers, hasHover, isStriped, textOverflow, verticalAlign]
+  );
+  return /* @__PURE__ */ jsx(TableContext, { value: contextValue, children: /* @__PURE__ */ jsx(
+    BaseTable,
+    {
+      className,
+      columns,
+      data,
+      "data-testid": dataTestId,
+      emptyState,
+      idKey,
+      plugins,
+      ref,
+      scrollWrapper: TableScrollWrapper,
+      style,
+      tableProps,
+      textOverflow,
+      children
+    }
+  ) });
+}
+var Table = TableInner;
+Table.displayName = "Table";
+function TableFooter({
+  children,
+  className,
+  "data-testid": dataTestId,
+  ref,
+  style
+}) {
+  return /* @__PURE__ */ jsx(
+    "tfoot",
+    {
+      className,
+      "data-testid": dataTestId,
+      ref,
+      style,
+      children
+    }
+  );
+}
+TableFooter.displayName = "TableFooter";
+var KEYBOARD_STEP = 10;
+var KEYBOARD_LARGE_STEP = 50;
+var styles6 = {
+  handle: css({
+    position: "absolute",
+    insetInlineEnd: 0,
+    top: 0,
+    bottom: 0,
+    zIndex: 1,
+    w: "4",
+    cursor: "ew-resize",
+    borderWidth: 0,
+    bg: "transparent",
+    p: 0,
+    touchAction: "none",
+    userSelect: "none",
+    _after: {
+      content: '""',
+      position: "absolute",
+      insetInlineEnd: 0,
+      top: 0,
+      bottom: 0,
+      w: "2px",
+      bg: "transparent",
+      transitionDuration: "fast",
+      transitionProperty: "background-color, width",
+      transitionTimingFunction: "default"
+    },
+    _focusVisible: {
+      outlineWidth: "focus",
+      outlineStyle: "solid",
+      outlineColor: "primary",
+      outlineOffset: "focusOffset"
+    },
+    _hover: {
+      _after: {
+        bg: "primary"
+      }
+    },
+    "@media (pointer: coarse)": {
+      display: "none"
+    }
+  }),
+  headerCell: css({
+    overflow: "visible",
+    position: "relative"
+  })
+};
+function resolveColumnMinWidth(width, globalMinWidth) {
+  if (globalMinWidth != null) {
+    return globalMinWidth;
+  }
+  if (width?.type === "pixel") {
+    return width.value;
+  }
+  return width?.minWidth ?? DEFAULT_MIN_COLUMN_WIDTH;
+}
+function applyWidth(th, width) {
+  th.style.width = `${width}px`;
+  th.style.minWidth = `${width}px`;
+  th.style.maxWidth = `${width}px`;
+}
+function isProportionalColumn(width) {
+  return width == null || width.type === "proportional";
+}
+function getRTLMultiplier(element) {
+  return getComputedStyle(element).direction === "rtl" ? -1 : 1;
+}
+function computeColumnWidths(drag, delta) {
+  const widths = drag.snapshots.map((snapshot) => snapshot.initialWidth);
+  if (drag.neighborIndex != null) {
+    const neighbor = drag.snapshots[drag.neighborIndex];
+    const self = drag.snapshots[drag.resizeIndex];
+    const maxDelta = neighbor.initialWidth - neighbor.minWidth;
+    const minDelta = self.minWidth - self.initialWidth;
+    const clampedDelta = Math.max(minDelta, Math.min(delta, maxDelta));
+    widths[drag.resizeIndex] = self.initialWidth + clampedDelta;
+    widths[drag.neighborIndex] = neighbor.initialWidth - clampedDelta;
+  } else {
+    const self = drag.snapshots[drag.resizeIndex];
+    widths[drag.resizeIndex] = Math.min(
+      self.maxWidth,
+      Math.max(self.minWidth, self.initialWidth + delta)
+    );
+  }
+  const lastIndex = drag.snapshots.length - 1;
+  const isResizingLastColumnWithoutNeighbor = drag.resizeIndex === lastIndex && drag.neighborIndex == null;
+  if (lastIndex >= 0 && drag.tableWidth > 0 && !isResizingLastColumnWithoutNeighbor) {
+    const sumOthers = widths.reduce(
+      (sum, width, index) => index === lastIndex ? sum : sum + width,
+      0
+    );
+    widths[lastIndex] = Math.max(
+      drag.snapshots[lastIndex].minWidth,
+      drag.tableWidth - sumOthers
+    );
+  }
+  return widths;
+}
+function applyWidths(snapshots, widths) {
+  snapshots.forEach((snapshot, index) => {
+    applyWidth(snapshot.th, widths[index]);
+  });
+}
+function restoreSnapshotStyles(snapshots) {
+  snapshots.forEach((snapshot) => {
+    snapshot.th.style.width = snapshot.initialWidthStyle;
+    snapshot.th.style.minWidth = snapshot.initialMinWidth;
+    snapshot.th.style.maxWidth = snapshot.initialMaxWidth;
+  });
+}
+function buildUpdates(drag, widths) {
+  const updates = {};
+  const lastIndex = drag.snapshots.length - 1;
+  const isResizingLastColumnWithoutNeighbor = drag.resizeIndex === lastIndex && drag.neighborIndex == null;
+  if (isResizingLastColumnWithoutNeighbor) {
+    const snapshot = drag.snapshots[drag.resizeIndex];
+    updates[snapshot.key] = Math.round(widths[drag.resizeIndex]);
+    return updates;
+  }
+  drag.snapshots.forEach((snapshot, index) => {
+    if (index === lastIndex) {
+      return;
+    }
+    updates[snapshot.key] = Math.round(widths[index]);
+  });
+  return updates;
+}
+function ResizeHandle({
+  columnHeader,
+  columnKey,
+  configRef,
+  currentWidth,
+  maxWidth,
+  minWidth,
+  neighborKey
+}) {
+  const dragStateRef = useRef(null);
+  const pointerListenersRef = useRef(null);
+  const removePointerListeners = useCallback(() => {
+    const listeners = pointerListenersRef.current;
+    if (listeners == null) {
+      return;
+    }
+    window.removeEventListener("pointermove", listeners.move);
+    window.removeEventListener("pointerup", listeners.up);
+    window.removeEventListener("pointercancel", listeners.cancel);
+    pointerListenersRef.current = null;
+  }, []);
+  const buildDragState = useCallback(
+    (th, startX) => {
+      const headerRow = th.parentElement;
+      if (headerRow == null) {
+        return null;
+      }
+      const table = th.closest("table");
+      const tableWidth = table?.getBoundingClientRect().width ?? 0;
+      const columns = configRef.current.columns;
+      const activeHeaderIndex = Array.from(headerRow.children).indexOf(th);
+      const activeColumnIndex = columns?.findIndex((column) => column.key === columnKey) ?? -1;
+      const columnIndexOffset = activeHeaderIndex >= 0 && activeColumnIndex >= 0 ? activeHeaderIndex - activeColumnIndex : 0;
+      const columnsByKey = new Map(
+        columns?.map((column) => [column.key, column])
+      );
+      const currentWidths = configRef.current.columnWidths ?? {};
+      const snapshots = [];
+      const allHeaders = Array.from(headerRow.children).filter(
+        (child) => child instanceof HTMLTableCellElement
+      );
+      for (const [index, header] of allHeaders.entries()) {
+        const key = header.querySelector("[data-column-key]")?.getAttribute("data-column-key") ?? columns?.[index - columnIndexOffset]?.key;
+        if (key == null) {
+          continue;
+        }
+        const snapshotColumn = columnsByKey.get(key);
+        if (columns != null && snapshotColumn == null) {
+          continue;
+        }
+        if (snapshotColumn?.resizable === false) {
+          continue;
+        }
+        const renderedWidth = header.getBoundingClientRect().width;
+        const overrideWidth = Object.prototype.hasOwnProperty.call(currentWidths, key) ? currentWidths[key] : void 0;
+        snapshots.push({
+          initialMaxWidth: header.style.maxWidth,
+          initialMinWidth: header.style.minWidth,
+          initialWidth: overrideWidth ?? (renderedWidth > 0 ? renderedWidth : minWidth),
+          initialWidthStyle: header.style.width,
+          key,
+          maxWidth: configRef.current.maxWidth ?? Number.POSITIVE_INFINITY,
+          minWidth: snapshotColumn == null ? minWidth : resolveColumnMinWidth(
+            snapshotColumn.width,
+            configRef.current.minWidth
+          ),
+          th: header
+        });
+      }
+      const resizeIndex = snapshots.findIndex(
+        (snapshot) => snapshot.key === columnKey
+      );
+      if (resizeIndex < 0) {
+        return null;
+      }
+      const neighborIndex = neighborKey == null ? null : snapshots.findIndex((snapshot) => snapshot.key === neighborKey);
+      return {
+        columnKey,
+        neighborIndex: neighborIndex == null || neighborIndex < 0 ? null : neighborIndex,
+        resizeIndex,
+        snapshots,
+        startX,
+        tableWidth
+      };
+    },
+    [columnKey, configRef, minWidth, neighborKey]
+  );
+  const commitResize = useCallback(
+    (drag, delta) => {
+      const widths = computeColumnWidths(drag, delta);
+      applyWidths(drag.snapshots, widths);
+      const updates = buildUpdates(drag, widths);
+      if (Object.keys(updates).length > 0) {
+        configRef.current.onColumnResizeEnd?.(updates);
+      }
+    },
+    [configRef]
+  );
+  const handlePointerMove = useCallback(
+    (event) => {
+      const drag = dragStateRef.current;
+      if (drag == null) {
+        return;
+      }
+      const delta = (event.clientX - drag.startX) * getRTLMultiplier(drag.snapshots[drag.resizeIndex].th);
+      applyWidths(drag.snapshots, computeColumnWidths(drag, delta));
+    },
+    [dragStateRef]
+  );
+  const handlePointerUp = useCallback(
+    (event) => {
+      const drag = dragStateRef.current;
+      removePointerListeners();
+      if (drag != null) {
+        const delta = (event.clientX - drag.startX) * getRTLMultiplier(drag.snapshots[drag.resizeIndex].th);
+        commitResize(drag, delta);
+      }
+      dragStateRef.current = null;
+    },
+    [commitResize, dragStateRef, removePointerListeners]
+  );
+  const handlePointerCancel = useCallback(() => {
+    const drag = dragStateRef.current;
+    if (drag != null) {
+      restoreSnapshotStyles(drag.snapshots);
+    }
+    removePointerListeners();
+    dragStateRef.current = null;
+  }, [dragStateRef, removePointerListeners]);
+  const handlePointerDown = useCallback(
+    (event) => {
+      event.preventDefault();
+      event.stopPropagation();
+      const th = event.currentTarget.closest("th");
+      if (th == null) {
+        return;
+      }
+      const drag = buildDragState(th, event.clientX);
+      if (drag == null) {
+        return;
+      }
+      dragStateRef.current = drag;
+      applyWidths(drag.snapshots, computeColumnWidths(drag, 0));
+      pointerListenersRef.current = {
+        cancel: handlePointerCancel,
+        move: handlePointerMove,
+        up: handlePointerUp
+      };
+      window.addEventListener("pointermove", handlePointerMove);
+      window.addEventListener("pointerup", handlePointerUp);
+      window.addEventListener("pointercancel", handlePointerCancel);
+    },
+    [
+      buildDragState,
+      dragStateRef,
+      handlePointerCancel,
+      handlePointerMove,
+      handlePointerUp
+    ]
+  );
+  const handleKeyDown = useCallback(
+    (event) => {
+      if (event.key !== "ArrowLeft" && event.key !== "ArrowRight" && event.key !== "Home" && event.key !== "End") {
+        return;
+      }
+      event.preventDefault();
+      event.stopPropagation();
+      const th = event.currentTarget.closest("th");
+      if (th == null) {
+        return;
+      }
+      const drag = buildDragState(th, 0);
+      if (drag == null) {
+        return;
+      }
+      const activeSnapshot = drag.snapshots[drag.resizeIndex];
+      const step = event.shiftKey ? KEYBOARD_LARGE_STEP : KEYBOARD_STEP;
+      const delta = event.key === "Home" ? activeSnapshot.minWidth - activeSnapshot.initialWidth : event.key === "End" ? Number.isFinite(activeSnapshot.maxWidth) ? activeSnapshot.maxWidth - activeSnapshot.initialWidth : 0 : event.key === "ArrowLeft" ? -step * getRTLMultiplier(th) : step * getRTLMultiplier(th);
+      commitResize(drag, delta);
+    },
+    [buildDragState, commitResize]
+  );
+  const headerLabel = typeof columnHeader === "string" ? columnHeader : columnKey;
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      "aria-label": `Resize column ${headerLabel}`,
+      "aria-orientation": "vertical",
+      "aria-valuemax": Number.isFinite(maxWidth) ? maxWidth : void 0,
+      "aria-valuemin": minWidth,
+      "aria-valuenow": currentWidth,
+      className: styles6.handle,
+      "data-column-key": columnKey,
+      onKeyDown: handleKeyDown,
+      onPointerDown: handlePointerDown,
+      role: "separator",
+      tabIndex: 0
+    }
+  );
+}
+function useTableColumnResize(config) {
+  const configRef = useRef(config);
+  useEffect(() => {
+    configRef.current = config;
+  }, [config]);
+  const globalMinWidth = config.minWidth;
+  const maxWidth = config.maxWidth ?? Number.POSITIVE_INFINITY;
+  const columnWidths = config.columnWidths;
+  const resizableColumns = useMemo(
+    () => config.columns?.filter((column) => column.resizable !== false),
+    [config.columns]
+  );
+  return useMemo(
+    () => ({
+      transformHeaderCell(props, column) {
+        if (column.resizable === false) {
+          return props;
+        }
+        let neighborKey = null;
+        if (resizableColumns != null && isProportionalColumn(column.width)) {
+          const columnIndex = resizableColumns.findIndex(
+            (resizableColumn) => resizableColumn.key === column.key
+          );
+          const isLastResizable = columnIndex === resizableColumns.length - 1;
+          if (isLastResizable) {
+            return props;
+          }
+          if (columnIndex >= 0) {
+            neighborKey = resizableColumns[columnIndex + 1]?.key ?? null;
+          }
+        }
+        const overrideWidth = columnWidths?.[column.key];
+        const widthStyle = overrideWidth == null ? void 0 : {
+          maxWidth: `${overrideWidth}px`,
+          minWidth: `${overrideWidth}px`,
+          width: `${overrideWidth}px`
+        };
+        const effectiveMinWidth = resolveColumnMinWidth(
+          column.width,
+          globalMinWidth
+        );
+        return {
+          ...props,
+          className: styles6.headerCell,
+          htmlProps: {
+            ...props.htmlProps,
+            style: widthStyle == null ? props.htmlProps.style : { ...props.htmlProps.style, ...widthStyle }
+          },
+          overlay: /* @__PURE__ */ jsxs(Fragment, { children: [
+            props.overlay,
+            /* @__PURE__ */ jsx(
+              ResizeHandle,
+              {
+                columnHeader: column.header ?? column.key,
+                columnKey: column.key,
+                configRef,
+                currentWidth: overrideWidth,
+                maxWidth,
+                minWidth: effectiveMinWidth,
+                neighborKey
+              }
+            )
+          ] })
+        };
+      }
+    }),
+    [columnWidths, configRef, globalMinWidth, maxWidth, resizableColumns]
+  );
+}
+function useTableColumnSettings(config) {
+  return useMemo(
+    () => ({
+      transformColumns(columns) {
+        const activeSet = new Set(config.activeColumnKeys);
+        const orderMap = new Map(
+          config.activeColumnKeys.map((key, index) => [key, index])
+        );
+        return columns.filter((column) => activeSet.has(column.key)).sort(
+          (a, b) => (orderMap.get(a.key) ?? Infinity) - (orderMap.get(b.key) ?? Infinity)
+        );
+      }
+    }),
+    [config]
+  );
+}
+function useTableColumnSettingsState(config) {
+  const { activeColumnKeys, columns } = config;
+  const activeSet = useMemo(
+    () => new Set(activeColumnKeys),
+    [activeColumnKeys]
+  );
+  const alwaysVisibleSet = useMemo(
+    () => new Set(
+      columns.filter((column) => column.isAlwaysVisible).map((column) => column.key)
+    ),
+    [columns]
+  );
+  const toggleColumn = useCallback(
+    (key) => {
+      if (config.columns.some(
+        (column) => column.key === key && column.isAlwaysVisible
+      )) {
+        return;
+      }
+      const currentSet = new Set(config.activeColumnKeys);
+      config.onChangeActiveColumnKeys(
+        currentSet.has(key) ? config.activeColumnKeys.filter((columnKey) => columnKey !== key) : [...config.activeColumnKeys, key]
+      );
+    },
+    [config]
+  );
+  const getIsColumnActive = useCallback(
+    (key) => activeSet.has(key),
+    [activeSet]
+  );
+  const getIsColumnToggleable = useCallback(
+    (key) => !alwaysVisibleSet.has(key),
+    [alwaysVisibleSet]
+  );
+  const showAllColumns = useCallback(() => {
+    config.onChangeActiveColumnKeys(config.columns.map((column) => column.key));
+  }, [config]);
+  const resetToDefault = useCallback(() => {
+    config.onChangeActiveColumnKeys(
+      config.defaultColumnKeys ?? config.columns.map((column) => column.key)
+    );
+  }, [config]);
+  const setActiveColumnKeys = useCallback(
+    (keys) => {
+      const next = new Set(keys);
+      for (const column of config.columns) {
+        if (column.isAlwaysVisible) {
+          next.add(column.key);
+        }
+      }
+      config.onChangeActiveColumnKeys(Array.from(next));
+    },
+    [config]
+  );
+  return {
+    activeColumnKeys,
+    columnSettingsConfig: config,
+    getIsColumnActive,
+    getIsColumnToggleable,
+    resetToDefault,
+    setActiveColumnKeys,
+    showAllColumns,
+    toggleColumn
+  };
+}
+var FilterStoreContext = createContext(null);
+FilterStoreContext.displayName = "TableFilterStoreContext";
+var styles7 = {
+  afterPopover: css({
+    display: "inline-flex",
+    alignItems: "center",
+    flexShrink: 0
+  }),
+  inlineWrapper: css({
+    mt: "1"
+  }),
+  popoverActions: css({
+    display: "flex",
+    justifyContent: "flex-end",
+    gap: "2",
+    mt: "2"
+  }),
+  popoverActionsSpacer: css({
+    flex: 1
+  }),
+  popoverContent: css({
+    w: "60"
+  })
+};
+function useFilterStore() {
+  const store = use(FilterStoreContext);
+  if (store == null) {
+    throw new Error(
+      "useFilterStore must be used within a Table filtering plugin"
+    );
+  }
+  return store;
+}
+function resolveOperator(field, operatorKey) {
+  if (operatorKey != null) {
+    return field.operators.find((operator) => operator.key === operatorKey);
+  }
+  if (field.defaultOperator != null) {
+    return field.operators.find(
+      (operator) => operator.key === field.defaultOperator
+    );
+  }
+  return field.operators[0];
+}
+function resolveFilterConfig(filter, searchConfig) {
+  const fieldKey = typeof filter === "string" ? filter : filter.field;
+  const operatorKey = typeof filter === "string" ? void 0 : filter.operator;
+  const field = searchConfig.fields.find(
+    (candidate) => candidate.key === fieldKey
+  );
+  return field == null ? void 0 : resolveOperator(field, operatorKey)?.value;
+}
+function tableValueToFilterValue(value, operatorValue, timezoneID) {
+  switch (operatorValue.type) {
+    case "date_absolute":
+      return value instanceof Temporal.PlainDate ? {
+        type: "date_absolute",
+        unixSeconds: plainDateToUnixSeconds(value, timezoneID)
+      } : void 0;
+    case "enum":
+      return typeof value === "string" ? { type: "enum", value } : void 0;
+    case "enum_list":
+      return Array.isArray(value) ? { type: "enum_list", value } : void 0;
+    case "entity_list":
+      return Array.isArray(value) ? {
+        type: "entity_list",
+        value: value.map((id) => ({ id, label: id }))
+      } : void 0;
+    case "float":
+      return typeof value === "number" ? { type: "float", value } : void 0;
+    case "integer":
+      return typeof value === "number" ? { type: "integer", value } : void 0;
+    case "string":
+      return typeof value === "string" ? { type: "string", value } : void 0;
+    case "string_list":
+      return Array.isArray(value) ? { type: "string_list", value } : void 0;
+    case "time":
+      return typeof value === "string" ? { type: "time", value } : void 0;
+    case "custom":
+    case "date_range":
+    case "date_relative":
+    case "empty":
+    case "nested":
+      return void 0;
+  }
+}
+function toSearchFilters(filters, columns, config, timezoneID) {
+  const result = [];
+  const searchConfig = "searchConfig" in config ? config.searchConfig : config;
+  const effectiveTimezoneID = ("searchConfig" in config ? config.timezoneID : void 0) ?? timezoneID ?? getBrowserTimezoneID();
+  for (const column of columns) {
+    if (column.filter == null) {
+      continue;
+    }
+    const value = filters[column.key];
+    if (value == null) {
+      continue;
+    }
+    const fieldKey = typeof column.filter === "string" ? column.filter : column.filter.field;
+    const operatorKey = typeof column.filter === "string" ? void 0 : column.filter.operator;
+    const field = searchConfig.fields.find(
+      (candidate) => candidate.key === fieldKey
+    );
+    const operator = field == null ? void 0 : resolveOperator(field, operatorKey);
+    if (operator == null) {
+      continue;
+    }
+    const filterValue = tableValueToFilterValue(
+      value,
+      operator.value,
+      effectiveTimezoneID
+    );
+    if (filterValue != null) {
+      result.push({
+        field: fieldKey,
+        operator: operator.key,
+        value: filterValue
+      });
+    }
+  }
+  return result;
+}
+function TextFilterControl({
+  columnKey,
+  hasClear,
+  header,
+  size
+}) {
+  const store = useFilterStore();
+  const value = store.getConfig().filters[columnKey];
+  return /* @__PURE__ */ jsx(
+    TextInput,
+    {
+      hasClear,
+      isLabelHidden: true,
+      label: `Filter ${header}`,
+      onChange: (nextValue) => {
+        store.getConfig().onFilterChange(columnKey, nextValue === "" ? null : nextValue);
+      },
+      placeholder: `Filter ${header}`,
+      size,
+      value: typeof value === "string" ? value : ""
+    }
+  );
+}
+function NumberFilterControl({
+  columnKey,
+  hasClear,
+  header,
+  operatorValue,
+  size
+}) {
+  const store = useFilterStore();
+  const value = store.getConfig().filters[columnKey];
+  const sharedProps = {
+    isIntegerOnly: operatorValue.type === "integer",
+    isLabelHidden: true,
+    label: `Filter ${header}`,
+    max: operatorValue.maxValue ?? null,
+    min: operatorValue.minValue ?? null,
+    placeholder: `Filter ${header}`,
+    size,
+    step: operatorValue.type === "integer" ? 1 : null,
+    value: typeof value === "number" ? value : null
+  };
+  if (hasClear === false) {
+    return /* @__PURE__ */ jsx(
+      NumberInput,
+      {
+        ...sharedProps,
+        onChange: (nextValue) => {
+          store.getConfig().onFilterChange(columnKey, nextValue);
+        }
+      }
+    );
+  }
+  return /* @__PURE__ */ jsx(
+    NumberInput,
+    {
+      ...sharedProps,
+      hasClear: true,
+      onChange: (nextValue) => {
+        store.getConfig().onFilterChange(columnKey, nextValue);
+      }
+    }
+  );
+}
+function SelectFilterControl({
+  columnKey,
+  hasClear,
+  header,
+  operatorValue,
+  size
+}) {
+  const store = useFilterStore();
+  const value = store.getConfig().filters[columnKey];
+  return /* @__PURE__ */ jsx(
+    Select,
+    {
+      hasClear,
+      isLabelHidden: true,
+      label: `Filter ${header}`,
+      onChange: (nextValue) => {
+        store.getConfig().onFilterChange(columnKey, nextValue);
+      },
+      options: operatorValue.values.map((option) => ({
+        icon: option.icon,
+        label: option.label,
+        value: option.value
+      })),
+      placeholder: "All",
+      size,
+      value: typeof value === "string" ? value : null
+    }
+  );
+}
+function MultiSelectFilterControl({
+  columnKey,
+  hasClear,
+  header,
+  operatorValue,
+  size
+}) {
+  const store = useFilterStore();
+  const value = store.getConfig().filters[columnKey];
+  return /* @__PURE__ */ jsx(
+    MultiSelect,
+    {
+      hasClear,
+      hasSearch: false,
+      hasSelectAll: true,
+      isLabelHidden: true,
+      label: `Filter ${header}`,
+      onChange: (nextValue) => {
+        store.getConfig().onFilterChange(columnKey, nextValue.length === 0 ? null : nextValue);
+      },
+      options: operatorValue.values.map((option) => ({
+        icon: option.icon,
+        label: option.label,
+        value: option.value
+      })),
+      placeholder: "All",
+      size,
+      value: Array.isArray(value) ? value : []
+    }
+  );
+}
+function DateFilterControl({
+  columnKey,
+  hasClear,
+  header,
+  size
+}) {
+  const store = useFilterStore();
+  const value = store.getConfig().filters[columnKey];
+  return /* @__PURE__ */ jsx(
+    DateInput,
+    {
+      hasClear,
+      isLabelHidden: true,
+      label: `Filter ${header}`,
+      onChange: (nextValue) => {
+        store.getConfig().onFilterChange(columnKey, nextValue ?? null);
+      },
+      placeholder: `Filter ${header}`,
+      size,
+      value: value instanceof Temporal.PlainDate ? value : void 0
+    }
+  );
+}
+function TimeFilterControl({
+  columnKey,
+  hasClear,
+  header,
+  size
+}) {
+  const store = useFilterStore();
+  const value = store.getConfig().filters[columnKey];
+  return /* @__PURE__ */ jsx(
+    TimeInput,
+    {
+      hasClear,
+      isLabelHidden: true,
+      label: `Filter ${header}`,
+      onChange: (nextValue) => {
+        store.getConfig().onFilterChange(columnKey, nextValue?.toString() ?? null);
+      },
+      placeholder: `Filter ${header}`,
+      size,
+      value: value instanceof Temporal.PlainTime ? value : void 0
+    }
+  );
+}
+function ListFilterControl({
+  columnKey,
+  hasClear,
+  header,
+  operatorValue,
+  size
+}) {
+  const store = useFilterStore();
+  const value = store.getConfig().filters[columnKey];
+  const items = Array.isArray(value) ? value.map((id) => ({ id, label: id })) : [];
+  const source = operatorValue.searchSource ?? createStaticSource(items, { keywords: (item) => [item.id] });
+  return /* @__PURE__ */ jsx(
+    TagsInput,
+    {
+      hasClear,
+      hasCreate: operatorValue.isArbitraryStringAllowed ?? true,
+      isLabelHidden: true,
+      label: `Filter ${header}`,
+      onChange: (nextItems) => {
+        const ids = nextItems.map((item) => item.id);
+        store.getConfig().onFilterChange(columnKey, ids.length === 0 ? null : ids);
+      },
+      placeholder: `Filter ${header}`,
+      renderItem: operatorValue.type === "entity_list" ? operatorValue.renderItem : void 0,
+      searchSource: source,
+      size,
+      value: items
+    }
+  );
+}
+function getHeaderText(column) {
+  return typeof column.header === "string" ? column.header : column.key;
+}
+function FilterControl({
+  column,
+  hasClear,
+  operatorValue,
+  size
+}) {
+  const header = getHeaderText(column);
+  switch (operatorValue.type) {
+    case "date_absolute":
+      return /* @__PURE__ */ jsx(
+        DateFilterControl,
+        {
+          columnKey: column.key,
+          hasClear,
+          header,
+          size
+        }
+      );
+    case "enum":
+      return /* @__PURE__ */ jsx(
+        SelectFilterControl,
+        {
+          columnKey: column.key,
+          hasClear,
+          header,
+          operatorValue,
+          size
+        }
+      );
+    case "enum_list":
+      return /* @__PURE__ */ jsx(
+        MultiSelectFilterControl,
+        {
+          columnKey: column.key,
+          hasClear,
+          header,
+          operatorValue,
+          size
+        }
+      );
+    case "entity_list":
+    case "string_list":
+      return /* @__PURE__ */ jsx(
+        ListFilterControl,
+        {
+          columnKey: column.key,
+          hasClear,
+          header,
+          operatorValue,
+          size
+        }
+      );
+    case "float":
+    case "integer":
+      return /* @__PURE__ */ jsx(
+        NumberFilterControl,
+        {
+          columnKey: column.key,
+          hasClear,
+          header,
+          operatorValue,
+          size
+        }
+      );
+    case "string":
+      return /* @__PURE__ */ jsx(
+        TextFilterControl,
+        {
+          columnKey: column.key,
+          hasClear,
+          header,
+          size
+        }
+      );
+    case "time":
+      return /* @__PURE__ */ jsx(
+        TimeFilterControl,
+        {
+          columnKey: column.key,
+          hasClear,
+          header,
+          size
+        }
+      );
+    case "custom":
+    case "date_range":
+    case "date_relative":
+    case "empty":
+    case "nested":
+      return null;
+  }
+}
+function PopoverFilterTrigger({
+  column,
+  operatorValue
+}) {
+  const store = useFilterStore();
+  const value = store.getConfig().filters[column.key];
+  const isActive = value != null;
+  const [isOpen, setIsOpen] = useState(false);
+  const [draft, setDraft] = useState(null);
+  const handleOpenChange = useCallback(
+    (isOpenNext) => {
+      if (isOpenNext) {
+        setDraft(value ?? null);
+      }
+      setIsOpen(isOpenNext);
+    },
+    [value]
+  );
+  const handleApply = useCallback(() => {
+    store.getConfig().onFilterChange(column.key, draft);
+    setIsOpen(false);
+  }, [column.key, draft, store]);
+  const handleReset = useCallback(() => {
+    store.getConfig().onFilterChange(column.key, null);
+    setDraft(null);
+    setIsOpen(false);
+  }, [column.key, store]);
+  const draftStore = useMemo(
+    () => ({
+      getConfig() {
+        const config = store.getConfig();
+        return {
+          ...config,
+          filters: {
+            ...config.filters,
+            [column.key]: draft ?? void 0
+          },
+          onFilterChange: (_columnKey, nextValue) => {
+            setDraft(nextValue);
+          }
+        };
+      }
+    }),
+    [column.key, draft, store]
+  );
+  return /* @__PURE__ */ jsx(
+    Popover,
+    {
+      content: /* @__PURE__ */ jsx(FilterStoreContext, { value: draftStore, children: /* @__PURE__ */ jsxs("div", { className: styles7.popoverContent, children: [
+        /* @__PURE__ */ jsx(
+          FilterControl,
+          {
+            column,
+            hasClear: false,
+            operatorValue,
+            size: "sm"
+          }
+        ),
+        /* @__PURE__ */ jsxs("div", { className: styles7.popoverActions, children: [
+          /* @__PURE__ */ jsx(
+            Button,
+            {
+              label: "Reset",
+              onClick: handleReset,
+              size: "sm",
+              variant: "ghost"
+            }
+          ),
+          /* @__PURE__ */ jsx("div", { className: styles7.popoverActionsSpacer }),
+          /* @__PURE__ */ jsx(
+            Button,
+            {
+              label: "Apply",
+              onClick: handleApply,
+              size: "sm",
+              variant: "primary"
+            }
+          )
+        ] })
+      ] }) }),
+      isOpen,
+      label: `Filter ${getHeaderText(column)}`,
+      onOpenChange: handleOpenChange,
+      padding: "3",
+      placement: "below",
+      children: /* @__PURE__ */ jsx(
+        Button,
+        {
+          icon: Filter,
+          isIconOnly: true,
+          label: `Filter ${getHeaderText(column)}`,
+          size: "sm",
+          variant: isActive ? "primary" : "ghost"
+        }
+      )
+    }
+  );
+}
+function useTableFiltering(config) {
+  const { variant = "popover" } = config;
+  const store = useMemo(
+    () => ({
+      getConfig: () => config
+    }),
+    [config]
+  );
+  return useMemo(
+    () => ({
+      transformColumns: variant === "inline" ? (columns) => columns.map((column) => {
+        if (column.filter != null && column.width == null) {
+          return { ...column, width: proportional(1) };
+        }
+        return column;
+      }) : void 0,
+      transformHeaderCell(props, column) {
+        if (column.filter == null) {
+          if (variant === "inline") {
+            return {
+              ...props,
+              htmlProps: {
+                ...props.htmlProps,
+                style: {
+                  ...props.htmlProps.style,
+                  verticalAlign: "bottom"
+                }
+              }
+            };
+          }
+          return props;
+        }
+        const operatorValue = resolveFilterConfig(
+          column.filter,
+          config.searchConfig
+        );
+        if (operatorValue == null) {
+          return props;
+        }
+        if (variant === "popover") {
+          return {
+            ...props,
+            after: /* @__PURE__ */ jsx("span", { className: styles7.afterPopover, children: /* @__PURE__ */ jsx(
+              PopoverFilterTrigger,
+              {
+                column,
+                operatorValue
+              }
+            ) })
+          };
+        }
+        return {
+          ...props,
+          below: /* @__PURE__ */ jsxs(Fragment, { children: [
+            props.below,
+            /* @__PURE__ */ jsx("div", { className: styles7.inlineWrapper, children: /* @__PURE__ */ jsx(
+              FilterControl,
+              {
+                column,
+                hasClear: true,
+                operatorValue,
+                size: "sm"
+              }
+            ) })
+          ] })
+        };
+      },
+      transformTableContext(children) {
+        return /* @__PURE__ */ jsx(FilterStoreContext, { value: store, children });
+      }
+    }),
+    [config.searchConfig, store, variant]
+  );
+}
+function useTableFilterState(initialState) {
+  const [filters, setFilters] = useState(initialState ?? {});
+  const onFilterChange = useCallback(
+    (key, value) => {
+      setFilters((previous) => {
+        if (value == null) {
+          const { [key]: _removed, ...next } = previous;
+          return next;
+        }
+        return { ...previous, [key]: value };
+      });
+    },
+    []
+  );
+  const clearAll = useCallback(() => setFilters({}), []);
+  return { clearAll, filters, onFilterChange };
+}
+
+// src/components/Table/plugins/pagination/paginateData.ts
+function paginateData(data, { page, pageSize }) {
+  const safePage = Math.max(1, page);
+  const safePageSize = Math.max(1, pageSize);
+  const start = (safePage - 1) * safePageSize;
+  return data.slice(start, start + safePageSize);
+}
+var styles8 = {
+  align: {
+    center: css({ justifyContent: "center" }),
+    end: css({ justifyContent: "flex-end" }),
+    start: css({ justifyContent: "flex-start" })
+  },
+  below: css({ mt: "2" }),
+  root: css({ display: "flex" }),
+  above: css({ mb: "2" })
+};
+function useTablePagination({
+  align = "center",
+  hasMore,
+  label = "Table pagination",
+  onPageChange,
+  page,
+  pageSize = 10,
+  position = "below",
+  size = "md",
+  totalItems,
+  totalPages,
+  variant = "pages"
+}) {
+  const computedTotalPages = totalPages ?? (totalItems == null ? void 0 : Math.ceil(totalItems / pageSize));
+  const paginationProps = useMemo(
+    () => ({
+      hasMore,
+      label,
+      onChange: onPageChange,
+      page,
+      pageSize,
+      size,
+      ...totalItems != null ? { totalItems } : computedTotalPages != null ? { totalPages: computedTotalPages } : {},
+      variant
+    }),
+    [
+      computedTotalPages,
+      hasMore,
+      label,
+      onPageChange,
+      page,
+      pageSize,
+      size,
+      totalItems,
+      variant
+    ]
+  );
+  return useMemo(
+    () => ({
+      transformTableContext(children) {
+        const current = { align, paginationProps, position };
+        if (current.position === "none") {
+          return children;
+        }
+        if (computedTotalPages === 1 && hasMore !== true) {
+          return children;
+        }
+        const makePagination = (side) => /* @__PURE__ */ jsx(
+          "div",
+          {
+            className: `${styles8.root} ${styles8.align[current.align]} ${side === "above" ? styles8.above : styles8.below}`,
+            children: /* @__PURE__ */ jsx(Pagination, { ...current.paginationProps })
+          }
+        );
+        return /* @__PURE__ */ jsxs(Fragment, { children: [
+          (current.position === "above" || current.position === "both") && makePagination("above"),
+          children,
+          (current.position === "below" || current.position === "both") && makePagination("below")
+        ] });
+      }
+    }),
+    [align, computedTotalPages, hasMore, paginationProps, position]
+  );
+}
+var styles9 = {
+  center: css({
+    display: "flex",
+    alignItems: "center",
+    justifyContent: "center"
+  }),
+  selectedRow: css({
+    bg: "bg.selected"
+  })
+};
+var SELECTION_COLUMN_KEY = "__table_selection";
+function createSelectionStore(configRef) {
+  const listeners = /* @__PURE__ */ new Set();
+  return {
+    getConfig: () => configRef.current,
+    notify: () => {
+      for (const listener of listeners) {
+        listener();
+      }
+    },
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    }
+  };
+}
+function applyRowSelectionStyle(element, isSelected) {
+  element.classList.toggle(styles9.selectedRow, isSelected);
+  if (isSelected) {
+    element.setAttribute("aria-selected", "true");
+  } else {
+    element.removeAttribute("aria-selected");
+  }
+}
+var ITEM_SELECTED = 1;
+var ITEM_SELECTABLE = 2;
+var ITEM_ENABLED = 4;
+function getItemSelectionSnapshot(config, item) {
+  const isSelected = config.getIsItemSelected(item);
+  const isSelectable = config.getIsItemSelectable?.(item) ?? true;
+  const isEnabled = config.getIsItemEnabled?.(item) ?? true;
+  return (isSelected ? ITEM_SELECTED : 0) | (isSelectable ? ITEM_SELECTABLE : 0) | (isEnabled ? ITEM_ENABLED : 0);
+}
+var SELECT_NONE = 0;
+var SELECT_INDETERMINATE = 1;
+var SELECT_ALL = 2;
+var SelectionStoreContext = createContext(null);
+SelectionStoreContext.displayName = "TableSelectionStoreContext";
+function SelectAllCheckbox() {
+  const store = use(SelectionStoreContext);
+  if (store == null) {
+    return null;
+  }
+  return /* @__PURE__ */ jsx(SelectAllCheckboxInner, { store });
+}
+function SelectAllCheckboxInner({
+  store
+}) {
+  const getSnapshot = useCallback(() => {
+    const config = store.getConfig();
+    if (config.getIsAllSelected()) {
+      return SELECT_ALL;
+    }
+    return config.getIsIndeterminate?.() === true ? SELECT_INDETERMINATE : SELECT_NONE;
+  }, [store]);
+  const state = useSyncExternalStore(store.subscribe, getSnapshot, getSnapshot);
+  const isAllSelected = state === SELECT_ALL;
+  return /* @__PURE__ */ jsx(
+    CheckboxInput,
+    {
+      isLabelHidden: true,
+      label: "Select all rows",
+      onChange: () => {
+        store.getConfig().onSelectAll({
+          isAllSelected: !isAllSelected
+        });
+      },
+      size: "sm",
+      value: isAllSelected ? true : state === SELECT_INDETERMINATE ? "indeterminate" : false
+    }
+  );
+}
+function SelectionCellContent({
+  item
+}) {
+  const store = use(SelectionStoreContext);
+  if (store == null) {
+    return null;
+  }
+  return /* @__PURE__ */ jsx(SelectionCellContentInner, { item, store });
+}
+function SelectionCellContentInner({
+  item,
+  store
+}) {
+  const getSnapshot = useCallback(
+    () => getItemSelectionSnapshot(store.getConfig(), item),
+    [item, store]
+  );
+  const state = useSyncExternalStore(store.subscribe, getSnapshot, getSnapshot);
+  const isSelected = (state & ITEM_SELECTED) !== 0;
+  const isSelectable = (state & ITEM_SELECTABLE) !== 0;
+  const isEnabled = (state & ITEM_ENABLED) !== 0;
+  if (!isSelectable) {
+    return null;
+  }
+  return /* @__PURE__ */ jsx(
+    CheckboxInput,
+    {
+      isDisabled: !isEnabled,
+      isLabelHidden: true,
+      label: "Select row",
+      onChange: () => {
+        store.getConfig().onSelectItem({ isSelected: !isSelected, item });
+      },
+      size: "sm",
+      value: isSelected
+    }
+  );
+}
+function useTableSelection(config) {
+  const configRef = useRef(config);
+  configRef.current = config;
+  const storeRef = useRef(null);
+  storeRef.current ?? (storeRef.current = createSelectionStore(configRef));
+  const store = storeRef.current;
+  useEffect(() => {
+    store.notify();
+  });
+  const selectionColumn = useMemo(
+    () => ({
+      header: /* @__PURE__ */ jsx("div", { className: styles9.center, children: /* @__PURE__ */ jsx(SelectAllCheckbox, {}) }),
+      key: SELECTION_COLUMN_KEY,
+      renderCell: (item) => /* @__PURE__ */ jsx("div", { className: styles9.center, children: /* @__PURE__ */ jsx(SelectionCellContent, { item }) }),
+      resizable: false,
+      width: pixel(36)
+    }),
+    []
+  );
+  return useMemo(
+    () => ({
+      transformTableContext(children) {
+        return /* @__PURE__ */ jsx(
+          SelectionStoreContext,
+          {
+            value: store,
+            children
+          }
+        );
+      },
+      transformBodyRow(props, item) {
+        let unsubscribe = null;
+        const selectionRef = (element) => {
+          unsubscribe?.();
+          unsubscribe = null;
+          if (element == null) {
+            return;
+          }
+          applyRowSelectionStyle(
+            element,
+            store.getConfig().getIsItemSelected(item)
+          );
+          unsubscribe = store.subscribe(() => {
+            if (!element.isConnected) {
+              unsubscribe?.();
+              unsubscribe = null;
+              return;
+            }
+            applyRowSelectionStyle(
+              element,
+              store.getConfig().getIsItemSelected(item)
+            );
+          });
+        };
+        return {
+          ...props,
+          ref: props.ref == null ? selectionRef : mergeRefs(props.ref, selectionRef)
+        };
+      },
+      transformColumns(columns) {
+        return [selectionColumn, ...columns];
+      }
+    }),
+    [selectionColumn, store]
+  );
+}
+var stableTrue = () => true;
+function useTableSelectionState({
+  data,
+  getIsItemEnabled = stableTrue,
+  getIsItemSelectable = stableTrue,
+  idKey,
+  selectedKeys,
+  setSelectedKeys
+}) {
+  const getId = useCallback(
+    (item) => typeof idKey === "function" ? idKey(item) : String(item[idKey]),
+    [idKey]
+  );
+  const getIsActionable = useCallback(
+    (item) => getIsItemSelectable(item) && getIsItemEnabled(item),
+    [getIsItemEnabled, getIsItemSelectable]
+  );
+  const actionableIDs = useMemo(
+    () => new Set(data.filter(getIsActionable).map(getId)),
+    [data, getId, getIsActionable]
+  );
+  const frozenSelectedIDs = useMemo(() => {
+    const frozen = /* @__PURE__ */ new Set();
+    for (const id of selectedKeys) {
+      if (!actionableIDs.has(id)) {
+        frozen.add(id);
+      }
+    }
+    return frozen;
+  }, [actionableIDs, selectedKeys]);
+  const allSelectableIDs = useMemo(
+    () => /* @__PURE__ */ new Set([...selectedKeys, ...actionableIDs]),
+    [actionableIDs, selectedKeys]
+  );
+  const onSelectAll = useCallback(
+    ({ isAllSelected }) => {
+      setSelectedKeys(isAllSelected ? allSelectableIDs : frozenSelectedIDs);
+    },
+    [allSelectableIDs, frozenSelectedIDs, setSelectedKeys]
+  );
+  const onSelectItem = useCallback(
+    ({ isSelected, item }) => {
+      setSelectedKeys((previous) => {
+        const next = new Set(previous);
+        const id = getId(item);
+        if (isSelected) {
+          next.add(id);
+        } else {
+          next.delete(id);
+        }
+        return next;
+      });
+    },
+    [getId, setSelectedKeys]
+  );
+  const getIsAllSelected = useCallback(
+    () => allSelectableIDs.size > 0 && allSelectableIDs.size === selectedKeys.size,
+    [allSelectableIDs, selectedKeys]
+  );
+  const getIsIndeterminate = useCallback(() => {
+    const selectedActionableCount = data.filter(
+      (item) => getIsActionable(item) && selectedKeys.has(getId(item))
+    ).length;
+    return selectedActionableCount > 0 && selectedActionableCount < actionableIDs.size;
+  }, [actionableIDs.size, data, getId, getIsActionable, selectedKeys]);
+  const selectionConfig = useMemo(
+    () => ({
+      getIsAllSelected,
+      getIsIndeterminate,
+      getIsItemEnabled,
+      getIsItemSelectable,
+      getIsItemSelected: (item) => selectedKeys.has(getId(item)),
+      onSelectAll,
+      onSelectItem
+    }),
+    [
+      getId,
+      getIsAllSelected,
+      getIsIndeterminate,
+      getIsItemEnabled,
+      getIsItemSelectable,
+      onSelectAll,
+      onSelectItem,
+      selectedKeys
+    ]
+  );
+  return { selectionConfig };
+}
+var styles10 = {
+  button: css({
+    display: "flex",
+    alignItems: "center",
+    gap: "1",
+    w: "full",
+    h: "full",
+    p: 0,
+    m: 0,
+    borderWidth: 0,
+    borderRadius: "sm",
+    bg: "transparent",
+    color: "inherit",
+    cursor: "pointer",
+    font: "inherit",
+    textAlign: "inherit",
+    _focusVisible: {
+      outlineWidth: "focus",
+      outlineStyle: "solid",
+      outlineColor: "primary",
+      outlineOffset: "focusOffset"
+    },
+    '&:is(:hover, [data-hover]) [data-table-sort-icon-state="inactive"], &:is(:focus-visible, [data-focus-visible]) [data-table-sort-icon-state="inactive"]': {
+      opacity: 1
+    }
+  }),
+  icon: css({
+    display: "inline-flex",
+    flexShrink: 0,
+    color: "fg.muted"
+  }),
+  iconInactive: css({
+    opacity: 0.35
+  }),
+  iconActive: css({
+    color: "primary"
+  }),
+  label: css({
+    minW: 0,
+    overflow: "hidden",
+    textOverflow: "ellipsis"
+  }),
+  rank: css({
+    color: "primary",
+    fontSize: "2xs",
+    lineHeight: 1
+  })
+};
+function resolveSortKey(column) {
+  if (!column.sortable) {
+    return null;
+  }
+  return column.sortable === true ? column.key : column.sortable.sortKey ?? column.key;
+}
+function getHeaderLabel(column) {
+  return typeof column.header === "string" ? column.header : column.key;
+}
+function getNextDirection(current, hasUnsortedState) {
+  if (current == null) {
+    return "ascending";
+  }
+  if (current === "ascending") {
+    return "descending";
+  }
+  return hasUnsortedState ? null : "ascending";
+}
+function SortHeaderButton({
+  children,
+  column,
+  config
+}) {
+  const sortKey = resolveSortKey(column) ?? "";
+  const entryIndex = config.sort.findIndex((entry2) => entry2.sortKey === sortKey);
+  const entry = entryIndex >= 0 ? config.sort[entryIndex] : null;
+  const direction = entry?.direction ?? null;
+  const rank = config.isMultiSortEnabled === true && config.sort.length > 1 && entryIndex >= 0 ? entryIndex + 1 : null;
+  const SortIcon = direction === "ascending" ? ArrowUp : direction === "descending" ? ArrowDown : ChevronsUpDown;
+  const label = getHeaderLabel(column);
+  const ariaLabel = direction == null ? `Sort by ${label}` : `Sort by ${label}, sorted ${direction}${rank == null ? "" : `, priority ${rank} of ${config.sort.length}`}`;
+  const handleClick = (event) => {
+    const nextConfig = config;
+    const isMultiSort = event.shiftKey && nextConfig.isMultiSortEnabled === true;
+    const allowUnsorted = nextConfig.hasUnsortedState ?? true;
+    if (isMultiSort) {
+      const index = nextConfig.sort.findIndex((sort) => sort.sortKey === sortKey);
+      if (index >= 0) {
+        const nextDirection2 = getNextDirection(
+          nextConfig.sort[index].direction,
+          allowUnsorted
+        );
+        const nextSort = [...nextConfig.sort];
+        if (nextDirection2 == null) {
+          nextSort.splice(index, 1);
+        } else {
+          nextSort[index] = { ...nextSort[index], direction: nextDirection2 };
+        }
+        nextConfig.onSortChange(nextSort);
+      } else {
+        nextConfig.onSortChange([
+          ...nextConfig.sort,
+          { direction: "ascending", sortKey }
+        ]);
+      }
+      return;
+    }
+    const currentEntry = nextConfig.sort.find((sort) => sort.sortKey === sortKey);
+    const nextDirection = getNextDirection(
+      currentEntry?.direction ?? null,
+      allowUnsorted
+    );
+    nextConfig.onSortChange(
+      nextDirection == null ? [] : [{ direction: nextDirection, sortKey }]
+    );
+  };
+  return /* @__PURE__ */ jsxs(
+    "button",
+    {
+      "aria-label": ariaLabel,
+      className: styles10.button,
+      onClick: handleClick,
+      type: "button",
+      children: [
+        /* @__PURE__ */ jsx("span", { className: styles10.label, children }),
+        /* @__PURE__ */ jsx(
+          "span",
+          {
+            className: `${styles10.icon} ${direction == null ? styles10.iconInactive : styles10.iconActive}`,
+            "data-table-sort-icon-state": direction == null ? "inactive" : "active",
+            "data-testid": `table-sort-icon-${sortKey}`,
+            children: /* @__PURE__ */ jsx(Icon, { icon: SortIcon, size: "sm" })
+          }
+        ),
+        rank == null ? null : /* @__PURE__ */ jsx("span", { "aria-hidden": "true", className: styles10.rank, children: rank })
+      ]
+    }
+  );
+}
+function useTableSortable(config) {
+  const sortableConfig = config;
+  return useMemo(
+    () => ({
+      transformHeaderCell(props, column) {
+        const sortKey = resolveSortKey(column);
+        if (sortKey == null) {
+          return props;
+        }
+        const entry = sortableConfig.sort.find(
+          (sort) => sort.sortKey === sortKey
+        );
+        return {
+          ...props,
+          content: /* @__PURE__ */ jsx(SortHeaderButton, { column, config: sortableConfig, children: props.content }),
+          htmlProps: {
+            ...props.htmlProps,
+            ...entry == null ? {} : { "aria-sort": entry.direction }
+          }
+        };
+      }
+    }),
+    [sortableConfig]
+  );
+}
+function stringifySortable(value) {
+  if (value instanceof Temporal.Instant || value instanceof Temporal.PlainDate || value instanceof Temporal.PlainDateTime || value instanceof Temporal.PlainTime || value instanceof Temporal.ZonedDateTime) {
+    return value.toString();
+  }
+  if (typeof value === "bigint" || typeof value === "boolean" || typeof value === "number" || typeof value === "string") {
+    return String(value);
+  }
+  return "";
+}
+function defaultCompare(a, b, sortKey) {
+  const left = a[sortKey];
+  const right = b[sortKey];
+  if (left == null && right == null) {
+    return 0;
+  }
+  if (left == null) {
+    return 1;
+  }
+  if (right == null) {
+    return -1;
+  }
+  if (typeof left === "number" && typeof right === "number") {
+    return left - right;
+  }
+  return stringifySortable(left).localeCompare(
+    stringifySortable(right),
+    void 0,
+    {
+      numeric: true
+    }
+  );
+}
+function useTableSortableState({
+  hasUnsortedState,
+  comparators,
+  data,
+  defaultSort = [],
+  isMultiSortEnabled,
+  onSortChange: controlledOnSortChange,
+  sort: controlledSort
+}) {
+  const [uncontrolledSort, setUncontrolledSort] = useState(defaultSort);
+  const sort = controlledSort ?? uncontrolledSort;
+  const onSortChange = useCallback(
+    (nextSort) => {
+      if (controlledSort == null) {
+        setUncontrolledSort(nextSort);
+      }
+      controlledOnSortChange?.(nextSort);
+    },
+    [controlledOnSortChange, controlledSort]
+  );
+  const applySort = useCallback(
+    (items) => {
+      if (sort.length === 0) {
+        return items;
+      }
+      return [...items].sort((a, b) => {
+        for (const entry of sort) {
+          const customCompare = comparators?.[entry.sortKey];
+          const result = customCompare == null ? defaultCompare(a, b, entry.sortKey) : customCompare(a, b);
+          if (result !== 0) {
+            return entry.direction === "ascending" ? result : -result;
+          }
+        }
+        return 0;
+      });
+    },
+    [comparators, sort]
+  );
+  const sortedData = useMemo(() => applySort(data), [applySort, data]);
+  const sortConfig = useMemo(
+    () => ({
+      hasUnsortedState,
+      isMultiSortEnabled,
+      onSortChange,
+      sort
+    }),
+    [hasUnsortedState, isMultiSortEnabled, onSortChange, sort]
+  );
+  return { applySort, sort, sortConfig, sortedData };
+}
+
+export { BaseTable, DEFAULT_MIN_COLUMN_WIDTH, Table, TableBody, TableCell, TableFooter, TableHeader, TableHeaderCell, TableRow, capitalize, defaultCellRenderer, generateColumns, paginateData, pixel, proportional, resolveColumnWidths, toSearchFilters, useBaseTablePlugins, useTableColumnResize, useTableColumnSettings, useTableColumnSettingsState, useTableFilterState, useTableFiltering, useTablePagination, useTableSelection, useTableSelectionState, useTableSortable, useTableSortableState };
+//# sourceMappingURL=chunk-R2NQNVEV.js.map
+//# sourceMappingURL=chunk-R2NQNVEV.js.map