@12-apps/ui 6.13.0 → 6.13.1

package/dist/chunk-QEPGWTJT.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/components/data-display/DataViews/data-views-types.ts"],"sourcesContent":["import type { GridColumn, GridSort } from \"../DataGrid\";\nimport type { DropdownMenuItem } from \"../../navigation/DropdownMenu\";\n// A re-export does not bring the name into local scope, and the state/query\n// types below are written in terms of it.\nimport type { RangeValue } from \"./data-views-range-types\";\n\n/**\n * Shared types for the reusable admin \"DataViews\" table (FUT-88): a filter bar\n * (search-across-all + typed multi-select pills + column visibility) whose full\n * state — filters + sort + visible columns — a saved view (FUT-89) can capture\n * and restore. Each table declares its own columns + filter fields.\n */\n\n/**\n * A single, reusable row action. ONE definition drives BOTH the per-row \"⋮\"\n * kebab menu and the bulk-actions menu (tabwoah model): `onSelect` receives the\n * affected rows — `[row]` from a kebab, the whole selection from the bulk menu.\n * Single-item-only actions (e.g. \"Editar\") set `bulk: false` so they never\n * appear in the bulk menu.\n */\nexport interface RowAction<T extends Record<string, unknown>> {\n  /** Stable id (also the `data-testid` suffix). */\n  id: string;\n  /** Menu label. In the kebab, `rowLabel` overrides it per row when provided. */\n  label: string;\n  /** Menu-item colour (e.g. `\"error\"` for destructive). */\n  color?: DropdownMenuItem[\"color\"];\n  /**\n   * Runs on the affected rows: `[row]` from the kebab, all selected from bulk.\n   * May be async — the bulk menu awaits it and only clears the selection once it\n   * settles (keeping the selection on failure so the user can retry).\n   */\n  onSelect: (rows: T[]) => void | Promise<void>;\n  /** Include in the bulk menu (2+ selected). Defaults to `true`. */\n  bulk?: boolean;\n  /** Include in the per-row kebab. Defaults to `true`. */\n  row?: boolean;\n  /** Per-row kebab label (e.g. `row.active ? \"Inativar\" : \"Ativar\"`). */\n  rowLabel?: (row: T) => string;\n  /**\n   * Per-row applicability (e.g. state-machine guards). `false` hides the\n   * kebab item for that row; in bulk the action runs only on the passing\n   * rows and is dropped when none pass. Defaults to applicable.\n   */\n  isVisible?: (row: T) => boolean;\n}\n\n/** Selection state handed to a card renderer so it can drive its own checkbox. */\nexport interface DataViewCardSelection {\n  selected: boolean;\n  onToggleSelect: () => void;\n  /**\n   * Card SIZE multiplier from the toolbar zoom slider. The grid sizes the card's\n   * width to `base × scale`; a card passes this to {@link BaseCard} `scale` so its\n   * padding + typography grow by the same factor — the whole card scales together\n   * (scale 2 → ~2× size). The proportion (aspect ratio) stays constant.\n   */\n  scale: number;\n}\n\n/**\n * The fixed proportions a {@link BaseCard} tile can take. The tile keeps this\n * ratio and grows in BOTH width and height as the zoom slider widens its grid\n * track, so a grid of cards stays visually uniform.\n */\nexport type CardAspectRatio = \"1:1\" | \"4:3\" | \"16:9\" | \"9:16\" | \"3:4\" | \"3:1\";\n\n/** Numeric width/height factor for each {@link CardAspectRatio} (CSS `aspect-ratio`). */\nexport const CARD_ASPECT_RATIOS: Record<CardAspectRatio, number> = {\n  \"1:1\": 1,\n  \"4:3\": 4 / 3,\n  \"16:9\": 16 / 9,\n  \"9:16\": 9 / 16,\n  \"3:4\": 3 / 4,\n  /**\n   * The BANNER tile: too short for media, sized for two lines of text.\n   *\n   * Every other ratio here is picture-shaped, because they were added for cards\n   * built around a thumbnail. A card whose subject is a NAME and a NUMBER — a\n   * cart, an order, anything triaged rather than browsed — spends most of a 4:3\n   * tile on an icon that repeats down the whole grid and says nothing.\n   */\n  \"3:1\": 3,\n};\n\n/** One selectable value inside a filter pill. */\nexport interface FilterOption {\n  value: string;\n  label: string;\n  /**\n   * Parent option's `value`, for a hierarchical field (`control: \"category\"`).\n   * Ignored by the flat controls, so one option list serves both.\n   */\n  parentId?: string | null;\n}\n\n/** A typed, multi-select filter pill's configuration for a table. */\nexport interface FilterFieldConfig<T extends Record<string, unknown>> {\n  /** Stable id; also the default row key when no `accessor` is given. */\n  id: string;\n  label: string;\n  options: FilterOption[];\n  /**\n   * How the field renders in the filter panel. `checkboxes` (default) is best for\n   * a few fixed options; `multiselect` is a compact dropdown for long option\n   * lists; `category` is the hierarchical picker, for an option set that nests\n   * via {@link FilterOption.parentId} — it renders parents as headings and\n   * their children as the selectable rows, rather than flattening the tree into\n   * one indistinguishable list.\n   */\n  control?: \"checkboxes\" | \"multiselect\" | \"category\";\n  /**\n   * Lets a `control: \"category\"` pill select a PARENT category, not just its\n   * children. Off by default, which keeps the leaf-only reading: the parent is\n   * a heading and its subcategories are the rows you tick.\n   *\n   * Turn it on where \"the whole category\" is a filter a user would reach for —\n   * selecting a parent then selects every subcategory under it, and the chip\n   * tray collapses that back to one chip bearing the category's name.\n   *\n   * A category with NO children is selectable either way: it is itself the\n   * leaf, so the flag has nothing to gate there.\n   */\n  allowParentSelection?: boolean;\n  /**\n   * Forces this filter to render as a searchable multi-select dropdown with the\n   * search box always shown, regardless of how many options are currently\n   * loaded. Use it when the option set can grow unbounded (e.g. a filter backed\n   * by a relation such as Roles or Categories). Omit it for a closed value set\n   * (an enum), which keeps the plain checkbox / \"search only when long\"\n   * behavior.\n   */\n  searchEnabled?: boolean;\n  /**\n   * Reads the row's value(s) for this field. A row matches the pill when any of\n   * its values is selected. Defaults to `String(row[id])`.\n   */\n  accessor?: (row: T) => string | string[];\n}\n\n/**\n * The range types live in `data-views-range-types` (this file outgrew the\n * size gate); they are re-exported here so `data-views-types` stays the one\n * name every consumer imports the model from.\n */\nexport type {\n  DayRangeFieldConfig,\n  NumberRangeFieldConfig,\n  RangeFieldConfig,\n  RangeFieldKind,\n  RangePreset,\n  RangeValue,\n} from \"./data-views-range-types\";\n\n/** A grid column that can join the search scan and the column-visibility menu. */\nexport interface DataViewColumn<T extends Record<string, unknown>> extends GridColumn<T> {\n  /** Included in \"search across all columns\" (needs a resolvable value). */\n  searchable?: boolean;\n  /** Toggleable in the column-visibility menu. Defaults to true; set false for\n   *  structural columns (image thumbnail, actions kebab) that must always show. */\n  hideable?: boolean;\n}\n\n/**\n * The DataViews layout (view type): the dense \"Tabela\" grid, the \"Grade\" of\n * cards, the \"Lista\" of full-width rows, or the \"Quadro\" board of state columns.\n * Lives with the state types rather than with the toggle because a saved view\n * CAPTURES it — see {@link DataViewState.layout}.\n */\nexport type DataViewsLayout = \"cards\" | \"list\" | \"board\" | \"table\";\n\n/** The full, serializable state a view captures. */\nexport interface DataViewState {\n  /** Free text matched across every `searchable` column. */\n  search: string;\n  /** fieldId → selected option values (empty/absent = no constraint). */\n  pills: Record<string, string[]>;\n  /** fieldId → selected numeric range (min/max). Absent/empty = no constraint. */\n  ranges?: Record<string, RangeValue>;\n  sortBy: GridSort[];\n  /** Column ids kept visible; a hideable column not listed here is hidden. */\n  visibleColumns: string[];\n  /**\n   * Column ids in READING ORDER. Absent ⇒ the order the table declared them in.\n   *\n   * Order is view state for the same reason visibility is: reordering columns is\n   * an operator deciding what to read FIRST, and a saved view that restored the\n   * columns but not their order would restore half a decision. Ids the table no\n   * longer declares are ignored at render, and ids missing from a stale list\n   * fall in after it — so a column added since the view was saved appears rather\n   * than disappearing.\n   */\n  order?: string[];\n  /**\n   * The active SCOPE id — the page-level partition the scope tabs select (see\n   * `ScopeConfig`). Optional, so a table that declares no scopes is untouched\n   * and no view persisted before scopes existed breaks.\n   *\n   * Stored raw and RESOLVED at read time: the declared scopes change underneath\n   * a saved view, and a view naming a scope that has since been removed must\n   * fall back at render rather than break.\n   */\n  scope?: string;\n  /**\n   * The layout the view was saved in. Optional — absent means \"whatever the user\n   * is currently using\", which is the pre-existing behaviour.\n   *\n   * A LAYOUT FALLBACK IS NOT A LAYOUT CHANGE: a table rendered as stacked rows\n   * on a phone still has `\"table\"` stored here, so the view round-trips the\n   * stored layout regardless of the device that opened it.\n   */\n  layout?: DataViewsLayout;\n}\n\n/** A pristine view state showing every given column and no filters/sort. */\nexport function emptyViewState(visibleColumns: string[]): DataViewState {\n  return { search: \"\", pills: {}, ranges: {}, sortBy: [], visibleColumns };\n}\n\n/**\n * The URL-driven slice of {@link DataViewState} — the controls a server-mode host\n * mirrors from the address bar (search / pills / ranges / sort), WITHOUT\n * `visibleColumns`. Supplying it re-applies those controls when its reference\n * changes (e.g. browser back/forward or a deep-link on the same route), merging\n * over the current state so a user's show/hide column choices are preserved —\n * unlike `appliedState`, which fully replaces the state to apply a saved view.\n */\nexport type DataViewSyncState = Pick<\n  DataViewState,\n  \"search\" | \"pills\" | \"ranges\" | \"sortBy\" | \"scope\"\n>;\n\n/**\n * The query a SERVER-mode table emits whenever its filter/sort/page changes\n * (FUT-180). The host translates this into a backend request (see\n * `@12-apps/shared-helpers/search`) — in server mode the grid never filters,\n * sorts, or paginates in the browser; it renders exactly the page the server\n * returned. `page` is 1-based to match the backend contract.\n */\nexport interface DataViewQuery {\n  search: string;\n  pills: Record<string, string[]>;\n  ranges: Record<string, RangeValue>;\n  sortBy: GridSort[];\n  /**\n   * The RESOLVED active scope (see `resolveScope`), when the table declares\n   * scopes. The KEY IS ABSENT for a table that declares none — not present-and-\n   * undefined — so a host that never opted in sees a byte-identical query.\n   *\n   * It carries the resolved id, never the stored one: a deep link or a saved\n   * view naming a scope the table no longer declares must not put that id on the\n   * wire, where the backend would reject it and replace the page with an error.\n   */\n  scope?: string;\n  page: number;\n  pageSize: number;\n}\n\n/**\n * Server-mode wiring for a DataViews table. Its PRESENCE flips the table from\n * in-browser filtering/sorting/pagination to backend-driven: the rows handed in\n * are already the current page, `totalCount` is the unpaginated total, and\n * `onQueryChange` fires (search debounced by the host) whenever the user changes\n * a filter, the sort, or the page. This is the ONLY way an admin list should run\n * (see the app-side `DataViewsTable` wrapper, which requires it).\n */\nexport interface DataViewServer {\n  /** Total matched rows across all pages (drives the counter + page count). */\n  totalCount: number;\n  /** Current 1-based page. */\n  page: number;\n  /** Rows per page. */\n  pageSize: number;\n  /** Fired when the effective query changes; the host re-fetches the page. */\n  onQueryChange: (query: DataViewQuery) => void;\n  /**\n   * Per-scope totals for the scope tabs: `scopeId → count`. THE ONLY PIECE OF\n   * THIS CONTRACT THAT CANNOT BE DONE CLIENT-SIDE — a count computed from the\n   * loaded page is wrong the moment there is a second page, which is the\n   * concrete bug scopes exist to fix.\n   *\n   * Compute it over search + pills + ranges while IGNORING the active scope.\n   * Computed WITH the scope applied, every inactive tab reads zero, which is\n   * worse than no counts at all.\n   *\n   * Omit it and the tabs render with no numbers. Nothing is ever invented from\n   * the loaded rows to fill the gap.\n   */\n  scopeCounts?: Record<string, number>;\n}\n\n/**\n * Coerce an opaque persisted state (a saved view's JSON) into a valid\n * DataViewState, filling any missing part with a sane default. Guards against\n * legacy/older shapes so applying a saved view never renders an empty grid.\n */\nexport function coerceViewState(raw: unknown, allColumnIds: string[]): DataViewState {\n  const value = (raw ?? {}) as Partial<DataViewState>;\n  return {\n    search: typeof value.search === \"string\" ? value.search : \"\",\n    pills: asRecord<string[]>(value.pills),\n    ranges: asRecord<RangeValue>(value.ranges),\n    sortBy: Array.isArray(value.sortBy) ? value.sortBy : [],\n    visibleColumns: Array.isArray(value.visibleColumns) ? value.visibleColumns : allColumnIds,\n    order: Array.isArray(value.order) ? value.order : undefined,\n    // Carried through UNVALIDATED against the declared scopes on purpose: a view\n    // written before scopes existed has none (⇒ undefined ⇒ the first declared\n    // scope at render), and one naming a since-removed scope keeps its stored id\n    // here and falls back at READ time. Resolving here would rewrite the view.\n    scope: typeof value.scope === \"string\" ? value.scope : undefined,\n    layout: isLayout(value.layout) ? value.layout : undefined,\n  };\n}\n\n/** Every layout this build knows how to render — the guard's single source. */\nexport const DATA_VIEWS_LAYOUTS: readonly DataViewsLayout[] = [\"cards\", \"list\", \"board\", \"table\"];\n\n/** Is this a layout this build knows how to render? Guards persisted JSON. */\nfunction isLayout(value: unknown): value is DataViewsLayout {\n  return DATA_VIEWS_LAYOUTS.includes(value as DataViewsLayout);\n}\n\n/** A persisted map, or an empty one — persisted JSON can hold anything. */\nfunction asRecord<V>(value: unknown): Record<string, V> {\n  return value !== null && typeof value === \"object\" ? (value as Record<string, V>) : {};\n}\n\n/** A saved view as consumed by the DataViews UI (FUT-89), with ownership flag. */\nexport interface SavedViewSummary {\n  id: string;\n  name: string;\n  description: string | null;\n  state: DataViewState;\n  shared: boolean;\n  pinned: boolean;\n  isDefault: boolean;\n  /** True when the current user owns the view (may edit/delete/pin/share it). */\n  isOwner: boolean;\n}\n\n/** A saved-view repository record (opaque `state`), as returned to server pages. */\ninterface SavedViewRecordLike {\n  id: string;\n  name: string;\n  description: string | null;\n  state: unknown;\n  shared: boolean;\n  pinned: boolean;\n  isDefault: boolean;\n  isOwner: boolean;\n}\n\n/** Map a repository record to the client summary (opaque state → DataViewState). */\nexport function toSavedViewSummary(record: SavedViewRecordLike): SavedViewSummary {\n  return { ...record, state: (record.state ?? {}) as DataViewState };\n}\n\n/**\n * Dependency-injection contracts for the framework-agnostic DataViewsTableBase:\n * the host app supplies saved-view persistence + router side-effects so the ui\n * component imports neither a backend (server actions) nor a framework router.\n */\n\n/** A saved view's editable fields, as the host persists them. */\nexport interface DataViewSaveInput {\n  name: string;\n  description: string;\n  state: DataViewState;\n  shared: boolean;\n  pinned: boolean;\n  isDefault: boolean;\n}\n\n/** Result of a persistence call — mirrors the app's `Result` without importing it. */\nexport type DataViewMutationResult = { ok: true } | { ok: false; error: string };\n\n/** Injected saved-view persistence (create/update/delete), wired by the host. */\nexport interface DataViewPersistence {\n  create: (input: DataViewSaveInput) => Promise<DataViewMutationResult>;\n  update: (id: string, input: DataViewSaveInput) => Promise<DataViewMutationResult>;\n  remove: (id: string) => Promise<DataViewMutationResult>;\n}\n\n/** Injected router side-effects: sync the `?view=` param and re-fetch on change. */\nexport interface DataViewRouter {\n  syncViewParam: (viewId: string | null) => void;\n  refresh: () => void;\n}\n"],"mappings":";AAoEO,IAAM,qBAAsD;AAAA,EACjE,OAAO;AAAA,EACP,OAAO,IAAI;AAAA,EACX,QAAQ,KAAK;AAAA,EACb,QAAQ,IAAI;AAAA,EACZ,OAAO,IAAI;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASX,OAAO;AACT;AAoIO,SAAS,eAAe,gBAAyC;AACtE,SAAO,EAAE,QAAQ,IAAI,OAAO,CAAC,GAAG,QAAQ,CAAC,GAAG,QAAQ,CAAC,GAAG,eAAe;AACzE;AA+EO,SAAS,gBAAgB,KAAc,cAAuC;AACnF,QAAM,QAAS,OAAO,CAAC;AACvB,SAAO;AAAA,IACL,QAAQ,OAAO,MAAM,WAAW,WAAW,MAAM,SAAS;AAAA,IAC1D,OAAO,SAAmB,MAAM,KAAK;AAAA,IACrC,QAAQ,SAAqB,MAAM,MAAM;AAAA,IACzC,QAAQ,MAAM,QAAQ,MAAM,MAAM,IAAI,MAAM,SAAS,CAAC;AAAA,IACtD,gBAAgB,MAAM,QAAQ,MAAM,cAAc,IAAI,MAAM,iBAAiB;AAAA,IAC7E,OAAO,MAAM,QAAQ,MAAM,KAAK,IAAI,MAAM,QAAQ;AAAA;AAAA;AAAA;AAAA;AAAA,IAKlD,OAAO,OAAO,MAAM,UAAU,WAAW,MAAM,QAAQ;AAAA,IACvD,QAAQ,SAAS,MAAM,MAAM,IAAI,MAAM,SAAS;AAAA,EAClD;AACF;AAGO,IAAM,qBAAiD,CAAC,SAAS,QAAQ,SAAS,OAAO;AAGhG,SAAS,SAAS,OAA0C;AAC1D,SAAO,mBAAmB,SAAS,KAAwB;AAC7D;AAGA,SAAS,SAAY,OAAmC;AACtD,SAAO,UAAU,QAAQ,OAAO,UAAU,WAAY,QAA8B,CAAC;AACvF;AA4BO,SAAS,mBAAmB,QAA+C;AAChF,SAAO,EAAE,GAAG,QAAQ,OAAQ,OAAO,SAAS,CAAC,EAAoB;AACnE;","names":[]}

package/dist/chunk-TOUSE63W.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/components/data-display/DataViews/use-data-views-state.ts"],"sourcesContent":["\"use client\";\n\nimport { useEffect, useMemo, useRef, useState } from \"react\";\n\nimport { type GridColumn } from \"../DataGrid\";\nimport { type SortFieldDefinition } from \"../../layout/ContentToolbar\";\n\nimport { filterRows } from \"./data-views-filter\";\nimport {\n  useColumnsWithActions,\n  useRenderedColumns,\n  type HideableColumn,\n} from \"./data-views-columns\";\nimport { computeActiveFilterCount, defaultSortFields } from \"./data-views-grid-helpers\";\nimport { resolveScope, useScopeConfigChecks, type ScopeConfig } from \"./data-views-scopes\";\nimport { serverDerived, useServerQuery } from \"./data-views-server-query\";\nimport { useSelection } from \"./data-views-selection\";\nimport {\n  emptyViewState,\n  type DataViewColumn,\n  type DataViewServer,\n  type DataViewState,\n  type DataViewSyncState,\n  type FilterFieldConfig,\n  type RangeFieldConfig,\n  type DataViewQuery,\n  type RangeValue,\n  type RowAction,\n} from \"./data-views-types\";\n\nexport type { HideableColumn };\n\n/** Inputs the hook needs to own the view state + derived data. */\ninterface UseDataViewsStateArgs<T extends Record<string, unknown>> {\n  rows: T[];\n  columns: DataViewColumn<T>[];\n  fields: FilterFieldConfig<T>[];\n  rangeFields: RangeFieldConfig<T>[];\n  getRowId: (row: T) => string | number;\n  onRowClick?: (row: T) => void;\n  appliedState?: DataViewState;\n  /**\n   * URL-driven controls (search/pills/ranges/sort) that re-apply on reference\n   * change while preserving column visibility — see {@link DataViewSyncState}.\n   */\n  syncState?: DataViewSyncState;\n  onStateChange?: (state: DataViewState) => void;\n  testIdPrefix: string;\n  sortFields?: SortFieldDefinition[];\n  rowActions?: RowAction<T>[];\n  rowActionsLeading?: (row: T) => React.ReactNode;\n  /** Bespoke per-row menu rendered in the actions column instead of the auto kebab. */\n  renderRowMenu?: (row: T) => React.ReactNode;\n  /**\n   * When present, the table is BACKEND-driven: `rows` is already the current\n   * page (no in-browser filter/sort/paginate), and query changes re-fetch via\n   * `server.onQueryChange`. Omit for the legacy client-side behaviour.\n   */\n  server?: DataViewServer;\n  /**\n   * The page-level partition rendered as tabs under the toolbar. Requires server\n   * mode: a scope is applied at the BACKEND, never in the browser.\n   */\n  scopes?: ScopeConfig[];\n  /**\n   * The row field the scopes partition by, when the host knows it — used only to\n   * reject the pill/scope clash at setup. See `assertNoScopePillOverlap`.\n   */\n  scopeFieldId?: string;\n}\n\n/** Everything the DataViewsGrid render needs; keeps the component itself thin. */\nexport interface DataViewsController<T extends Record<string, unknown>> {\n  state: DataViewState;\n  ranges: Record<string, RangeValue>;\n  patch: (next: Partial<DataViewState>) => void;\n  matched: T[];\n  gridColumns: GridColumn<T>[];\n  /** Columns eligible for the show/hide menu (hideable, with a text header). */\n  hideableColumns: HideableColumn[];\n  /** Every column id in reading order — what the Colunas tab reorders. */\n  columnOrder: string[];\n  /** Toggle one column's visibility in the current view state. */\n  toggleColumn: (id: string, visible: boolean) => void;\n  selectedIds: Set<string | number>;\n  setSelectedIds: (ids: Set<string | number>) => void;\n  /**\n   * Add/remove ONE id from the selection. The card and board bodies both need\n   * it, so it lives here rather than being written out twice at the call sites —\n   * one selection model, one toggle, identical in every layout.\n   */\n  toggleId: (id: string | number) => void;\n  selectedRows: T[];\n  clearSelection: () => void;\n  selectAll: () => void;\n  filterOpen: boolean;\n  setFilterOpen: (open: boolean) => void;\n  resolvedSortFields: SortFieldDefinition[];\n  activeSortField: string;\n  activeSortOrder: \"asc\" | \"desc\";\n  activeFilterCount: number;\n  /** True when the table is backend-driven (server mode). */\n  serverMode: boolean;\n  /** Server-mode pagination: 1-based current page (1 when client mode). */\n  serverPage: number;\n  /** Server-mode pagination: total pages (1 when client mode). */\n  serverPageCount: number;\n  /** Server-mode: total matched rows across all pages (drives the counter). */\n  serverTotalCount: number;\n  /** Server-mode: request a specific 1-based page (re-fetches via onQueryChange). */\n  changePage: (page: number) => void;\n  /**\n   * The active scope id, RESOLVED against the declared scopes (see\n   * `resolveScope`). `undefined` when the table declares none — which is what\n   * keeps `scope` out of the emitted query for every table that never opted in.\n   */\n  scope: string | undefined;\n  /** Select a scope: re-fetches from page 1 and drops the selection. */\n  setScope: (id: string) => void;\n  /**\n   * The query the grid is currently showing. Read by Export, which hands it\n   * back to the host UNPAGINATED — so an export follows the filters rather\n   * than the 25 rows that happen to be loaded.\n   */\n  currentQuery: DataViewQuery;\n  /**\n   * Server-supplied per-scope totals, passed through verbatim, or `undefined`\n   * when the server omits them. NEVER falls back to counting `matched`: a count\n   * off the loaded page is wrong under pagination, which is the bug scopes fix.\n   */\n  scopeCounts?: Record<string, number>;\n}\n\n/**\n * The rows to render: in server mode `rows` is already the current page (the\n * backend filtered/sorted/paginated), so it passes through untouched; otherwise\n * the client search/pill/range filter narrows it.\n */\nfunction useMatchedRows<T extends Record<string, unknown>>(\n  server: DataViewServer | undefined,\n  rows: T[],\n  columns: DataViewColumn<T>[],\n  fields: FilterFieldConfig<T>[],\n  rangeFields: RangeFieldConfig<T>[],\n  state: DataViewState,\n): T[] {\n  return useMemo(\n    () =>\n      server\n        ? rows\n        : filterRows(\n            rows,\n            columns,\n            fields,\n            { search: state.search, pills: state.pills, ranges: state.ranges },\n            rangeFields,\n          ),\n    [server, rows, columns, fields, rangeFields, state.search, state.pills, state.ranges],\n  );\n}\n\n/** Add or remove one column id from the visible-columns list. */\nfunction nextVisibleColumns(current: string[], id: string, visible: boolean): string[] {\n  const without = current.filter((colId) => colId !== id);\n  return visible ? [...without, id] : without;\n}\n\n/**\n * Reconcile external state changes and surface every change to the caller:\n * - `appliedState` (a saved view) fully REPLACES the state — it is columns-\n *   authoritative, so applying a view restores its filters, sort AND columns.\n * - `syncState` (URL-driven controls) MERGES over the current state, leaving\n *   `visibleColumns` untouched — so browser back/forward or a same-route\n *   deep-link re-applies search/pills/sort without wiping a user's hidden columns.\n * Each channel only fires when its own reference changes (after the first run).\n */\nfunction useStateSyncEffects(\n  appliedState: DataViewState | undefined,\n  syncState: DataViewSyncState | undefined,\n  state: DataViewState,\n  onStateChange: ((state: DataViewState) => void) | undefined,\n  setState: React.Dispatch<React.SetStateAction<DataViewState>>,\n): void {\n  const firstApplied = useRef(true);\n  useEffect(() => {\n    if (firstApplied.current) {\n      firstApplied.current = false;\n      return;\n    }\n    if (appliedState) setState(appliedState);\n    // `setState` is a stable useState setter (passed in), included to satisfy\n    // exhaustive-deps; the effect still only re-applies when `appliedState` changes.\n  }, [appliedState, setState]);\n  const firstSync = useRef(true);\n  useEffect(() => {\n    if (firstSync.current) {\n      firstSync.current = false;\n      return;\n    }\n    // Merge — keep the current `visibleColumns` (never URL-carried); only the\n    // URL-driven controls change.\n    if (syncState) setState((prev) => ({ ...prev, ...syncState }));\n  }, [syncState, setState]);\n  useEffect(() => {\n    onStateChange?.(state);\n  }, [state, onStateChange]);\n}\n\n/**\n * The seed view state: a saved view (`appliedState`) or a pristine all-columns\n * one, with the URL-driven controls (`syncState`) merged over it so a deep-linked\n * filter or scope is reflected on the FIRST render. Column visibility is never\n * URL-carried, so the merge cannot wipe it.\n */\nfunction seedState(\n  appliedState: DataViewState | undefined,\n  syncState: DataViewSyncState | undefined,\n  allColumnIds: string[],\n): DataViewState {\n  const seed = appliedState ?? emptyViewState(allColumnIds);\n  return syncState ? { ...seed, ...syncState } : seed;\n}\n\n/**\n * Selecting a scope: record it, then DROP the selection.\n *\n * A scope change renders a different result set. A selection that survived it\n * would let a bulk action run against rows the user can no longer see — the\n * same reason changing any other part of the query clears it.\n */\nfunction makeSetScope(\n  patch: (next: Partial<DataViewState>) => void,\n  clearSelection: () => void,\n): (id: string) => void {\n  return (id) => {\n    patch({ scope: id });\n    clearSelection();\n  };\n}\n\n/**\n * The declared column ids in the stored reading order — the same tolerance\n * `applyOrder` uses, so the Colunas tab lists exactly what the grid renders.\n */\nfunction orderedColumnIds(allColumnIds: string[], order: string[] | undefined): string[] {\n  if (!order || order.length === 0) return allColumnIds;\n  const declared = new Set(allColumnIds);\n  const kept = order.filter((id) => declared.has(id));\n  const seen = new Set(kept);\n  return [...kept, ...allColumnIds.filter((id) => !seen.has(id))];\n}\n\n/**\n * The query the grid is currently SHOWING — the same shape `onQueryChange`\n * emits, kept as a value so a host control (Exportar) can re-run it against the\n * backend rather than reading the loaded rows.\n */\nfunction liveQuery(\n  state: DataViewState,\n  scope: string | undefined,\n  server: DataViewServer | undefined,\n  matchedCount: number,\n): DataViewQuery {\n  return {\n    search: state.search,\n    pills: state.pills,\n    ranges: state.ranges ?? {},\n    sortBy: state.sortBy,\n    // Absent, not undefined, when the table declares no scopes.\n    ...(scope !== undefined ? { scope } : {}),\n    page: server?.page ?? 1,\n    // Client mode has one page, and it is everything that matched.\n    pageSize: server?.pageSize ?? matchedCount,\n  };\n}\n\n/** The toolbar's active sort, read off the state's FIRST sort entry. */\nfunction activeSortOf(\n  state: DataViewState,\n  resolvedSortFields: SortFieldDefinition[],\n): { activeSortField: string; activeSortOrder: \"asc\" | \"desc\" } {\n  const active = state.sortBy?.[0];\n  return {\n    activeSortField: active?.id ?? resolvedSortFields[0]?.value ?? \"\",\n    activeSortOrder: active?.dir === \"desc\" ? \"desc\" : \"asc\",\n  };\n}\n\n/**\n * Owns the DataViews view state (search/pills/ranges/sort/visibleColumns),\n * multi-select, the filter-panel toggle, and every derived value (filtered rows,\n * grid columns, active sort/filter counts). Extracted from the component so the\n * render stays within the size/complexity budget.\n */\nexport function useDataViewsState<T extends Record<string, unknown>>({\n  rows,\n  columns,\n  fields,\n  rangeFields,\n  getRowId,\n  onRowClick,\n  appliedState,\n  syncState,\n  onStateChange,\n  testIdPrefix,\n  sortFields,\n  rowActions,\n  rowActionsLeading,\n  renderRowMenu,\n  server,\n  scopes = [],\n  scopeFieldId,\n}: UseDataViewsStateArgs<T>): DataViewsController<T> {\n  useScopeConfigChecks(scopes, fields.map((field) => field.id), scopeFieldId, server !== undefined);\n  const { columnsWithActions, allColumnIds } = useColumnsWithActions(columns, {\n    rowActions,\n    rowActionsLeading,\n    renderRowMenu,\n    testIdPrefix,\n    getRowId,\n  });\n  // Seed once — see {@link seedState}.\n  const [state, setState] = useState<DataViewState>(() =>\n    seedState(appliedState, syncState, allColumnIds),\n  );\n  const [filterOpen, setFilterOpen] = useState(false);\n\n  useStateSyncEffects(appliedState, syncState, state, onStateChange, setState);\n\n  const patch = (next: Partial<DataViewState>): void => setState((prev) => ({ ...prev, ...next }));\n  const matched = useMatchedRows(server, rows, columns, fields, rangeFields, state);\n  // Resolved at READ time, every render: a stale deep link or a saved view naming\n  // a scope that has since been removed falls back to the first declared scope\n  // instead of putting an id the backend rejects on the wire.\n  const scope = resolveScope(scopes, state.scope);\n  // Server mode: re-fetch on query change (page resets to 1) + drive pagination.\n  const { changePage } = useServerQuery(server, state, scope);\n  const { gridColumns, hideableColumns } = useRenderedColumns(\n    columnsWithActions,\n    state.visibleColumns,\n    onRowClick,\n    state.order,\n  );\n  const toggleColumn = (id: string, visible: boolean): void =>\n    setState((prev) => ({ ...prev, visibleColumns: nextVisibleColumns(prev.visibleColumns, id, visible) }));\n  const selection = useSelection(matched, getRowId);\n  const resolvedSortFields = sortFields ?? defaultSortFields(columns);\n\n  return {\n    state,\n    ranges: state.ranges ?? {},\n    patch,\n    matched,\n    gridColumns,\n    hideableColumns,\n    columnOrder: orderedColumnIds(allColumnIds, state.order),\n    toggleColumn,\n    ...selection,\n    filterOpen,\n    setFilterOpen,\n    resolvedSortFields,\n    ...activeSortOf(state, resolvedSortFields),\n    activeFilterCount: computeActiveFilterCount(state, fields, rangeFields),\n    ...serverDerived(server, matched.length),\n    changePage,\n    scope,\n    setScope: makeSetScope(patch, selection.clearSelection),\n    currentQuery: liveQuery(state, scope, server, matched.length),\n    // Verbatim, or absent. See DataViewServer.scopeCounts for why there is no\n    // client-side fallback.\n    scopeCounts: server?.scopeCounts,\n  };\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-W3UM2KEW.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/components/data-display/DataViews/data-views-grid-parts.tsx"],"sourcesContent":["\"use client\";\n\nimport { useEffect, useState } from \"react\";\n\nimport { TableFilter } from \"../../layout/TableFilter\";\nimport { Text } from \"../../typography/Text\";\nimport { Box } from \"../../../mui/Box\";\nimport { Stack } from \"../../../mui/Stack\";\n\nimport {\n  DataViewsLayoutProvider,\n  useDataViewsLayout,\n  type DataViewsLayout,\n} from \"./data-views-layout-context\";\nimport { FilterDialog, GridFilterPanel } from \"./data-views-filter-panel\";\nimport { GridMain } from \"./data-views-grid-bodies\";\nimport type { ListGroupConfig } from \"./list-card-rails\";\nimport { InlineFilterControls } from \"./data-views-inline-bar\";\nimport { toOverflowFields, useFilterOverflow, type OverflowSplit } from \"./data-views-overflow\";\nimport { ShellToolbar } from \"./data-views-shell-toolbar\";\nimport type { DisplayPanelView } from \"./data-views-display-panel\";\nimport type { DataViewExport } from \"./data-views-export\";\nimport { useDataViewsCopy } from \"./data-views-copy-context\";\nimport { DataViewsEmpty } from \"./data-views-empty\";\nimport { DataViewsPagination } from \"./data-views-pagination\";\nimport type { BoardConfig } from \"./DataViewsBoard\";\nimport { type ScopeConfig } from \"./data-views-scopes\";\nimport { ScopeTabsSlot } from \"./data-views-scope-tabs\";\nimport { togglePillValues } from \"./data-views-grid-helpers\";\nimport type {\n  DataViewCardSelection,\n  FilterFieldConfig,\n  RangeFieldConfig,\n  RangeValue,\n  RowAction,\n} from \"./data-views-types\";\nimport type { DataViewsController } from \"./use-data-views-state\";\n\n/* ── Header row ──────────────────────────────────────────────────────────── */\n\n/**\n * The grid's own header row: the page title on the left, the primary page\n * actions on the right.\n *\n * `title` and `headerActions` were DECLARED on `DataViewsGridProps` and\n * `DataViewsTableBaseProps` but never destructured or forwarded — dead props\n * whose types lied to every caller that set them. Wired here rather than\n * deleted: a table that carries its own title keeps the title, the scope tabs\n * and the toolbar as one block, instead of the page having to space them.\n *\n * Renders NOTHING when neither is supplied, so no existing table gains a row.\n */\nfunction GridHeaderRow({\n  title,\n  headerActions,\n  testIdPrefix,\n}: {\n  title?: string;\n  headerActions?: React.ReactNode;\n  testIdPrefix: string;\n}): React.JSX.Element | null {\n  if (!title && !headerActions) return null;\n  return (\n    <Box\n      data-testid={`${testIdPrefix}-header`}\n      sx={{\n        display: \"flex\",\n        alignItems: \"center\",\n        justifyContent: \"space-between\",\n        gap: 2,\n        flexWrap: \"wrap\",\n        pb: 1.5,\n      }}\n    >\n      {title ? (\n        <Text variant=\"heading\" size=\"lg\" as=\"h2\">\n          {title}\n        </Text>\n      ) : (\n        <Box />\n      )}\n      {headerActions && <Box sx={{ display: \"flex\", alignItems: \"center\", gap: 1 }}>{headerActions}</Box>}\n    </Box>\n  );\n}\n\n/* ── Layout ⇄ view-state mirror ──────────────────────────────────────────── */\n\n/**\n * Mirrors the LIVE layout back into the view state, so saving a view captures\n * the layout the user is actually looking at.\n *\n * A component rather than a callback prop because only something INSIDE the\n * provider can read the layout, and only the controller can write the state.\n * The `stored !== layout` guard is what makes it idempotent: `c` is rebuilt on\n * every render, so an unguarded effect here would patch → re-render → patch.\n *\n * It re-fires when `stored` changes too, which is the case that matters after\n * applying a saved view: `appliedState` REPLACES the state, so a view saved\n * before layouts were captured clears `state.layout`, and the mirror puts the\n * current one back rather than leaving the next save with nothing to store.\n */\nfunction LayoutStateSync<T extends Record<string, unknown>>({\n  c,\n}: {\n  c: DataViewsController<T>;\n}): null {\n  const { layout } = useDataViewsLayout();\n  const stored = c.state.layout;\n  useEffect(() => {\n    if (stored !== layout) c.patch({ layout });\n    // `c` is intentionally out of the deps — see the guard above.\n  }, [layout, stored]);\n  return null;\n}\n\n/* ── Shell (composes toolbar + body + panel) ─────────────────────────────── */\n\n/** The shared filter-surface props consumed by the inline bar, panel, and modal. */\ninterface FilterSurfaceProps<T extends Record<string, unknown>> {\n  testIdPrefix: string;\n  search: string;\n  fields: FilterFieldConfig<T>[];\n  rangeFields: RangeFieldConfig<T>[];\n  pills: Record<string, string[]>;\n  ranges: Record<string, RangeValue>;\n  onSearchChange: (value: string) => void;\n  onTogglePill: (fieldId: string, value: string, checked: boolean) => void;\n  onChangeRange: (fieldId: string, range: RangeValue) => void;\n  onClearField: (fieldId: string) => void;\n  onClearAll: () => void;\n}\n\n/**\n * Derives the responsive filter state (which surface to show at this width) and\n * the filter-mutation handlers from the controller — pulled out of `GridShell`\n * so the component body stays under the size/complexity budget.\n */\n/** Grouped rather than positional: the list had grown past readability. */\ninterface GridShellFiltersArgs<T extends Record<string, unknown>> {\n  c: DataViewsController<T>;\n  inlineFilters: boolean;\n  fields: FilterFieldConfig<T>[];\n  rangeFields: RangeFieldConfig<T>[];\n  testIdPrefix: string;\n  alwaysShowSearch: boolean;\n  /** Is \"Exportar\" on the bar? Half the right cluster's cost when it is not. */\n  hasExport: boolean;\n}\n\nfunction useGridShellFilters<T extends Record<string, unknown>>({\n  c,\n  inlineFilters,\n  fields,\n  rangeFields,\n  testIdPrefix,\n  alwaysShowSearch,\n  hasExport,\n}: GridShellFiltersArgs<T>): {\n  showInline: boolean;\n  useModal: boolean;\n  inlineVisible: boolean;\n  filterProps: FilterSurfaceProps<T>;\n  split: OverflowSplit<T>;\n  onControlOpenChange: (open: boolean) => void;\n} {\n  const { state } = c;\n  // How many filter controls are open. A COUNT, not a flag: closing one popover\n  // by opening another overlaps, and a boolean would unfreeze mid-handover.\n  const [openControls, setOpenControls] = useState(0);\n  // ONE measurement for the whole shell: the filter row decides which controls\n  // it can keep, and the TOOLBAR needs the same answer to drop its labels.\n  // Measuring twice would let the two disagree at the crossover width.\n  const split = useFilterOverflow(\n    toOverflowFields(fields, rangeFields),\n    state.pills,\n    c.ranges,\n    openControls > 0,\n    hasExport,\n  );\n  // THE BAR RENDERS AT EVERY WIDTH. It used to be swapped for a full-screen\n  // filter MODAL below `lg`, which was the responsive strategy before the\n  // measured ladder existed — and the two now do the same job, badly together:\n  // the modal took the bar away at 1199px, and with it the very degradation\n  // (labels off, search collapsed, filters into \"Mais\") that exists to make a\n  // narrow bar work. So a 900px window got no bar and no ladder, and the\n  // operator lost the search entirely rather than gaining a compact one.\n  //\n  // The ladder is measured, so it already covers every width the modal did.\n  const showInline = inlineFilters;\n  const useModal = false;\n  const inlineVisible =\n    showInline &&\n    (alwaysShowSearch || fields.length > 0 || rangeFields.length > 0 || state.search !== \"\");\n  const filterProps: FilterSurfaceProps<T> = {\n    testIdPrefix,\n    search: state.search,\n    fields,\n    rangeFields,\n    pills: state.pills,\n    ranges: c.ranges,\n    onSearchChange: (value) => c.patch({ search: value }),\n    onTogglePill: (fieldId, value, checked) =>\n      c.patch({ pills: { ...state.pills, [fieldId]: togglePillValues(state.pills[fieldId], value, checked) } }),\n    onChangeRange: (fieldId, range) => c.patch({ ranges: { ...c.ranges, [fieldId]: range } }),\n    onClearField: (fieldId) => c.patch({ pills: { ...state.pills, [fieldId]: [] } }),\n    onClearAll: () => c.patch({ search: \"\", pills: {}, ranges: {} }),\n  };\n  return {\n    showInline,\n    useModal,\n    inlineVisible,\n    filterProps,\n    split,\n    onControlOpenChange: (open) =>\n      setOpenControls((count) => Math.max(0, count + (open ? 1 : -1))),\n  };\n}\n\ninterface GridShellProps<T extends Record<string, unknown>> {\n  c: DataViewsController<T>;\n  rows: T[];\n  fields: FilterFieldConfig<T>[];\n  rangeFields: RangeFieldConfig<T>[];\n  getRowId: (row: T) => string | number;\n  testIdPrefix: string;\n  dataTestId?: string;\n  emptyState?: React.ReactNode;\n  toolbarRightSlot?: React.ReactNode;\n  rowActions?: RowAction<T>[];\n  bulkActions?: (selectedRows: T[], clearSelection: () => void) => React.ReactNode;\n  /** Opt-in \"Grade\" (cards) layout: renders each row as an entity-supplied card.\n   *  Omit ⇒ table only (no layout toggle). */\n  renderCard?: (row: T, selection: DataViewCardSelection) => React.ReactNode;\n  /**\n   * Opt-in \"Quadro\" (board) layout. Needs `renderCard` too — the board reuses\n   * the entity's card, so a board config without one simply offers no board\n   * rather than failing: that is a config gap, not a runtime error.\n   */\n  board?: BoardConfig<T>;\n  /** Opt-in \"Lista\" layout: one full-width, entity-rendered row per record. */\n  renderListRow?: (row: T, selection: DataViewCardSelection) => React.ReactNode;\n  /** The Lista's shared columns, so its rows line up by construction. */\n  listGroup?: ListGroupConfig<T>;\n  /** The page-level partition rendered as tabs under the toolbar. */\n  scopes?: ScopeConfig[];\n  /**\n   * The row field the scopes partition by. Compared against the board's\n   * `groupBy` so the two are not shown as the same partition twice.\n   */\n  scopeFieldId?: string;\n  /** Per-sort-field value kind, so directions read in the column's own terms. */\n  sortKinds?: Record<string, string>;\n  /** The saved-view chrome bracketing the Exibir panel. */\n  displayView?: DisplayPanelView;\n  /** Injected export — the host re-queries; the grid never fetches. */\n  exportConfig?: DataViewExport;\n  /** Page title in the grid's own header row, above the scopes + toolbar. */\n  title?: string;\n  /** Primary page actions rendered at the header row's right. */\n  headerActions?: React.ReactNode;\n  /** Which layout to show first when the user has expressed no preference (default \"table\"). */\n  defaultLayout?: DataViewsLayout;\n  /** Pin to `defaultLayout`, ignoring the remembered preference (stories/docs). */\n  ignoreStoredLayout?: boolean;\n  /**\n   * Opt into the responsive inline filter UX: a collapsible filter row below the\n   * toolbar on wide screens and a modal on narrow ones. When false (default),\n   * keep the classic slide-in filter panel opened by the \"Filtros\" button.\n   */\n  inlineFilters?: boolean;\n  /**\n   * Keep the inline search box on screen even with no filter fields and no\n   * active search. Without it a grid whose only filter IS the search (`fields`\n   * empty) can never OFFER one: the row renders only once a search exists, so\n   * the operator would have to hand-edit the URL to start one. Default false —\n   * every grid that ships filter fields already shows the row.\n   */\n  alwaysShowSearch?: boolean;\n}\n\n/** The scrollable content region: scope tabs, toolbar, filter bar, body, pager. */\nfunction ShellStack<T extends Record<string, unknown>>({\n  props,\n  filters,\n}: {\n  props: GridShellProps<T>;\n  filters: ReturnType<typeof useGridShellFilters<T>>;\n}): React.JSX.Element {\n  const copy = useDataViewsCopy();\n  const { c, testIdPrefix, dataTestId, scopes = [], emptyState, inlineFilters = false } = props;\n  const { showInline, useModal, inlineVisible, filterProps, split, onControlOpenChange } = filters;\n  // The grid renders the FILTERED empty state itself — it is the only party\n  // that knows a filter is applied. See {@link DataViewsEmpty}.\n  const body = (\n    <DataViewsEmpty\n      filtered={c.activeFilterCount > 0 || c.state.search !== \"\"}\n      onClearFilters={() => c.patch({ search: \"\", pills: {}, ranges: {} })}\n      emptyState={emptyState}\n      testIdPrefix={testIdPrefix}\n    />\n  );\n  return (\n    <TableFilter\n      copy={copy.tableFilter} open={c.filterOpen} onOpenChange={c.setFilterOpen}\n      hasActiveFilters={c.activeFilterCount > 0}\n    >\n      <Stack spacing={0} data-testid={dataTestId ? `${dataTestId}-container` : undefined}>\n        <GridHeaderRow title={props.title} headerActions={props.headerActions} testIdPrefix={testIdPrefix} />\n        <ShellToolbar\n          c={c}\n          rows={props.rows}\n          sortKinds={props.sortKinds}\n          displayView={props.displayView}\n          exportConfig={props.exportConfig}\n          filterControls={\n            inlineVisible ? (\n              <InlineFilterControls\n                {...filterProps} split={split} activeFilterCount={c.activeFilterCount}\n                onControlOpenChange={onControlOpenChange}\n              />\n            ) : undefined\n          }\n          barRef={split.barRef}\n          testIdPrefix={testIdPrefix}\n          rowActions={props.rowActions}\n          bulkActions={props.bulkActions}\n          toolbarRightSlot={props.toolbarRightSlot}\n          compactControls={showInline && split.compactControls}\n          counterHidden={showInline && split.counterHidden}\n          showInline={showInline}\n        />\n        <ScopeTabsSlot\n          scopes={scopes} scopeFieldId={props.scopeFieldId} board={props.board}\n          value={c.scope} onChange={c.setScope} counts={c.scopeCounts}\n          testIdPrefix={testIdPrefix}\n        />\n        <TableFilter.Layout>\n          <TableFilter.Main>\n            <GridMain\n              c={c}\n              getRowId={props.getRowId}\n              renderCard={props.renderCard}\n              renderListRow={props.renderListRow}\n              listGroup={props.listGroup}\n              board={props.board}\n              dataTestId={dataTestId}\n              testIdPrefix={testIdPrefix}\n              emptyState={body}\n            />\n            <DataViewsPagination c={c} testIdPrefix={testIdPrefix} />\n          </TableFilter.Main>\n          {inlineFilters ? null : <GridFilterPanel {...filterProps} />}\n        </TableFilter.Layout>\n        {useModal && <FilterDialog open={c.filterOpen} onClose={() => c.setFilterOpen(false)} {...filterProps} />}\n      </Stack>\n    </TableFilter>\n  );\n}\n\nexport function GridShell<T extends Record<string, unknown>>(props: GridShellProps<T>): React.JSX.Element {\n  const {\n    c,\n    fields,\n    rangeFields,\n    testIdPrefix,\n    renderCard,\n    renderListRow,\n    board,\n    defaultLayout,\n    ignoreStoredLayout,\n    inlineFilters = false,\n    alwaysShowSearch = false,\n  } = props;\n  const filters = useGridShellFilters({\n    c,\n    inlineFilters,\n    fields,\n    rangeFields,\n    testIdPrefix,\n    alwaysShowSearch,\n    hasExport: props.exportConfig !== undefined,\n  });\n  return (\n    <DataViewsLayoutProvider\n      canUseCards={Boolean(renderCard)}\n      canUseList={Boolean(renderListRow)}\n      // The board reuses the entity's card, so it needs BOTH — a `board` with no\n      // `renderCard` offers no board rather than throwing.\n      canUseBoard={Boolean(board && renderCard)}\n      defaultLayout={defaultLayout}\n      ignoreStoredLayout={ignoreStoredLayout}\n      viewLayout={c.state.layout}\n    >\n    <LayoutStateSync c={c} />\n    <ShellStack props={props} filters={filters} />\n    </DataViewsLayoutProvider>\n  );\n}\n"],"mappings":"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","names":["default"]}