@marktiderman/genesis-ui 2.9.0 → 2.10.0

package/dist/chunk-C7PQ54JI.js

@@ -0,0 +1,763 @@
+"use client";
+import { useResourcePage } from './chunk-RKPS7ERS.js';
+import { useResourceUrlState } from './chunk-DIV4BYXX.js';
+import { useViewSettings } from './chunk-OZ7ZAYCS.js';
+import { toast } from './chunk-4RAZJ6LL.js';
+import { defaultNavigate } from './chunk-WGMEVX3Y.js';
+import { useKeyboardNavigation } from './chunk-YJ6MPS6U.js';
+import { useState, useRef, useEffect, useMemo, useCallback } from 'react';
+import { useResource, useOne, useCapabilities } from '@marktiderman/genesis-core/hooks';
+
+// src/components/data/undo-toast.ts
+var DONE = {
+  create: "Created.",
+  update: "Saved.",
+  delete: "Deleted."
+};
+function showUndoToast(write) {
+  toast(DONE[write.kind], {
+    duration: write.delayMs,
+    action: {
+      label: "Undo",
+      onClick: () => {
+        void write.undo().then((undone) => {
+          if (!undone && write.strategy === "delay") {
+            toast("Already saved. It can no longer be undone.");
+          }
+        });
+      }
+    }
+  });
+}
+function showWriteErrorToast(error) {
+  toast.error(error.message || "The change could not be saved.");
+}
+function writeModeOptions(resourceOptions, mutationMode) {
+  const mode = resourceOptions?.mutationMode ?? mutationMode ?? "pessimistic";
+  return {
+    mutationMode: mode,
+    onUndoable: resourceOptions?.onUndoable ?? showUndoToast,
+    onError: resourceOptions?.onError ?? (mode === "pessimistic" ? void 0 : showWriteErrorToast)
+  };
+}
+function useResourceTableModel(props) {
+  const {
+    resource: resourceName,
+    data: dataProp,
+    total: totalProp,
+    pagination = "client",
+    clientRowLimit = 1e3,
+    title,
+    subtitle,
+    icon,
+    columns: columnsProp,
+    getKey: getKeyProp,
+    detail = "panel",
+    detailWidth = "md",
+    titleField: titleFieldProp,
+    subtitleField: subtitleFieldProp,
+    getTitle,
+    getSubtitle,
+    renderDetail: renderDetailProp,
+    detailFields,
+    statusFilter,
+    searchFields,
+    searchPlaceholder,
+    initialFilters,
+    onFiltersChange,
+    filters: filtersProp,
+    page: pageProp,
+    perPage: perPageProp,
+    onPageChange,
+    onPerPageChange,
+    onSortChange,
+    onSearchChange,
+    loading: loadingProp,
+    error: errorProp,
+    errorMessage,
+    onRetry: onRetryProp,
+    savedViews,
+    onLoadView,
+    onSaveView,
+    onDeleteView,
+    canSaveViews,
+    columnVisibility,
+    columnVisibilityKey,
+    resizableColumns,
+    resizeKey,
+    stickyHeader,
+    stickyFirstColumn,
+    pageSizeOptions,
+    onCreate,
+    onEdit,
+    onDelete,
+    can,
+    canEditItem,
+    createLabel = "New",
+    canEdit,
+    canDelete,
+    allowDelete,
+    confirmDelete,
+    onDeleted,
+    secondaryActions,
+    allowCreate,
+    allowEdit,
+    formFields,
+    renderForm: renderFormProp,
+    formMode,
+    formSteps,
+    formLayout: formLayoutProp,
+    mutationMode: mutationModeProp,
+    bulkActions,
+    renderCard: renderCardProp,
+    openOnCardClick = false,
+    renderTable: renderTableProp,
+    gridCols: gridColsProp,
+    keyboardNavigation = true,
+    capabilities,
+    toolbar,
+    emptyState,
+    emptyIcon,
+    emptyMessage,
+    emptyDescription,
+    header: headerMode = "page",
+    resourceOptions,
+    urlState: urlStateProp,
+    defaultView = "table",
+    onNavigate = defaultNavigate,
+    viewSettingsKey: viewSettingsKeyProp,
+    slots,
+    slotProps,
+    className
+  } = props;
+  const isClientMode = !!resourceName;
+  const resourceServerPaging = isClientMode && pagination === "server";
+  const url = useResourceUrlState(
+    urlStateProp ? "setSearchParams" in urlStateProp ? { searchParams: urlStateProp } : urlStateProp : void 0
+  );
+  const [urlSeed] = useState(() => {
+    if (!url) return null;
+    const sortable = !url.sort || !columnsProp ? true : columnsProp.some(
+      (col) => typeof col === "string" ? col === url.sort.field : col.key === url.sort.field && col.sortable !== false
+    );
+    return { q: url.q, sort: sortable ? url.sort : null, page: url.page };
+  });
+  const urlPeek = detail === "panel" || detail === "modal" ? url : void 0;
+  const urlSortKey = urlSeed?.sort ? `${urlSeed.sort.field}:${urlSeed.sort.order}` : "";
+  const isServerControlled = resourceServerPaging || pageProp !== void 0 || perPageProp !== void 0 || onPageChange !== void 0 || onPerPageChange !== void 0 || onSortChange !== void 0 || onSearchChange !== void 0;
+  const viewSettingsKey = viewSettingsKeyProp ?? resourceName ?? title.toLowerCase().replace(/\s+/g, "-");
+  const { settings, updateSetting } = useViewSettings(viewSettingsKey);
+  const serverSearchFields = resourceOptions?.searchFields ?? searchFields;
+  const resourceHook = useResource(
+    resourceName ?? "__noop__",
+    isClientMode ? {
+      ...resourceOptions,
+      // Client paging fetches everything it can in one request; server
+      // paging starts at the user's stored page size. An explicit
+      // `defaultPerPage` wins over both.
+      defaultPerPage: resourceOptions?.defaultPerPage ?? (resourceServerPaging ? perPageProp ?? settings.pageSize : clientRowLimit),
+      searchFields: resourceServerPaging ? serverSearchFields : resourceOptions?.searchFields,
+      // Paging, searching and sorting change the query key; keep the
+      // current page on screen while the next one loads.
+      keepPreviousData: resourceOptions?.keepPreviousData ?? resourceServerPaging,
+      // Start where the URL says, so restoring a link doesn't push a
+      // search or sort that resets the page to 1.
+      ...resourceServerPaging && urlSeed ? {
+        defaultSearch: urlSeed.q,
+        ...urlSeed.page ? { defaultPage: urlSeed.page } : {},
+        ...urlSeed.sort ? { defaultSort: urlSeed.sort } : {}
+      } : {},
+      ...writeModeOptions(resourceOptions, mutationModeProp)
+    } : { enabled: false }
+  );
+  const effectivePageSize = resourceServerPaging ? resourceHook.params.pagination?.perPage ?? settings.pageSize : perPageProp ?? settings.pageSize;
+  const displayData = isClientMode ? resourceHook.list.data?.data ?? [] : dataProp ?? [];
+  const displayTotal = isClientMode ? resourceHook.list.data?.total ?? 0 : totalProp ?? 0;
+  const isLoading = isClientMode ? resourceHook.list.isLoading : loadingProp ?? false;
+  const hasError = isClientMode ? resourceHook.list.isError : errorProp ?? false;
+  const page = useResourcePage({
+    resource: resourceName,
+    data: displayData,
+    total: displayTotal,
+    columns: columnsProp,
+    statusFilter,
+    searchFields,
+    initialFilters: initialFilters ?? (urlSeed && (urlSeed.q || urlSeed.sort) ? [
+      ...urlSeed.q ? [{ field: "__search__", operator: "contains", value: urlSeed.q }] : [],
+      ...urlSeed.sort ? [{ field: "__sort__", operator: "eq", value: urlSortKey }] : []
+    ] : void 0),
+    onFiltersChange,
+    defaultView,
+    // Each page remembers its own table/cards choice, under the same key as
+    // its density and page size — not one key shared by every data page.
+    viewKey: viewSettingsKey,
+    detail,
+    titleField: titleFieldProp,
+    subtitleField: subtitleFieldProp,
+    controlled: isServerControlled
+  });
+  const {
+    setSearch: setResourceSearch,
+    setSort: setResourceSort,
+    setFilters: setResourceFilters
+  } = resourceHook;
+  const pushedSearchRef = useRef(resourceServerPaging ? urlSeed?.q ?? "" : "");
+  const searchEffectRanRef = useRef(false);
+  useEffect(() => {
+    if (!resourceServerPaging) return;
+    const firstRun = !searchEffectRanRef.current;
+    searchEffectRanRef.current = true;
+    if (page.search === pushedSearchRef.current) return;
+    const push = () => {
+      pushedSearchRef.current = page.search;
+      setResourceSearch(page.search);
+    };
+    if (firstRun || page.search === "") {
+      push();
+      return;
+    }
+    const timer = setTimeout(push, 300);
+    return () => clearTimeout(timer);
+  }, [resourceServerPaging, page.search, setResourceSearch]);
+  const defaultSort = resourceOptions?.defaultSort;
+  const pushedSortRef = useRef(resourceServerPaging ? urlSortKey : "");
+  useEffect(() => {
+    if (!resourceServerPaging) return;
+    const key = page.sort ? `${page.sort.field}:${page.sort.order}` : "";
+    if (key === pushedSortRef.current) return;
+    pushedSortRef.current = key;
+    setResourceSort(page.sort ?? defaultSort);
+  }, [resourceServerPaging, page.sort, defaultSort, setResourceSort]);
+  const statusField = statusFilter ? typeof statusFilter === "string" ? statusFilter : statusFilter.field : void 0;
+  const defaultFilters = resourceOptions?.defaultFilters;
+  const pushedStatusRef = useRef("");
+  useEffect(() => {
+    if (!resourceServerPaging || !statusField) return;
+    const key = JSON.stringify([page.statusValue, defaultFilters ?? null]);
+    if (key === pushedStatusRef.current) return;
+    pushedStatusRef.current = key;
+    setResourceFilters([
+      ...defaultFilters ?? [],
+      ...page.statusValue.length > 0 ? [{ field: statusField, operator: "in", value: page.statusValue }] : []
+    ]);
+  }, [
+    resourceServerPaging,
+    statusField,
+    page.statusValue,
+    defaultFilters,
+    setResourceFilters
+  ]);
+  const clientTruncated = isClientMode && !resourceServerPaging && !isLoading && !hasError && displayTotal > displayData.length;
+  const warnedTruncatedRef = useRef(false);
+  useEffect(() => {
+    if (!clientTruncated || warnedTruncatedRef.current) return;
+    warnedTruncatedRef.current = true;
+    console.warn(
+      `ResourcePage: "${resourceName}" has ${displayTotal} rows but only ${displayData.length} were fetched. Pass \`pagination="server"\` to page through all of them, or raise \`clientRowLimit\` (no higher than the provider's \`maxPerPage\`, which refuses a larger page).`
+    );
+  }, [clientTruncated, resourceName, displayTotal, displayData.length]);
+  const actions = useMemo(() => {
+    if (isClientMode) {
+      return {
+        update: resourceHook.update,
+        remove: resourceHook.remove,
+        refetch: () => resourceHook.list.refetch()
+      };
+    }
+    return {
+      update: async () => {
+        throw new Error(
+          "ResourceActions.update not available in server-data mode"
+        );
+      },
+      remove: async () => {
+        throw new Error(
+          "ResourceActions.remove not available in server-data mode"
+        );
+      },
+      refetch: () => {
+      }
+    };
+  }, [
+    isClientMode,
+    resourceHook.update,
+    resourceHook.remove,
+    resourceHook.list
+  ]);
+  const keyOf = useCallback(
+    (item) => getKeyProp ? getKeyProp(item) : String(item.id ?? ""),
+    [getKeyProp]
+  );
+  const snapshotKey = page.selectedItem ? keyOf(page.selectedItem) : null;
+  const selectedKey = urlPeek ? urlPeek.detailId : snapshotKey;
+  const snapshot = page.selectedItem && snapshotKey === selectedKey ? page.selectedItem : null;
+  const rowOrSnapshot = !selectedKey ? snapshot : displayData.find((row) => keyOf(row) === selectedKey) ?? snapshot;
+  const linkedId = urlPeek && selectedKey && !rowOrSnapshot ? selectedKey : null;
+  const linked = useOne(resourceName ?? "__noop__", linkedId, {
+    enabled: isClientMode && !!linkedId
+  });
+  const selectedItem = rowOrSnapshot ?? (linkedId && linked.data ? linked.data : null);
+  const linkMissing = !!linkedId && !selectedItem && !isLoading && (isClientMode ? linked.isError : !isServerControlled);
+  const detailOpen = urlPeek ? selectedItem !== null || linkMissing : page.detailOpen;
+  const [selectedIds, setSelectedIds] = useState(/* @__PURE__ */ new Set());
+  const handleToggleSelect = useCallback((id) => {
+    setSelectedIds((prev) => {
+      const next = new Set(prev);
+      if (next.has(id)) next.delete(id);
+      else next.add(id);
+      return next;
+    });
+  }, []);
+  const handleToggleAll = useCallback(() => {
+    setSelectedIds((prev) => {
+      if (prev.size === page.data.length) return /* @__PURE__ */ new Set();
+      return new Set(page.data.map(keyOf));
+    });
+  }, [page.data, keyOf]);
+  const handleClearSelection = useCallback(() => {
+    setSelectedIds(/* @__PURE__ */ new Set());
+  }, []);
+  const [formOpen, setFormOpen] = useState(false);
+  const [formAction, setFormAction] = useState("create");
+  const [formItem, setFormItem] = useState(null);
+  const useBuiltInCreate = allowCreate && !onCreate && isClientMode;
+  const useBuiltInEdit = allowEdit && !onEdit && isClientMode;
+  const handleCreate = useCallback(() => {
+    if (useBuiltInCreate) {
+      setFormAction("create");
+      setFormItem(null);
+      setFormOpen(true);
+    } else if (onCreate) {
+      onCreate();
+    }
+  }, [useBuiltInCreate, onCreate]);
+  const allows = useCallback(
+    (action, item) => {
+      if (can && !can(action, item)) return false;
+      if (!item) return true;
+      if (canEditItem && !canEditItem(item)) return false;
+      if (action === "edit" && canEdit && !canEdit(item)) return false;
+      if (action === "delete" && canDelete && !canDelete(item)) return false;
+      return true;
+    },
+    [can, canEditItem, canEdit, canDelete]
+  );
+  const handleEdit = useCallback(
+    (item) => {
+      if (!allows("edit", item)) return;
+      if (useBuiltInEdit) {
+        setFormAction("edit");
+        setFormItem(item);
+        setFormOpen(true);
+      } else if (onEdit) {
+        onEdit(item);
+      }
+    },
+    [useBuiltInEdit, onEdit, allows]
+  );
+  const closeDetail = useCallback(() => {
+    page.setDetailOpen(false);
+    page.setSelectedItem(null);
+    urlPeek?.setDetailId(null);
+  }, [page, urlPeek]);
+  const useBuiltInDelete = !!allowDelete && !onDelete && isClientMode;
+  const deleteConfirmed = confirmDelete === void 0 ? useBuiltInDelete : !!confirmDelete;
+  const deleteCopy = typeof confirmDelete === "object" ? confirmDelete : void 0;
+  const [pendingDelete, setPendingDelete] = useState(null);
+  const [deleteOpen, setDeleteOpen] = useState(false);
+  const { remove: removeRecord } = resourceHook;
+  const { data: providerCaps } = useCapabilities(resourceName, {
+    enabled: useBuiltInDelete && deleteConfirmed
+  });
+  const deleteKind = providerCaps?.softDelete ? "recycle" : "permanent";
+  const performDelete = useCallback(
+    async (item) => {
+      if (useBuiltInDelete) {
+        await removeRecord(
+          getKeyProp ? keyOf(item) : item.id
+        );
+      } else if (onDelete) {
+        await onDelete(item);
+      }
+      closeDetail();
+      onDeleted?.(item);
+    },
+    [
+      useBuiltInDelete,
+      removeRecord,
+      getKeyProp,
+      keyOf,
+      onDelete,
+      closeDetail,
+      onDeleted
+    ]
+  );
+  const deleteHandler = !(useBuiltInDelete || onDelete) ? void 0 : deleteConfirmed ? (item) => {
+    setPendingDelete(item);
+    setDeleteOpen(true);
+  } : useBuiltInDelete ? (item) => {
+    performDelete(item).catch((err) => {
+      if (!resourceOptions?.onError) {
+        toast.error(err instanceof Error ? err.message : "The delete failed.");
+      }
+    });
+  } : (
+    // Unconfirmed `onDelete` keeps its original contract exactly:
+    // called straight from the peek, nothing closed for it.
+    (item) => {
+      const report = (err) => {
+        const error = err instanceof Error ? err : new Error(String(err));
+        if (resourceOptions?.onError) {
+          try {
+            resourceOptions.onError(error);
+            return;
+          } catch {
+          }
+        }
+        toast.error(error.message || "The delete failed.");
+      };
+      try {
+        Promise.resolve(onDelete?.(item)).catch(report);
+      } catch (err) {
+        report(err);
+      }
+    }
+  );
+  const selectedEditable = !!selectedItem && allows("edit", selectedItem);
+  const selectedDeletable = !!selectedItem && allows("delete", selectedItem);
+  const tableColumns = useMemo(() => {
+    const base = isClientMode ? page.columns.map((col) => ({
+      key: col.key,
+      header: col.header ?? col.key,
+      sortable: col.sortable ?? true,
+      hideBelow: col.hideBelow,
+      width: col.width,
+      minWidth: col.minWidth,
+      defaultVisible: col.defaultVisible,
+      editable: col.editable,
+      accessor: col.accessor,
+      render: col.render ? (item, value) => col.render(item, value, actions) : void 0
+    })) : page.tableColumns;
+    if (!isServerControlled) return base;
+    return base.map((col) => ({ ...col, sortable: false }));
+  }, [
+    isClientMode,
+    isServerControlled,
+    page.columns,
+    page.tableColumns,
+    actions
+  ]);
+  const [tableTieBreaks, setTableTieBreaks] = useState(null);
+  const pageSort = page.sort;
+  const setPageSort = page.setSort;
+  const tableSort = useMemo(() => {
+    if (!pageSort) return [];
+    const primary = { key: pageSort.field, dir: pageSort.order };
+    const rest = tableTieBreaks && tableTieBreaks.primary === `${primary.key}:${primary.dir}` ? tableTieBreaks.rest : [];
+    return [primary, ...rest].filter((s) => tableColumns.some((c) => c.key === s.key));
+  }, [pageSort, tableTieBreaks, tableColumns]);
+  const handleTableSort = useCallback(
+    (next) => {
+      const [primary, ...rest] = next;
+      setTableTieBreaks(primary ? { primary: `${primary.key}:${primary.dir}`, rest } : null);
+      setPageSort(primary ? { field: primary.key, order: primary.dir } : null);
+    },
+    [setPageSort]
+  );
+  const pagerPage = resourceServerPaging ? resourceHook.params.pagination?.page ?? 1 : pageProp;
+  const pagerPerPage = resourceServerPaging ? resourceHook.params.pagination?.perPage : perPageProp;
+  const pagerTotal = resourceServerPaging ? displayTotal : totalProp;
+  const pagerOnPageChange = resourceServerPaging ? resourceHook.setPage : onPageChange;
+  const currentPage = pagerPage ?? 1;
+  const writeUrl = url?.write;
+  useEffect(() => {
+    writeUrl?.({
+      q: page.search,
+      sort: page.sort,
+      ...resourceServerPaging ? { page: currentPage } : {}
+    });
+  }, [writeUrl, page.search, page.sort, currentPage, resourceServerPaging]);
+  const handleSearchChange = useCallback(
+    (value) => {
+      page.filterConfig.onSearchChange(value);
+      if (!isServerControlled) return;
+      onSearchChange?.(value);
+      if (currentPage !== 1 && !resourceServerPaging) onPageChange?.(1);
+    },
+    [
+      page.filterConfig,
+      isServerControlled,
+      onSearchChange,
+      onPageChange,
+      resourceServerPaging,
+      currentPage
+    ]
+  );
+  const handleSortSelect = useCallback(
+    (value) => {
+      page.filterConfig.onSortChange(value);
+      if (!isServerControlled) return;
+      const [field, order] = value.split(":");
+      onSortChange?.(
+        field && (order === "asc" || order === "desc") ? { field, order } : null
+      );
+      if (!resourceServerPaging) onPageChange?.(1);
+    },
+    [
+      page.filterConfig,
+      isServerControlled,
+      onSortChange,
+      onPageChange,
+      resourceServerPaging
+    ]
+  );
+  const handleClearFilters = useCallback(() => {
+    page.clearFilters();
+    if (!isServerControlled) return;
+    onSearchChange?.("");
+    onSortChange?.(null);
+    if (!resourceServerPaging) onPageChange?.(1);
+  }, [
+    page,
+    isServerControlled,
+    onSearchChange,
+    onSortChange,
+    onPageChange,
+    resourceServerPaging
+  ]);
+  const handleStatusChange = useCallback(
+    (values) => {
+      page.filterConfig.statusChips?.onChange(values);
+      if (!isServerControlled) return;
+      if (currentPage !== 1 && !resourceServerPaging) onPageChange?.(1);
+    },
+    [
+      page.filterConfig,
+      isServerControlled,
+      onPageChange,
+      resourceServerPaging,
+      currentPage
+    ]
+  );
+  const statusChipsConfig = useMemo(() => {
+    const base = page.filterConfig.statusChips;
+    if (!base) return void 0;
+    return { ...base, onChange: handleStatusChange };
+  }, [page.filterConfig.statusChips, handleStatusChange]);
+  const handlePageSizeChange = useCallback(
+    (size) => {
+      updateSetting("pageSize", size);
+      onPerPageChange?.(size);
+      if (resourceServerPaging) resourceHook.setPerPage(size);
+      else if (isServerControlled) onPageChange?.(1);
+    },
+    [
+      updateSetting,
+      onPerPageChange,
+      resourceServerPaging,
+      resourceHook.setPerPage,
+      isServerControlled,
+      onPageChange
+    ]
+  );
+  const missingPerPage = isServerControlled && !!pagerOnPageChange && pagerPerPage === void 0;
+  const missingTotal = isServerControlled && !!pagerOnPageChange && pagerTotal === void 0;
+  const pagerMisconfigured = missingPerPage || missingTotal;
+  const missingPagerProps = [
+    ...missingPerPage ? ["perPage"] : [],
+    ...missingTotal ? ["total"] : []
+  ];
+  const loggedMissingPerPageRef = useRef(false);
+  useEffect(() => {
+    if (!pagerMisconfigured) return;
+    if (loggedMissingPerPageRef.current) return;
+    loggedMissingPerPageRef.current = true;
+    console.error(
+      `ResourcePage: ${missingPagerProps.map((name) => `\`${name}\``).join(" and ")} ${missingPagerProps.length > 1 ? "are" : "is"} required when \`onPageChange\` is supplied.`
+    );
+  }, [pagerMisconfigured]);
+  const pagerPageSize = pagerPerPage ?? effectivePageSize;
+  const totalPages = Math.max(
+    1,
+    Math.ceil(displayTotal / Math.max(1, pagerPageSize))
+  );
+  const rangeFrom = page.data.length === 0 ? 0 : (currentPage - 1) * pagerPageSize + 1;
+  const rangeTo = rangeFrom === 0 ? 0 : rangeFrom + page.data.length - 1;
+  const { setPage: setResourcePage } = resourceHook;
+  const settledPage = !isLoading && !hasError && !resourceHook.list.isPlaceholderData;
+  useEffect(() => {
+    if (!resourceServerPaging || !settledPage) return;
+    if (currentPage > totalPages) setResourcePage(totalPages);
+  }, [resourceServerPaging, settledPage, currentPage, totalPages, setResourcePage]);
+  const titleOf = (item) => getTitle ? getTitle(item) : String(item[page.titleField] ?? "");
+  const detailTitle = selectedItem ? titleOf(selectedItem) : "";
+  const detailSubtitle = !selectedItem ? void 0 : getSubtitle ? getSubtitle(selectedItem) : page.subtitleField ? String(
+    selectedItem[page.subtitleField] ?? ""
+  ) : void 0;
+  const handleRowClick = (item) => {
+    if (detail === "route") {
+      const id = item.id;
+      if (resourceName && id) {
+        onNavigate(`/${resourceName}/${id}`);
+      }
+      return;
+    }
+    page.handleRowClick(item);
+    urlPeek?.setDetailId(keyOf(item));
+  };
+  const hasBulkSelect = !!bulkActions && bulkActions.length > 0;
+  const overlayOpen = detailOpen || formOpen || deleteOpen;
+  const keyboardNav = useKeyboardNavigation({
+    itemCount: page.data.length,
+    enabled: keyboardNavigation && page.viewMode !== "table",
+    overlayOpen,
+    onOpen: (index) => {
+      const item = page.data[index];
+      if (item) handleRowClick(item);
+    },
+    onToggleSelect: hasBulkSelect ? (index) => {
+      const item = page.data[index];
+      if (item) {
+        handleToggleSelect(keyOf(item));
+      }
+    } : void 0,
+    // Supplied only while there is an open detail to close — the hook
+    // suppresses Backspace's default whenever this is present, so leaving it
+    // wired up permanently would swallow the browser/app's Backspace on
+    // every grid/list page (including detail="none" and detail="route",
+    // which never open one). `detailOpen` is only ever true for the panel
+    // and modal modes, so it is the precise precondition here.
+    onBack: detailOpen ? closeDetail : void 0
+  });
+  return {
+    actions,
+    allows,
+    clientTruncated,
+    closeDetail,
+    currentPage,
+    deleteConfirmed,
+    deleteCopy,
+    deleteHandler,
+    deleteKind,
+    deleteOpen,
+    detailOpen,
+    detailSubtitle,
+    detailTitle,
+    displayData,
+    displayTotal,
+    effectivePageSize,
+    formAction,
+    formItem,
+    formOpen,
+    handleClearFilters,
+    handleClearSelection,
+    handleCreate,
+    handleEdit,
+    handlePageSizeChange,
+    handleRowClick,
+    handleSearchChange,
+    handleSortSelect,
+    handleTableSort,
+    handleToggleAll,
+    handleToggleSelect,
+    hasError,
+    isClientMode,
+    isLoading,
+    isServerControlled,
+    keyOf,
+    keyboardNav,
+    linkMissing,
+    linked,
+    missingPagerProps,
+    page,
+    pagerMisconfigured,
+    pagerOnPageChange,
+    pendingDelete,
+    performDelete,
+    rangeFrom,
+    rangeTo,
+    resourceHook,
+    resourceServerPaging,
+    selectedDeletable,
+    selectedEditable,
+    selectedIds,
+    selectedItem,
+    serverSearchFields,
+    setDeleteOpen,
+    setFormOpen,
+    settings,
+    statusChipsConfig,
+    tableColumns,
+    tableSort,
+    titleOf,
+    totalPages,
+    updateSetting,
+    useBuiltInCreate,
+    useBuiltInDelete,
+    useBuiltInEdit
+  };
+}
+function useResourceTable(props) {
+  const m = useResourceTableModel(props);
+  const { pendingDelete, performDelete } = m;
+  const confirm = useCallback(
+    () => pendingDelete ? performDelete(pendingDelete) : Promise.resolve(),
+    [pendingDelete, performDelete]
+  );
+  return {
+    rows: m.page.data,
+    total: m.page.total,
+    loading: m.isLoading,
+    error: m.hasError,
+    truncated: m.clientTruncated,
+    columns: m.tableColumns,
+    actions: m.actions,
+    getKey: m.keyOf,
+    getTitle: m.titleOf,
+    can: m.allows,
+    search: m.page.search,
+    setSearch: m.handleSearchChange,
+    sort: m.tableSort,
+    setSort: m.handleTableSort,
+    statusFilter: m.statusChipsConfig,
+    hasActiveFilters: m.page.hasActiveFilters,
+    clearFilters: m.handleClearFilters,
+    page: m.currentPage,
+    pageCount: m.totalPages,
+    pageSize: m.effectivePageSize,
+    setPageSize: m.handlePageSizeChange,
+    setPage: m.pagerOnPageChange,
+    rangeFrom: m.rangeFrom,
+    rangeTo: m.rangeTo,
+    selectedIds: m.selectedIds,
+    toggleSelected: m.handleToggleSelect,
+    toggleAll: m.handleToggleAll,
+    clearSelection: m.handleClearSelection,
+    openItem: m.selectedItem,
+    detailOpen: m.detailOpen,
+    openRow: m.handleRowClick,
+    closeDetail: m.closeDetail,
+    openItemMissing: m.linkMissing,
+    create: m.useBuiltInCreate || props.onCreate ? m.handleCreate : void 0,
+    edit: m.handleEdit,
+    form: {
+      open: m.formOpen,
+      setOpen: m.setFormOpen,
+      action: m.formAction,
+      item: m.formItem
+    },
+    remove: m.deleteHandler,
+    deleteConfirm: {
+      open: m.deleteOpen,
+      setOpen: m.setDeleteOpen,
+      item: pendingDelete,
+      confirm,
+      kind: m.deleteKind,
+      copy: m.deleteCopy
+    }
+  };
+}
+
+export { showUndoToast, showWriteErrorToast, useResourceTable, useResourceTableModel };
+//# sourceMappingURL=chunk-C7PQ54JI.js.map
+//# sourceMappingURL=chunk-C7PQ54JI.js.map