{
  "$schema": "https://ui.shadcn.com/schema/registry-item.json",
  "name": "data-grid-views",
  "title": "Data Grid Views",
  "author": "gridcn",
  "description": "Saved views add-on for the gridcn data grid: <DataGridViews /> saves, applies, updates, renames, deletes, and defaults named views of sort, filters, search, and column layout, and imports or exports one as bounded JSON checked against the live columns. useDataGridViews is the headless hook; a storage adapter (localStorage with an in-memory fallback by default, any async store) keeps the views. Zero core changes — purely additive.",
  "dependencies": [
    "lucide-react@^1.46.0"
  ],
  "registryDependencies": [
    "@gridcn/data-grid",
    "popover",
    "button",
    "button-group",
    "badge",
    "input-group",
    "textarea"
  ],
  "files": [
    {
      "path": "registry/default/blocks/data-grid-views/data-grid-views.ts",
      "content": "/** Public entry point — the only module consumers/docs should import from. */\r\n\r\nexport { DataGridViews, type DataGridViewsProps } from \"./views-menu\";\r\nexport type { DataGridViewsLabels } from \"@/registry/default/components/data-grid/data-grid\";\r\nexport {\r\n  useDataGridViews,\r\n  type ImportViewResult,\r\n  type UseDataGridViewsOptions,\r\n  type UseDataGridViewsResult,\r\n} from \"./use-data-grid-views\";\r\nexport { createLocalStorageViewsStorage, createMemoryViewsStorage, type DataGridViewsStorage } from \"./view-storage\";\r\nexport type { DataGridView, DataGridViewState, DataGridViewsDocument, OverLimitPart } from \"./view-state\";\r\n",
      "type": "registry:component",
      "target": "components/data-grid-views/data-grid-views.ts"
    },
    {
      "path": "registry/default/blocks/data-grid-views/use-data-grid-views.ts",
      "content": "\"use client\";\n\nimport { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState } from \"react\";\nimport {\n  useDataGridActions,\n  useDataGridAllColumns,\n  useDataGridFilterState,\n  useDataGridSearchText,\n  useDataGridSortState,\n} from \"@/registry/default/components/data-grid/data-grid\";\nimport { resolveCustomFilterOperators, setFilterValuesOf, useDataGridSelector, useDataGridStoreApi } from \"@/registry/default/components/data-grid/data-grid-sdk\";\nimport {\n  MAX_DOCUMENT_LENGTH,\n  MAX_VIEW_FILE_LENGTH,\n  MAX_VIEWS,\n  captureViewState,\n  cleanViewName,\n  emptyViewsDocument,\n  parseViewDocument,\n  parseViewFile,\n  sanitizeViewState,\n  overLimitPart,\n  savableViewState,\n  serializeViewFile,\n  viewPartKeys,\n  viewStateKey,\n  type DataGridView,\n  type DataGridViewState,\n  type DataGridViewsDocument,\n  type ViewColumns,\n  type OverLimitPart,\n} from \"./view-state\";\nimport { createLocalStorageViewsStorage, DEFAULT_VIEWS_KEY, type DataGridViewsStorage } from \"./view-storage\";\nimport { useWarnSharedViewsKey } from \"./shared-key\";\n\n/** Options for {@link useDataGridViews}. */\nexport type UseDataGridViewsOptions = {\n  /**\n   * Where views persist. A string is the `localStorage` key of the built-in storage (default\n   * `\"gridcn-views\"`); a new key loads again. An object is your own storage: remount the grid with\n   * a new `key` to switch to another one, for example another user's. The first load reads it once.\n   */\n  storage?: string | DataGridViewsStorage;\n  /** Id of the active view. Controlled: the hook opens a view when this changes, and picks only call `onValueChange`. */\n  value?: string | null;\n  /** First active view id when `value` is not set. */\n  defaultValue?: string | null;\n  onValueChange?: (id: string | null) => void;\n  /** Open the default view after load when the grid still holds its start state and `value` and `defaultValue` are unset. Default `true`. */\n  enableDefaultView?: boolean;\n  /** Called with a load or save failure. */\n  onError?: (error: unknown) => void;\n};\n\nexport type ImportViewResult =\n  | { ok: true; view: DataGridView; dropped: number }\n  | { ok: false; reason: \"too-large\" | \"invalid\" | \"limit\" | \"loading\" };\n\n/** Result of {@link useDataGridViews}. */\nexport type UseDataGridViewsResult = {\n  views: readonly DataGridView[];\n  activeViewId: string | null;\n  activeView: DataGridView | null;\n  /** The grid differs from the active view. */\n  modified: boolean;\n  /**\n   * The part of the grid state that exceeds a view limit, or `false`. `saveView` returns `null` and `updateView` returns `false` while it is set.\n   * Limits: `\"sorts\"` 64 sorts; `\"filters\"` 64 filters, 16 groups, 1,000 characters per value, 1,000 entries per value list; `\"search\"` 500 characters; `\"layout\"` a column width over 10,000 px, 1,000 entries per layout list. State of a column the grid lacks is not a limit. A filter value of the wrong shape for its operator, such as a list on `contains`, is over the `\"filters\"` limit.\n   */\n  overLimit: false | OverLimitPart;\n  defaultViewId: string | null;\n  /** The stored views are being read. */\n  loading: boolean;\n  /** A save is in flight. */\n  saving: boolean;\n  /** The latest load or save failure, else `null`. */\n  error: unknown;\n  /** Which request `error` belongs to. */\n  failed: \"load\" | \"save\" | null;\n  /** Repeats the failed load or save. Stable. */\n  retry: () => void;\n  /** Opens a view (again, to revert changes) and makes it active; `null` only clears the active view. With a controlled `value`, a pick only calls `onValueChange`. */\n  selectView: (id: string | null) => void;\n  /** Saves the grid state under `name` (trimmed, at most 80 characters) and makes the new view active. `null` for a blank name, the limit of 50 views, a grid state over a view limit (see `overLimit`), or before the load ends. */\n  saveView: (name: string) => DataGridView | null;\n  /** Replaces a view's state with the grid state. Default: the active view. `false` for an unknown id, no active view, a grid state over a view limit (see `overLimit`), or before the load ends. */\n  updateView: (id?: string) => boolean;\n  /** Renames a view. `false` for an unknown id, a blank name, or before the load ends. */\n  renameView: (id: string, name: string) => boolean;\n  /** Deletes a view; deleting the active view clears it, and deleting the default view clears the default. `false` for an unknown id or before the load ends. */\n  deleteView: (id: string) => boolean;\n  /** Makes a view the one opened after load; `null` clears it. `false` for an unknown id or before the load ends. */\n  setDefaultView: (id: string | null) => boolean;\n  /** The view as JSON text, or `null` for an unknown id or a view too large to import again. Default: the active view. */\n  exportView: (id?: string) => string | null;\n  /** Reads JSON from `exportView`, drops what the live columns lack, and saves it as a new active view named `options.name` when the file has none (`\"View\"` without either). `dropped` counts the removed parts. */\n  importView: (text: string, options?: { name?: string }) => ImportViewResult;\n};\n\n/** Calls a consumer callback; a throw must not break the hook. */\nfunction callSafely<T>(callback: ((arg: T) => void) | undefined, arg: T): void {\n  if (!callback) return;\n  try {\n    callback(arg);\n  } catch (cause) {\n    console.error(\"[data-grid-views] a callback threw\", cause);\n  }\n}\n\nfunction createViewId(): string {\n  return `v${Date.now().toString(36)}${Math.random().toString(36).slice(2, 8)}`;\n}\n\n/**\n * Saves and restores named grid views: sort, filters, search, and column layout. Call it inside the\n * grid provider. Opening a view runs the same store actions as a user gesture, only for the parts\n * that differ, so controlled `sortState` and `filterState` receive their change callbacks.\n */\nexport function useDataGridViews(options: UseDataGridViewsOptions = {}): UseDataGridViewsResult {\n  const { value, defaultValue, onValueChange, enableDefaultView = true, onError } = options;\n  const storageKey = typeof options.storage === \"string\" ? options.storage : undefined;\n  const defaultStorage = useMemo(() => createLocalStorageViewsStorage(storageKey), [storageKey]);\n  const storage = typeof options.storage === \"object\" ? options.storage : defaultStorage;\n\n  const storeApi = useDataGridStoreApi();\n  const actions = useDataGridActions();\n  const allColumns = useDataGridAllColumns();\n  const sortState = useDataGridSortState();\n  const groupBy = useDataGridSelector((s) => s.groupBy);\n  const filterState = useDataGridFilterState();\n  const filterJoin = useDataGridSelector((s) => s.filterJoin);\n  const searchText = useDataGridSearchText();\n  const searchOptions = useDataGridSelector((s) => s.searchOptions);\n  const columnLayout = useDataGridSelector((s) => s.columnLayout);\n\n  useWarnSharedViewsKey(typeof options.storage === \"object\" ? undefined : (storageKey ?? DEFAULT_VIEWS_KEY), allColumns.map((c) => c.id).join(\"\\u0000\"));\n\n  const cellTypes = useDataGridSelector((s) => s.cellTypes);\n  const registeredOperators = useCallback(\n    (column: (typeof allColumns)[number]) => new Map([...resolveCustomFilterOperators(column, column.type ? cellTypes[column.type] : undefined)].map(([id, op]) => [id, op.input ?? \"single\"] as const)),\n    [cellTypes],\n  );\n  const choiceValues = useCallback((columnId: string) => () => setFilterValuesOf(storeApi.getState())(columnId), [storeApi]);\n  const columnMap: ViewColumns = useMemo(() => new Map(allColumns.map((c) => [c.id, { sortable: c.sortable, groupable: c.groupable, filterable: c.filterable, operators: registeredOperators(c), choices: choiceValues(c.id) }])), [allColumns, registeredOperators, choiceValues]);\n  // opting a column out of sort or filter UI does not stop programmatic specs, so applying a saved view skips those flags\n  const knownColumns: ViewColumns = useMemo(() => new Map(allColumns.map((c) => [c.id, { operators: registeredOperators(c), choices: choiceValues(c.id) }])), [allColumns, registeredOperators, choiceValues]);\n  const latest = useRef({ columnMap, knownColumns, onValueChange, onError, value, enableDefaultView, defaultValue });\n  useLayoutEffect(() => {\n    latest.current = { columnMap, knownColumns, onValueChange, onError, value, enableDefaultView, defaultValue };\n  });\n\n  const [document, setDocument] = useState<DataGridViewsDocument | null>(null);\n  const documentRef = useRef<DataGridViewsDocument | null>(null);\n  const loaded = document !== null;\n  const [internalActiveId, setInternalActiveId] = useState<string | null>(defaultValue ?? null);\n  const activeViewId = value !== undefined ? value : internalActiveId;\n  const [appliedKey, setAppliedKey] = useState<string | null>(null);\n  const appliedIdRef = useRef<string | null | undefined>(undefined);\n  const [saving, setSaving] = useState(false);\n  const [error, setError] = useState<unknown>(null);\n  const [failed, setFailed] = useState<\"load\" | \"save\" | null>(null);\n  const failedRef = useRef<\"load\" | \"save\" | null>(null);\n  const [loadAttempt, setLoadAttempt] = useState(0);\n  const pendingSaveRef = useRef<DataGridViewsDocument | null>(null);\n  const savingRef = useRef(false);\n  const storageRef = useRef(storage);\n  useLayoutEffect(() => {\n    storageRef.current = storage;\n  });\n\n  const readState = useCallback((): DataGridViewState => {\n    const s = storeApi.getState();\n    return captureViewState({ sorts: s.sortState, groupBy: [...s.groupBy], filters: s.filterState, filterJoin: s.filterJoin, searchText: s.searchText, searchOptions: s.searchOptions, columnLayout: s.columnLayout });\n  }, [storeApi]);\n\n  const readSavableState = useCallback(() => savableViewState(readState()), [readState]);\n\n  const reportError = useCallback((kind: \"load\" | \"save\", cause: unknown) => {\n    failedRef.current = kind;\n    setError(cause);\n    setFailed(kind);\n    callSafely(latest.current.onError, cause);\n  }, []);\n\n  const clearError = useCallback(() => {\n    failedRef.current = null;\n    setError(null);\n    setFailed(null);\n  }, []);\n\n  const applyState = useCallback(\n    (state: DataGridViewState) => {\n      const clean = sanitizeViewState(state, latest.current.knownColumns).state;\n      const wanted = viewPartKeys(clean);\n      const now = viewPartKeys(readState());\n      if (wanted.sorts !== now.sorts) actions.setSorts(clean.sorts);\n      if (wanted.group !== now.group) actions.setGroupBy(clean.groupBy);\n      if (wanted.filters !== now.filters) {\n        actions.setFilters(clean.filters);\n        actions.setFilterJoin(clean.filterJoin ?? \"and\");\n      }\n      if (wanted.search !== now.search) actions.setSearch(clean.searchText, clean.searchOptions);\n      if (wanted.layout !== now.layout) actions.setColumnLayout(clean.columnLayout);\n      // the store fills in layout parts a view leaves out, so the baseline reads the layout back\n      setAppliedKey(viewStateKey({ ...clean, columnLayout: storeApi.getState().columnLayout }));\n    },\n    [actions, readState, storeApi],\n  );\n\n  const notify = useCallback((id: string | null) => callSafely(latest.current.onValueChange, id), []);\n\n  /** Makes `id` active for a state the grid already holds. */\n  const setActive = useCallback(\n    (id: string | null) => {\n      appliedIdRef.current = id;\n      if (latest.current.value === undefined) setInternalActiveId(id);\n      notify(id);\n    },\n    [notify],\n  );\n\n  const flushSaves = useCallback(async () => {\n    if (savingRef.current) return;\n    savingRef.current = true;\n    setSaving(true);\n    while (pendingSaveRef.current) {\n      const next = pendingSaveRef.current;\n      pendingSaveRef.current = null;\n      if (JSON.stringify(next).length > MAX_DOCUMENT_LENGTH) {\n        reportError(\"save\", new Error(\"The saved views are too large to store\"));\n        continue;\n      }\n      try {\n        await storageRef.current.save(next);\n        clearError();\n      } catch (cause) {\n        reportError(\"save\", cause);\n      }\n    }\n    savingRef.current = false;\n    setSaving(false);\n  }, [clearError, reportError]);\n\n  const commit = useCallback(\n    (next: DataGridViewsDocument) => {\n      documentRef.current = next;\n      setDocument(next);\n      pendingSaveRef.current = next;\n      void flushSaves();\n    },\n    [flushSaves],\n  );\n\n  const loadedKeyRef = useRef(storageKey);\n  useEffect(() => {\n    const controller = new AbortController();\n    documentRef.current = null;\n    setDocument(null);\n    if (loadedKeyRef.current !== storageKey) {\n      loadedKeyRef.current = storageKey;\n      appliedIdRef.current = undefined;\n      if (latest.current.value === undefined) setInternalActiveId(null);\n      notify(null);\n    }\n    void (async () => {\n      let raw: unknown;\n      try {\n        raw = await storageRef.current.load({ signal: controller.signal });\n      } catch (cause) {\n        if (!controller.signal.aborted) reportError(\"load\", cause);\n        return;\n      }\n      if (controller.signal.aborted) return;\n      const parsed = raw == null ? emptyViewsDocument() : parseViewDocument(raw);\n      if (!parsed) {\n        reportError(\"load\", new Error(\"The saved views are in an unknown format\"));\n        return;\n      }\n      documentRef.current = parsed;\n      setDocument(parsed);\n      clearError();\n      const { value: controlled, defaultValue: seed, enableDefaultView: useDefault } = latest.current;\n      const initial = storeApi.getInitialState();\n      const untouched =\n        viewStateKey(readState()) ===\n        viewStateKey(captureViewState({ sorts: initial.sortState, groupBy: [...initial.groupBy], filters: initial.filterState, filterJoin: initial.filterJoin, searchText: initial.searchText, searchOptions: initial.searchOptions, columnLayout: initial.columnLayout }));\n      const view = useDefault && controlled === undefined && seed === undefined && untouched ? parsed.views.find((v) => v.id === parsed.defaultViewId) : undefined;\n      if (view) {\n        applyState(view.state);\n        setActive(view.id);\n      }\n    })();\n    return () => controller.abort();\n  }, [storageKey, loadAttempt, storeApi, readState, applyState, setActive, notify, reportError, clearError]);\n\n  useEffect(() => {\n    if (!loaded) return;\n    const controller = new AbortController();\n    const unsubscribe = storageRef.current.subscribe?.(() => {\n      if (savingRef.current || pendingSaveRef.current) return;\n      void (async () => {\n        let raw: unknown;\n        try {\n          raw = await storageRef.current.load({ signal: controller.signal });\n        } catch (cause) {\n          if (!controller.signal.aborted) reportError(\"load\", cause);\n          return;\n        }\n        if (controller.signal.aborted || savingRef.current || pendingSaveRef.current) return;\n        const parsed = raw == null ? emptyViewsDocument() : parseViewDocument(raw);\n        if (!parsed) return;\n        documentRef.current = parsed;\n        setDocument(parsed);\n        const activeId = (latest.current.value !== undefined ? latest.current.value : appliedIdRef.current) ?? null;\n        if (activeId !== null && !parsed.views.some((view) => view.id === activeId)) setActive(null);\n      })();\n    });\n    return () => {\n      controller.abort();\n      unsubscribe?.();\n    };\n  }, [loaded, reportError, setActive]);\n\n  useEffect(() => {\n    if (!loaded || appliedIdRef.current === activeViewId) return;\n    appliedIdRef.current = activeViewId;\n    const view = documentRef.current?.views.find((v) => v.id === activeViewId);\n    if (view) applyState(view.state);\n  }, [loaded, activeViewId, applyState]);\n\n  const views = document?.views ?? EMPTY_VIEWS;\n  const activeView = views.find((v) => v.id === activeViewId) ?? null;\n\n  const currentKey = useMemo(\n    () => (activeView ? viewStateKey({ sorts: sortState, groupBy: [...groupBy], filters: filterState, filterJoin, searchText, searchOptions, columnLayout }) : null),\n    [activeView, sortState, groupBy, filterState, filterJoin, searchText, searchOptions, columnLayout],\n  );\n\n  const overLimit = useMemo(\n    () => overLimitPart(captureViewState({ sorts: sortState, groupBy: [...groupBy], filters: filterState, filterJoin, searchText, searchOptions, columnLayout })),\n    [sortState, groupBy, filterState, filterJoin, searchText, searchOptions, columnLayout],\n  );\n\n  const activeIdNow = useCallback(() => (latest.current.value !== undefined ? latest.current.value : appliedIdRef.current) ?? null, []);\n\n  const selectView = useCallback(\n    (id: string | null) => {\n      const view = id === null ? undefined : documentRef.current?.views.find((v) => v.id === id);\n      if (id !== null && !view) return;\n      const controlled = latest.current.value !== undefined;\n      if (controlled) {\n        if (view && latest.current.value === id) applyState(view.state);\n        else notify(id);\n        return;\n      }\n      if (view) applyState(view.state);\n      setActive(id);\n    },\n    [applyState, notify, setActive],\n  );\n\n  const saveView = useCallback(\n    (name: string) => {\n      const current = documentRef.current;\n      const clean = cleanViewName(name);\n      if (!current || clean === \"\" || current.views.length >= MAX_VIEWS) return null;\n      const state = readSavableState();\n      if (!state) return null;\n      const view: DataGridView = { id: createViewId(), name: clean, state };\n      commit({ ...current, views: [...current.views, view] });\n      setAppliedKey(viewStateKey(view.state));\n      setActive(view.id);\n      return view;\n    },\n    [commit, readSavableState, setActive],\n  );\n\n  const updateView = useCallback(\n    (id?: string) => {\n      const current = documentRef.current;\n      const targetId = id ?? activeIdNow();\n      if (!current || !targetId || !current.views.some((v) => v.id === targetId)) return false;\n      const state = readSavableState();\n      if (!state) return false;\n      commit({ ...current, views: current.views.map((v) => (v.id === targetId ? { ...v, state } : v)) });\n      if (targetId === activeIdNow()) setAppliedKey(viewStateKey(state));\n      return true;\n    },\n    [activeIdNow, commit, readSavableState],\n  );\n\n  const renameView = useCallback(\n    (id: string, name: string) => {\n      const current = documentRef.current;\n      const clean = cleanViewName(name);\n      if (!current || clean === \"\" || !current.views.some((v) => v.id === id)) return false;\n      commit({ ...current, views: current.views.map((v) => (v.id === id ? { ...v, name: clean } : v)) });\n      return true;\n    },\n    [commit],\n  );\n\n  const deleteView = useCallback(\n    (id: string) => {\n      const current = documentRef.current;\n      if (!current || !current.views.some((v) => v.id === id)) return false;\n      commit({ ...current, views: current.views.filter((v) => v.id !== id), defaultViewId: current.defaultViewId === id ? null : current.defaultViewId });\n      if (activeIdNow() === id) setActive(null);\n      return true;\n    },\n    [activeIdNow, commit, setActive],\n  );\n\n  const setDefaultView = useCallback(\n    (id: string | null) => {\n      const current = documentRef.current;\n      if (!current || (id !== null && !current.views.some((v) => v.id === id))) return false;\n      commit({ ...current, defaultViewId: id });\n      return true;\n    },\n    [commit],\n  );\n\n  const exportView = useCallback(\n    (id?: string) => {\n      const targetId = id ?? activeIdNow();\n      const view = documentRef.current?.views.find((v) => v.id === targetId);\n      if (!view) return null;\n      const text = serializeViewFile(view);\n      return text.length > MAX_VIEW_FILE_LENGTH ? null : text;\n    },\n    [activeIdNow],\n  );\n\n  const importView = useCallback(\n    (text: string, importOptions?: { name?: string }): ImportViewResult => {\n      const current = documentRef.current;\n      if (!current) return { ok: false, reason: \"loading\" };\n      if (current.views.length >= MAX_VIEWS) return { ok: false, reason: \"limit\" };\n      const parsed = parseViewFile(text, latest.current.columnMap);\n      if (!parsed.ok) return parsed;\n      const view: DataGridView = { id: createViewId(), name: parsed.name || cleanViewName(importOptions?.name) || \"View\", state: parsed.state };\n      commit({ ...current, views: [...current.views, view] });\n      applyState(view.state);\n      setActive(view.id);\n      return { ok: true, view, dropped: parsed.dropped };\n    },\n    [applyState, commit, setActive],\n  );\n\n  const retry = useCallback(() => {\n    if (failedRef.current === \"load\") setLoadAttempt((n) => n + 1);\n    else if (failedRef.current === \"save\" && documentRef.current) {\n      pendingSaveRef.current = documentRef.current;\n      void flushSaves();\n    }\n  }, [flushSaves]);\n\n  return {\n    views,\n    activeViewId,\n    activeView,\n    modified: currentKey !== null && appliedKey !== null && currentKey !== appliedKey,\n    overLimit,\n    defaultViewId: document?.defaultViewId ?? null,\n    loading: document === null && failed !== \"load\",\n    saving,\n    error,\n    failed,\n    retry,\n    selectView,\n    saveView,\n    updateView,\n    renameView,\n    deleteView,\n    setDefaultView,\n    exportView,\n    importView,\n  };\n}\n\nconst EMPTY_VIEWS: readonly DataGridView[] = [];\n",
      "type": "registry:component",
      "target": "components/data-grid-views/use-data-grid-views.ts"
    },
    {
      "path": "registry/default/blocks/data-grid-views/view-state.ts",
      "content": "import type { ColumnLayout, ColumnPin, BuiltInFilterOperator, FilterNode, FilterOperator, FilterOperatorInput, FilterSpec, SearchOptions, SortSpec } from \"@/registry/default/components/data-grid/data-grid\";\nimport { MAX_FILTER_GROUP_DEPTH, MAX_SPEC_SEARCH_LENGTH, MAX_GROUP_LEVELS, MAX_SPEC_SORTS, countFilterSpecs, isFilterGroup, pruneFilterSpecs } from \"@/registry/default/components/data-grid/data-grid-sdk\";\n\nexport const MAX_VIEWS = 50;\n/** Largest stored document, in characters; a save over it is refused so the next load can read it. */\nexport const MAX_DOCUMENT_LENGTH = 1_000_000;\nexport const MAX_VIEW_NAME_LENGTH = 80;\n/** Largest view file `parseViewFile` reads, in characters. */\nexport const MAX_VIEW_FILE_LENGTH = 100_000;\nconst MAX_SORTS = MAX_SPEC_SORTS;\nconst LIMIT_PARTS = [\"sorts\", \"filters\", \"search\", \"layout\"] as const;\nconst MAX_FILTERS = 64;\nconst MAX_FILTER_GROUPS = 16;\nconst MAX_LIST_ENTRIES = 1000;\nconst MAX_TEXT_LENGTH = 1000;\nconst MAX_LAYOUT_ENTRIES = 1000;\nconst MAX_COLUMN_WIDTH = 10_000;\nconst MAX_VIEW_ID_LENGTH = 64;\nconst FILE_FORMAT = \"gridcn-view\";\n\n/** The grid state a saved view restores. `groupBy` holds the group columns, outermost first; which groups are open is not saved. */\nexport type DataGridViewState = {\n  sorts: SortSpec[];\n  groupBy: string[];\n  filters: FilterNode[];\n  /** How the top-level `filters` combine. A capture stores it only as `\"or\"`; absent means `\"and\"`. */\n  filterJoin?: \"and\" | \"or\";\n  searchText: string;\n  searchOptions: Required<SearchOptions>;\n  columnLayout: ColumnLayout;\n};\n\nexport type DataGridView = { id: string; name: string; state: DataGridViewState };\n\n/** What a storage adapter persists. */\nexport type DataGridViewsDocument = { version: 1; views: DataGridView[]; defaultViewId: string | null };\n\n/** The live columns a view is checked against; `undefined` checks structure and limits only, so any column id passes. */\nexport type ViewColumns = ReadonlyMap<string, { sortable?: boolean; filterable?: boolean; groupable?: boolean; operators?: ReadonlyMap<string, FilterOperatorInput>; choices?: () => ReadonlySet<string> | undefined }>;\n\nexport type ViewFileResult = { ok: true; name: string; state: DataGridViewState; dropped: number } | { ok: false; reason: \"too-large\" | \"invalid\" };\n\nconst OPERATORS = [\n  \"contains\",\n  \"notContains\",\n  \"equals\",\n  \"notEquals\",\n  \"startsWith\",\n  \"endsWith\",\n  \"empty\",\n  \"notEmpty\",\n  \"gt\",\n  \"gte\",\n  \"lt\",\n  \"lte\",\n  \"isBetween\",\n  \"isAnyOf\",\n  \"isNoneOf\",\n] as const satisfies readonly BuiltInFilterOperator[];\n\n/** Fails to compile when a built-in operator is missing from `OPERATORS`, which would drop saved filters silently. */\nconst operatorsAreExhaustive: Exclude<BuiltInFilterOperator, (typeof OPERATORS)[number]> extends never ? true : never = true;\nvoid operatorsAreExhaustive;\n\nconst FILTER_OPERATOR_IDS: ReadonlySet<string> = new Set(OPERATORS);\n\nexport function emptyViewState(): DataGridViewState {\n  return { sorts: [], groupBy: [], filters: [], searchText: \"\", searchOptions: { matchCase: false, wholeCell: false }, columnLayout: { widths: {}, order: [], pins: {}, hidden: [] } };\n}\n\nexport function emptyViewsDocument(): DataGridViewsDocument {\n  return { version: 1, defaultViewId: null, views: [] };\n}\n\nfunction stripFilterIds(nodes: readonly FilterNode[], depth: number): FilterNode[] {\n  const out: FilterNode[] = [];\n  for (const node of nodes) {\n    if (isFilterGroup(node)) {\n      if (depth < MAX_FILTER_GROUP_DEPTH) out.push({ join: node.join, ...(node.not === true ? { not: true } : null), filters: stripFilterIds(node.filters, depth + 1) });\n    } else {\n      const { filterId: _filterId, ...spec } = node;\n      out.push(spec);\n    }\n  }\n  return out;\n}\n\n/** Copies grid state into a view state without the transient `filterId`s. */\nexport function captureViewState(source: DataGridViewState): DataGridViewState {\n  const { widths, order, pins, hidden } = source.columnLayout;\n  return {\n    sorts: source.sorts.map((s) => ({ columnId: s.columnId, direction: s.direction })),\n    groupBy: [...source.groupBy],\n    filters: stripFilterIds(source.filters, 0),\n    ...(source.filterJoin === \"or\" ? { filterJoin: \"or\" as const } : null),\n    searchText: source.searchText,\n    searchOptions: { matchCase: source.searchOptions.matchCase, wholeCell: source.searchOptions.wholeCell },\n    columnLayout: { widths: { ...widths }, order: [...order], pins: { ...pins }, hidden: [...hidden] },\n  };\n}\n\nfunction withoutUnusedValues(nodes: readonly FilterNode[]): FilterNode[] {\n  return nodes.map((node) => {\n    if (isFilterGroup(node)) return { join: node.join, ...(node.not === true ? { not: true } : null), filters: withoutUnusedValues(node.filters) };\n    return node.operator === \"empty\" || node.operator === \"notEmpty\" ? { columnId: node.columnId, operator: node.operator } : node;\n  });\n}\n\nfunction sortKeys(_key: string, value: unknown): unknown {\n  if (value === null || typeof value !== \"object\" || Array.isArray(value)) return value;\n  return Object.fromEntries(Object.entries(value).sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0)));\n}\n\nexport type ViewStatePart = \"sorts\" | \"filters\" | \"search\" | \"layout\";\n\n/** The part of a view state that a view limit cuts. */\nexport type OverLimitPart = ViewStatePart;\n\n/** One string per part of a state; equal strings mean the part restores the same grid. */\nexport function viewPartKeys(state: DataGridViewState): Record<ViewStatePart | \"group\", string> {\n  // lossless except for the one thing storage drops: the unused `value` of `empty` and `notEmpty`\n  const captured = captureViewState(state);\n  captured.filters = withoutUnusedValues(captured.filters);\n  captured.columnLayout.hidden.sort();\n  return {\n    sorts: JSON.stringify(captured.sorts),\n    group: JSON.stringify(captured.groupBy),\n    filters: JSON.stringify(captured.filters, sortKeys) + (captured.filterJoin === \"or\" ? \"|or\" : \"\"),\n    search: JSON.stringify([captured.searchText, captured.searchOptions]),\n    layout: JSON.stringify(captured.columnLayout, sortKeys),\n  };\n}\n\n/** A string that is equal for two states that restore the same view. */\nexport function viewStateKey(state: DataGridViewState): string {\n  return Object.values(viewPartKeys(state)).join(\"|\");\n}\n\n/** The part of `state` that a view limit would cut or drop, or `false` when none. A column the grid lacks is not a limit. Layout covers a width over 10,000 px and a list over 1,000 entries. */\nexport function overLimitPart(state: DataGridViewState): OverLimitPart | false {\n  const kept = viewPartKeys(sanitizeViewState(state).state);\n  const wanted = viewPartKeys(state);\n  return LIMIT_PARTS.find((part) => kept[part] !== wanted[part]) ?? false;\n}\n\n/** The state in the form that reloads unchanged, or `null` when a view limit would cut or drop part of it. */\nexport function savableViewState(state: DataGridViewState): DataGridViewState | null {\n  const clean = sanitizeViewState(state).state;\n  return viewStateKey(clean) === viewStateKey(state) ? clean : null;\n}\n\ntype RawSort = { columnId?: unknown; direction?: unknown };\ntype RawFilter = { columnId?: unknown; operator?: unknown; value?: unknown; join?: unknown; not?: unknown; filters?: unknown };\ntype RawLayout = { widths?: unknown; order?: unknown; pins?: unknown; hidden?: unknown };\ntype RawState = { sorts?: unknown; groupBy?: unknown; filters?: unknown; filterJoin?: unknown; searchText?: unknown; searchOptions?: unknown; columnLayout?: unknown };\ntype RawSearchOptions = { matchCase?: unknown; wholeCell?: unknown };\ntype RawView = { id?: unknown; name?: unknown; state?: unknown };\ntype RawDocument = { version?: unknown; views?: unknown; defaultViewId?: unknown };\ntype RawFile = { format?: unknown; version?: unknown; name?: unknown; state?: unknown };\n\n/** Narrows untrusted JSON to a plain object whose fields are all `unknown`. */\nfunction asRecord<T extends object>(value: unknown): T | undefined {\n  return typeof value === \"object\" && value !== null && !Array.isArray(value) ? (value as T) : undefined;\n}\n\n/** Counts the entries beyond `cap` as dropped, then returns the first `cap`. */\nfunction boundedEntries<T>(entries: readonly T[], cap: number, tally: Tally): readonly T[] {\n  if (entries.length > cap) tally.dropped += entries.length - cap;\n  return entries.slice(0, cap);\n}\n\ntype Tally = { dropped: number };\n\n/** An id passes when it is a usable key and, given a column set, names a live column. */\nfunction acceptsColumnId(id: unknown, columns: ViewColumns | undefined): id is string {\n  if (typeof id !== \"string\" || id === \"\") return false;\n  return columns ? columns.has(id) : true;\n}\n\n/** Ids of live groupable columns, once each, at most {@link MAX_GROUP_LEVELS}; a longer list is cut and counted. */\nfunction sanitizeGroupBy(raw: unknown, columns: ViewColumns | undefined, tally: Tally): string[] {\n  if (!Array.isArray(raw)) return [];\n  const ids: string[] = [];\n  for (const id of boundedEntries(raw, MAX_LIST_ENTRIES, tally)) {\n    if (!acceptsColumnId(id, columns) || columns?.get(id)?.groupable === false || ids.includes(id) || ids.length >= MAX_GROUP_LEVELS) tally.dropped++;\n    else ids.push(id);\n  }\n  return ids;\n}\n\nfunction sanitizeSorts(raw: unknown, columns: ViewColumns | undefined, tally: Tally): SortSpec[] {\n  if (!Array.isArray(raw)) return [];\n  const sorts: SortSpec[] = [];\n  const seen = new Set<string>();\n  for (const item of boundedEntries(raw, MAX_LIST_ENTRIES, tally)) {\n    const entry = asRecord<RawSort>(item);\n    const columnId = entry?.columnId;\n    const direction = entry?.direction;\n    if (!acceptsColumnId(columnId, columns) || columns?.get(columnId)?.sortable === false || (direction !== \"asc\" && direction !== \"desc\") || seen.has(columnId) || sorts.length >= MAX_SORTS) {\n      tally.dropped++;\n      continue;\n    }\n    seen.add(columnId);\n    sorts.push({ columnId, direction });\n  }\n  return sorts;\n}\n\ntype FilterBudget = { leaves: number; groups: number };\n\nfunction sanitizeFilterValue(operator: string, raw: unknown, tally: Tally): { ok: true; value: FilterSpec[\"value\"] } | { ok: false } {\n  const text = (v: unknown): v is string => typeof v === \"string\" && v.length <= MAX_TEXT_LENGTH;\n  if (operator === \"empty\" || operator === \"notEmpty\") return { ok: true, value: undefined };\n  if (operator === \"isBetween\") return Array.isArray(raw) && raw.length === 2 && text(raw[0]) && text(raw[1]) ? { ok: true, value: [raw[0], raw[1]] } : { ok: false };\n  if (operator === \"isAnyOf\" || operator === \"isNoneOf\") {\n    if (!Array.isArray(raw) || !raw.every(text)) return { ok: false };\n    // a truncated exclusion list would match more rows than the view meant\n    if (raw.length > MAX_LIST_ENTRIES) {\n      if (operator === \"isNoneOf\") return { ok: false };\n      tally.dropped += raw.length - MAX_LIST_ENTRIES;\n      return { ok: true, value: raw.slice(0, MAX_LIST_ENTRIES) };\n    }\n    return { ok: true, value: [...raw] };\n  }\n  if (raw === undefined) return { ok: true, value: undefined };\n  return text(raw) ? { ok: true, value: raw } : { ok: false };\n}\n\nfunction sanitizeCustomValue(input: FilterOperatorInput | \"any\", raw: unknown): { ok: true; value: FilterSpec[\"value\"] } | { ok: false } {\n  const text = (v: unknown): v is string => typeof v === \"string\" && v.length <= MAX_TEXT_LENGTH;\n  if (input === \"none\") return { ok: true, value: undefined };\n  if (input === \"single\") return text(raw) ? { ok: true, value: raw } : { ok: false };\n  if (input === \"range\") return Array.isArray(raw) && raw.length === 2 && text(raw[0]) && text(raw[1]) ? { ok: true, value: [raw[0], raw[1]] } : { ok: false };\n  if (input === \"list\" || Array.isArray(raw)) {\n    if (!Array.isArray(raw) || !raw.every(text)) return { ok: false };\n    if (raw.length > MAX_LIST_ENTRIES) return { ok: false };\n    return { ok: true, value: [...raw] };\n  }\n  if (raw === undefined) return { ok: true, value: undefined };\n  return text(raw) ? { ok: true, value: raw } : { ok: false };\n}\n\nfunction sanitizeOperatorValue(operator: unknown, columnId: unknown, raw: unknown, columns: ViewColumns | undefined, tally: Tally): { ok: true; value: FilterSpec[\"value\"] } | { ok: false } {\n  if (typeof operator !== \"string\") return { ok: false };\n  if (FILTER_OPERATOR_IDS.has(operator)) return sanitizeFilterValue(operator, raw, tally);\n  if (operator.length === 0) return { ok: false };\n  // a live-grid snapshot has no column map; a column map accepts only operators the column registers\n  if (!columns) return sanitizeCustomValue(\"any\", raw);\n  const input = typeof columnId === \"string\" ? columns.get(columnId)?.operators?.get(operator) : undefined;\n  return input ? sanitizeCustomValue(input, raw) : { ok: false };\n}\n\n/** The blank entry and the list entries whose lowercased text `choices` holds; `null` when none of a non-empty list is left. */\nfunction knownChoices(operator: unknown, value: FilterSpec[\"value\"], readChoices: (() => ReadonlySet<string> | undefined) | undefined, tally: Tally): FilterSpec[\"value\"] | null {\n  if ((operator !== \"isAnyOf\" && operator !== \"isNoneOf\") || !Array.isArray(value)) return value;\n  const choices = readChoices?.();\n  if (!choices) return value;\n  const kept = value.filter((entry) => entry === \"\" || choices.has(entry.toLowerCase()));\n  tally.dropped += value.length - kept.length;\n  return kept.length === 0 && value.length > 0 ? null : kept;\n}\n\nfunction sanitizeFilterNodes(raw: unknown, depth: number, columns: ViewColumns | undefined, budget: FilterBudget, tally: Tally): FilterNode[] {\n  if (!Array.isArray(raw)) return [];\n  const out: FilterNode[] = [];\n  for (const item of boundedEntries(raw, MAX_FILTERS * 4, tally)) {\n    const entry = asRecord<RawFilter>(item);\n    if (!entry) {\n      tally.dropped++;\n      continue;\n    }\n    if (Array.isArray(entry.filters)) {\n      const join = entry.join;\n      if ((join !== \"and\" && join !== \"or\") || depth >= MAX_FILTER_GROUP_DEPTH || budget.groups >= MAX_FILTER_GROUPS) {\n        tally.dropped++;\n        continue;\n      }\n      budget.groups++;\n      const droppedBefore = tally.dropped;\n      const children = sanitizeFilterNodes(entry.filters, depth + 1, columns, budget, tally);\n      const negated = entry.not === true;\n      // a negated group missing a term would match different rows, so it goes whole\n      if (children.length === 0 || (negated && tally.dropped > droppedBefore)) tally.dropped++;\n      else out.push(negated ? { join, not: true, filters: children } : { join, filters: children });\n      continue;\n    }\n    const { columnId, operator } = entry;\n    const value = sanitizeOperatorValue(operator, columnId, entry.value, columns, tally);\n    if (!acceptsColumnId(columnId, columns) || columns?.get(columnId)?.filterable === false || !value.ok || budget.leaves >= MAX_FILTERS) {\n      tally.dropped++;\n      continue;\n    }\n    const known = knownChoices(operator, value.value, columns?.get(columnId)?.choices, tally);\n    if (known === null) continue;\n    budget.leaves++;\n    const spec: FilterSpec = { columnId, operator: operator as FilterOperator };\n    if (known !== undefined) spec.value = known;\n    out.push(spec);\n  }\n  return out;\n}\n\nfunction sanitizeIdList(raw: unknown, columns: ViewColumns | undefined, tally: Tally): string[] {\n  if (!Array.isArray(raw)) return [];\n  const seen = new Set<string>();\n  for (const id of boundedEntries(raw, MAX_LAYOUT_ENTRIES, tally)) {\n    if (acceptsColumnId(id, columns) && !seen.has(id)) seen.add(id);\n    else tally.dropped++;\n  }\n  return [...seen];\n}\n\nfunction sanitizeLayout(raw: unknown, columns: ViewColumns | undefined, tally: Tally): ColumnLayout {\n  const layout = asRecord<RawLayout>(raw) ?? {};\n  const widths: [string, number][] = [];\n  const pins: [string, ColumnPin][] = [];\n  const widthEntries = boundedEntries(Object.entries(asRecord<Record<string, unknown>>(layout.widths) ?? {}), MAX_LAYOUT_ENTRIES, tally);\n  for (const [id, width] of widthEntries) {\n    if (acceptsColumnId(id, columns) && typeof width === \"number\" && Number.isFinite(width) && width > 0 && width <= MAX_COLUMN_WIDTH) widths.push([id, width]);\n    else tally.dropped++;\n  }\n  const pinEntries = boundedEntries(Object.entries(asRecord<Record<string, unknown>>(layout.pins) ?? {}), MAX_LAYOUT_ENTRIES, tally);\n  for (const [id, side] of pinEntries) {\n    const pin = side === \"start\" || side === \"left\" ? \"start\" : side === \"end\" || side === \"right\" ? \"end\" : null;\n    if (acceptsColumnId(id, columns) && pin) pins.push([id, pin]);\n    else tally.dropped++;\n  }\n  return {\n    widths: Object.fromEntries(widths),\n    order: sanitizeIdList(layout.order, columns, tally),\n    pins: Object.fromEntries(pins),\n    hidden: sanitizeIdList(layout.hidden, columns, tally),\n  };\n}\n\n/**\n * Checks untrusted view state: unknown shapes, operators, and columns drop, lists and strings are\n * bounded. `dropped` counts every rejected or cut entry so the caller can tell the user; text cut to its limit is not counted.\n */\nexport function sanitizeViewState(raw: unknown, columns?: ViewColumns): { state: DataGridViewState; dropped: number } {\n  const source = asRecord<RawState>(raw);\n  if (!source) return { state: emptyViewState(), dropped: 0 };\n  const tally: Tally = { dropped: 0 };\n  const options = asRecord<RawSearchOptions>(source.searchOptions) ?? {};\n  return {\n    state: {\n      sorts: sanitizeSorts(source.sorts, columns, tally),\n      groupBy: sanitizeGroupBy(source.groupBy, columns, tally),\n      filters: sanitizeFilterNodes(source.filters, 0, columns, { leaves: 0, groups: 0 }, tally),\n      ...(source.filterJoin === \"or\" ? { filterJoin: \"or\" as const } : null),\n      searchText: typeof source.searchText === \"string\" ? source.searchText.slice(0, MAX_SPEC_SEARCH_LENGTH) : \"\",\n      searchOptions: { matchCase: options.matchCase === true, wholeCell: options.wholeCell === true },\n      columnLayout: sanitizeLayout(source.columnLayout, columns, tally),\n    },\n    dropped: tally.dropped,\n  };\n}\n\nexport function cleanViewName(raw: unknown): string {\n  return typeof raw === \"string\" ? raw.trim().slice(0, MAX_VIEW_NAME_LENGTH) : \"\";\n}\n\n/** Reads a stored document, or `null` when `raw` is not a version 1 document. A view keeps the columns that return later, so ids are not checked against the live columns. */\nexport function parseViewDocument(raw: unknown): DataGridViewsDocument | null {\n  const source = asRecord<RawDocument>(raw);\n  if (!source || source.version !== 1 || !Array.isArray(source.views)) return null;\n  const views: DataGridView[] = [];\n  const ids = new Set<string>();\n  for (const item of source.views.slice(0, MAX_VIEWS * 2)) {\n    if (views.length >= MAX_VIEWS) break;\n    const entry = asRecord<RawView>(item);\n    const id = entry?.id;\n    if (typeof id !== \"string\" || id === \"\" || id.length > MAX_VIEW_ID_LENGTH || ids.has(id)) continue;\n    const name = cleanViewName(entry?.name);\n    if (name === \"\") continue;\n    ids.add(id);\n    views.push({ id, name, state: sanitizeViewState(entry?.state).state });\n  }\n  const defaultViewId = typeof source.defaultViewId === \"string\" && ids.has(source.defaultViewId) ? source.defaultViewId : null;\n  return { version: 1, defaultViewId, views };\n}\n\n/** The text `exportView` returns and `importView` reads. */\nexport function serializeViewFile(view: Pick<DataGridView, \"name\" | \"state\">): string {\n  return JSON.stringify({ format: FILE_FORMAT, version: 1, name: view.name, state: view.state });\n}\n\nexport function parseViewFile(text: string, columns: ViewColumns): ViewFileResult {\n  if (text.length > MAX_VIEW_FILE_LENGTH) return { ok: false, reason: \"too-large\" };\n  let raw: unknown;\n  try {\n    raw = JSON.parse(text);\n  } catch {\n    return { ok: false, reason: \"invalid\" };\n  }\n  const file = asRecord<RawFile>(raw);\n  if (!file || file.format !== FILE_FORMAT || file.version !== 1 || !asRecord(file.state)) return { ok: false, reason: \"invalid\" };\n  const sanitized = sanitizeViewState(file.state, columns);\n  const hidden = new Set(sanitized.state.columnLayout.hidden);\n  const sorts = sanitized.state.sorts.filter((s) => !hidden.has(s.columnId));\n  const groupBy = sanitized.state.groupBy.filter((id) => !hidden.has(id));\n  const filters = pruneFilterSpecs(sanitized.state.filters, (spec) => !hidden.has(spec.columnId), true);\n  const dropped = sanitized.dropped + (sanitized.state.sorts.length - sorts.length) + (sanitized.state.groupBy.length - groupBy.length) + (countFilterSpecs(sanitized.state.filters) - countFilterSpecs(filters));\n  return { ok: true, name: cleanViewName(file.name), state: { ...sanitized.state, sorts, groupBy, filters }, dropped };\n}\n",
      "type": "registry:component",
      "target": "components/data-grid-views/view-state.ts"
    },
    {
      "path": "registry/default/blocks/data-grid-views/view-storage.ts",
      "content": "import { MAX_DOCUMENT_LENGTH, type DataGridViewsDocument } from \"./view-state\";\n\n/**\n * Where saved views live. `load` returns the stored document (any shape; the hook validates it) or\n * `undefined` for none. Throw from `load` when the store cannot be read, so the hook keeps the\n * stored views instead of replacing them. `load` gets a signal that aborts on unmount. `save`\n * receives the whole document and is never aborted, so a save started just before unmount still\n * lands. Both may be sync or async. `subscribe` is optional: call `onChange` when another writer changed\n * the stored document, and the hook loads it again. Return a function that removes the subscription.\n */\nexport type DataGridViewsStorage = {\n  load: (ctx: { signal: AbortSignal }) => unknown | Promise<unknown>;\n  save: (document: DataGridViewsDocument) => void | Promise<void>;\n  subscribe?: (onChange: () => void) => () => void;\n};\n\n/** Keeps views for the life of the page. */\nexport function createMemoryViewsStorage(seed?: DataGridViewsDocument): DataGridViewsStorage {\n  let document = seed;\n  return {\n    load: () => document,\n    save: (next) => {\n      document = next;\n    },\n  };\n}\n\nfunction readStorage(): Storage | undefined {\n  try {\n    return globalThis.localStorage;\n  } catch {\n    return undefined;\n  }\n}\n\nconst memoryByKey = new Map<string, DataGridViewsDocument>();\n// The storage event reaches other tabs only, so a save tells the subscribers of its key on this page itself.\nconst pageListenersByKey = new Map<string, Set<() => void>>();\n\nfunction notifyPage(key: string): void {\n  pageListenersByKey.get(key)?.forEach((listener) => listener());\n}\n\nexport const DEFAULT_VIEWS_KEY = \"gridcn-views\";\n\n/**\n * Stores views as one JSON entry in `localStorage`. A save in another tab, or in another grid of this page with the same key, reloads the views here. When the browser blocks or fills the store,\n * `save` keeps the document in memory for this page and throws, so the hook reports the failure; `load`\n * returns the memory copy until a save succeeds. Malformed text counts as no document; text over the size limit throws.\n * `key` defaults to `\"gridcn-views\"`.\n */\nexport function createLocalStorageViewsStorage(key = DEFAULT_VIEWS_KEY): DataGridViewsStorage {\n  return {\n    load: () => {\n      const unsaved = memoryByKey.get(key);\n      if (unsaved) return unsaved;\n      let text: string | null | undefined;\n      try {\n        text = readStorage()?.getItem(key);\n      } catch {\n        return undefined;\n      }\n      if (text == null) return undefined;\n      if (text.length > MAX_DOCUMENT_LENGTH) throw new Error(\"The stored views are too large to read\");\n      try {\n        return JSON.parse(text) as unknown;\n      } catch {\n        return undefined;\n      }\n    },\n    subscribe: (onChange) => {\n      const onStorage = (event: StorageEvent) => {\n        if (event.key === key || event.key === null) onChange();\n      };\n      globalThis.addEventListener?.(\"storage\", onStorage);\n      const listeners = pageListenersByKey.get(key) ?? new Set();\n      pageListenersByKey.set(key, listeners);\n      listeners.add(onChange);\n      return () => {\n        globalThis.removeEventListener?.(\"storage\", onStorage);\n        listeners.delete(onChange);\n        if (listeners.size === 0) pageListenersByKey.delete(key);\n      };\n    },\n    save: (next) => {\n      try {\n        const store = readStorage();\n        if (!store) throw new Error(\"Browser storage is not available\");\n        store.setItem(key, JSON.stringify(next));\n        memoryByKey.delete(key);\n      } catch (cause) {\n        memoryByKey.set(key, next);\n        throw cause;\n      } finally {\n        notifyPage(key);\n      }\n    },\n  };\n}\n",
      "type": "registry:component",
      "target": "components/data-grid-views/view-storage.ts"
    },
    {
      "path": "registry/default/blocks/data-grid-views/shared-key.ts",
      "content": "import { useEffect } from \"react\";\nimport { isDev } from \"@/registry/default/components/data-grid/data-grid-sdk\";\n\nconst mounted = new Map<string, Map<symbol, string>>();\nconst warned = new Set<string>();\n\n/** Warns once per key in development when mounted grids with other columns share one `localStorage` key of the built-in storage. */\nexport function useWarnSharedViewsKey(key: string | undefined, columnIds: string): void {\n  useEffect(() => {\n    if (key === undefined || !isDev()) return;\n    const token = Symbol(key);\n    const instances = mounted.get(key) ?? new Map<symbol, string>();\n    mounted.set(key, instances);\n    instances.set(token, columnIds);\n    if (!warned.has(key) && new Set(instances.values()).size > 1) {\n      warned.add(key);\n      console.warn(`[data-grid-views] two mounted grids with other columns share the views storage key \"${key}\", so each loads and overwrites the views of the other; pass each grid its own \\`storage\\` key`);\n    }\n    return () => {\n      instances.delete(token);\n      if (instances.size === 0) mounted.delete(key);\n    };\n  }, [key, columnIds]);\n}\n",
      "type": "registry:component",
      "target": "components/data-grid-views/shared-key.ts"
    },
    {
      "path": "registry/default/blocks/data-grid-views/views-menu.tsx",
      "content": "\"use client\";\n\nimport { useRef, useState, type KeyboardEvent } from \"react\";\nimport { Bookmark, Check, Pencil, Star, Trash2 } from \"lucide-react\";\nimport { cn } from \"@/lib/utils\";\nimport { Badge } from \"@/components/ui/badge\";\nimport { Button } from \"@/components/ui/button\";\nimport { ButtonGroup } from \"@/components/ui/button-group\";\nimport { InputGroup, InputGroupAddon, InputGroupButton, InputGroupInput } from \"@/components/ui/input-group\";\nimport { Popover, PopoverContent, PopoverTrigger } from \"@/components/ui/popover\";\nimport { Textarea } from \"@/components/ui/textarea\";\nimport { isComposingKey, mergeLabelLayers } from \"@/registry/default/components/data-grid/data-grid-sdk\";\nimport { DEFAULT_LABELS, useDataGridLabels, type DataGridViewsLabels } from \"@/registry/default/components/data-grid/data-grid\";\nimport { useDataGridViews, type UseDataGridViewsOptions } from \"./use-data-grid-views\";\nimport { MAX_VIEWS, MAX_VIEW_FILE_LENGTH, MAX_VIEW_NAME_LENGTH, type DataGridView } from \"./view-state\";\n\n/** Props for {@link DataGridViews}: the options of {@link useDataGridViews} plus styling. */\nexport type DataGridViewsProps = UseDataGridViewsOptions & {\n  className?: string;\n  /** Overrides for the menu's strings, merged key by key over the grid's `labels.views`, which sit over the built-in English defaults. */\n  labels?: Partial<DataGridViewsLabels>;\n};\n\nfunction ViewRow({\n  view,\n  active,\n  isDefault,\n  labels,\n  onSelect,\n  onSetDefault,\n  onRename,\n  onDelete,\n  onAfterDelete,\n}: {\n  view: DataGridView;\n  active: boolean;\n  isDefault: boolean;\n  labels: DataGridViewsLabels;\n  onSelect: () => void;\n  onSetDefault: () => void;\n  onRename: (name: string) => void;\n  onDelete: () => void;\n  onAfterDelete: () => void;\n}) {\n  const renameButton = useRef<HTMLButtonElement>(null);\n  const [editing, setEditing] = useState(false);\n  const [name, setName] = useState(view.name);\n  const [confirming, setConfirming] = useState(false);\n\n  const stopEditing = () => {\n    setEditing(false);\n    requestAnimationFrame(() => renameButton.current?.focus());\n  };\n  const commitRename = () => {\n    stopEditing();\n    if (name.trim() !== \"\" && name.trim() !== view.name) onRename(name);\n  };\n  const onKeyDown = (event: KeyboardEvent<HTMLInputElement>) => {\n    if (isComposingKey(event)) return;\n    if (event.key === \"Enter\") {\n      event.preventDefault();\n      commitRename();\n    } else if (event.key === \"Escape\") {\n      event.preventDefault();\n      event.stopPropagation();\n      stopEditing();\n    }\n  };\n\n  if (editing) {\n    return (\n      <li>\n        <InputGroup>\n          <InputGroupInput value={name} maxLength={MAX_VIEW_NAME_LENGTH} aria-label={labels.rename(view.name)} autoFocus onChange={(e) => setName(e.target.value)} onKeyDown={onKeyDown} />\n          <InputGroupAddon align=\"inline-end\">\n            <InputGroupButton variant=\"secondary\" onClick={commitRename}>\n              {labels.confirmRename}\n            </InputGroupButton>\n            <InputGroupButton onClick={stopEditing}>{labels.cancel}</InputGroupButton>\n          </InputGroupAddon>\n        </InputGroup>\n      </li>\n    );\n  }\n\n  return (\n    <li data-active={active ? \"\" : undefined}>\n      <ButtonGroup className=\"w-full\">\n      <Button type=\"button\" variant=\"outline\" size=\"sm\" className=\"min-w-0 flex-1 justify-start\" aria-current={active ? \"true\" : undefined} onClick={onSelect}>\n        {active ? <Check /> : null}\n        <span className=\"truncate\">{view.name}</span>\n      </Button>\n      <Button type=\"button\" variant=\"outline\" size=\"icon-sm\" aria-pressed={isDefault} aria-label={isDefault ? labels.unsetDefault(view.name) : labels.setDefault(view.name)} onClick={onSetDefault}>\n        <Star className={cn(isDefault && \"fill-current\")} />\n      </Button>\n      <Button\n        type=\"button\"\n        variant=\"outline\"\n        size=\"icon-sm\"\n        ref={renameButton}\n        aria-label={labels.rename(view.name)}\n        onClick={() => {\n          setName(view.name);\n          setEditing(true);\n        }}\n      >\n        <Pencil />\n      </Button>\n      <Button\n        type=\"button\"\n        variant={confirming ? \"destructive\" : \"outline\"}\n        size=\"icon-sm\"\n        aria-label={confirming ? labels.confirmDelete(view.name) : labels.delete(view.name)}\n        onBlur={() => setConfirming(false)}\n        onClick={() => {\n          if (!confirming) return setConfirming(true);\n          onDelete();\n          onAfterDelete();\n        }}\n      >\n        <Trash2 />\n      </Button>\n      </ButtonGroup>\n    </li>\n  );\n}\n\n/**\n * Toolbar popover to pick, save, update, rename, delete, default, export, and import grid views.\n * Place it inside the grid provider, for example in `DataGridToolbar`. It takes the options of\n * {@link useDataGridViews}.\n */\nexport function DataGridViews({ className, labels: labelOverrides, ...options }: DataGridViewsProps) {\n  const gridLabels = useDataGridLabels();\n  const labels = mergeLabelLayers<DataGridViewsLabels>(DEFAULT_LABELS.views, gridLabels.views, labelOverrides);\n  const views = useDataGridViews(options);\n  const [newName, setNewName] = useState(\"\");\n  const [fileText, setFileText] = useState(\"\");\n  const [message, setMessage] = useState({ text: \"\", id: 0 });\n  const [problem, setProblem] = useState(\"\");\n  const nameField = useRef<HTMLInputElement>(null);\n  const { activeView } = views;\n  const announce = (text: string) => {\n    setProblem(\"\");\n    setMessage((previous) => ({ text, id: previous.id + 1 }));\n  };\n  const fail = (text: string) => {\n    setProblem(text);\n    setMessage((previous) => ({ text, id: previous.id + 1 }));\n  };\n  const focusNameField = () => requestAnimationFrame(() => nameField.current?.focus());\n  const atLimit = views.views.length >= MAX_VIEWS;\n  const canSave = !views.loading && views.failed !== \"load\" && !atLimit && !views.overLimit && newName.trim() !== \"\";\n\n  const save = () => {\n    if (!canSave) return;\n    const saved = views.saveView(newName);\n    if (!saved) return;\n    setNewName(\"\");\n    announce(labels.saved(saved.name));\n  };\n  const onSaveKeyDown = (event: KeyboardEvent<HTMLInputElement>) => {\n    if (isComposingKey(event) || event.key !== \"Enter\") return;\n    event.preventDefault();\n    save();\n  };\n  const runImport = () => {\n    const result = views.importView(fileText, { name: labels.importedName });\n    if (result.ok) {\n      setFileText(\"\");\n      announce(labels.imported(result.view.name, result.dropped));\n      focusNameField();\n    } else {\n      fail(labels.importFailed(result.reason));\n    }\n  };\n\n  return (\n    <Popover>\n      <PopoverTrigger\n        render={\n          <Button type=\"button\" variant=\"outline\" size=\"sm\" className={cn(\"relative\", className)} data-modified={views.modified ? \"\" : undefined}>\n            <Bookmark />\n            <span className=\"max-w-40 truncate\">{activeView?.name ?? labels.views}</span>\n            {views.modified ? <Badge variant=\"secondary\">{labels.modified}</Badge> : null}\n          </Button>\n        }\n      />\n      <PopoverContent align=\"start\" className=\"max-h-(--available-height) w-80 gap-3 overflow-y-auto p-3\" aria-label={labels.views}>\n        <div data-grid-views=\"\" className=\"flex flex-col gap-3\">\n          {views.loading ? <p className=\"text-muted-foreground\">{labels.loading}</p> : null}\n          {views.failed ? (\n            <div role=\"alert\" className=\"flex items-center justify-between gap-2 text-destructive\">\n              <span>{views.failed === \"load\" ? labels.loadFailed : labels.saveFailed}</span>\n              <Button type=\"button\" size=\"sm\" variant=\"outline\" onClick={views.retry}>\n                {labels.retry}\n              </Button>\n            </div>\n          ) : null}\n          {!views.loading && views.failed !== \"load\" && views.views.length === 0 ? <p className=\"text-muted-foreground\">{labels.empty}</p> : null}\n          {views.views.length > 0 ? (\n            <ul className=\"flex flex-col gap-1\" aria-label={labels.views}>\n              {views.views.map((view) => (\n                <ViewRow\n                  key={view.id}\n                  view={view}\n                  active={view.id === views.activeViewId}\n                  isDefault={view.id === views.defaultViewId}\n                  labels={labels}\n                  onSelect={() => {\n                    views.selectView(view.id);\n                    announce(labels.applied(view.name));\n                  }}\n                  onSetDefault={() => views.setDefaultView(view.id === views.defaultViewId ? null : view.id)}\n                  onRename={(name) => {\n                    if (views.renameView(view.id, name)) announce(labels.renamed(name.trim()));\n                  }}\n                  onDelete={() => {\n                    if (views.deleteView(view.id)) announce(labels.deleted(view.name));\n                  }}\n                  onAfterDelete={focusNameField}\n                />\n              ))}\n            </ul>\n          ) : null}\n          {activeView && views.modified ? (\n            <Button\n              type=\"button\"\n              variant=\"outline\"\n              size=\"sm\"\n              disabled={views.overLimit !== false}\n              onClick={() => {\n                if (views.updateView()) {\n                  announce(labels.updated(activeView.name));\n                  focusNameField();\n                }\n              }}\n            >\n              {labels.updateActive(activeView.name)}\n            </Button>\n          ) : null}\n          <InputGroup>\n            <InputGroupInput ref={nameField} value={newName} maxLength={MAX_VIEW_NAME_LENGTH} placeholder={labels.newViewName} aria-label={labels.newViewName} onChange={(e) => setNewName(e.target.value)} onKeyDown={onSaveKeyDown} />\n            <InputGroupAddon align=\"inline-end\">\n              <InputGroupButton variant=\"secondary\" disabled={!canSave} onClick={save}>\n                {labels.saveNew}\n              </InputGroupButton>\n            </InputGroupAddon>\n          </InputGroup>\n          <div className=\"flex flex-col gap-1.5\">\n            <Textarea\n              value={fileText}\n              onChange={(e) => setFileText(e.target.value)}\n              maxLength={MAX_VIEW_FILE_LENGTH * 2}\n              aria-label={labels.fileLabel}\n              spellCheck={false}\n              rows={4}\n              className=\"max-h-40 resize-y font-mono text-xs\"\n            />\n            <ButtonGroup>\n              <Button\n                type=\"button\"\n                variant=\"outline\"\n                size=\"sm\"\n                disabled={!activeView}\n                onClick={() => {\n                  const text = views.exportView();\n                  if (text === null) return fail(labels.exportTooLarge);\n                  setFileText(text);\n                  announce(labels.exported);\n                }}\n              >\n                {labels.exportView}\n              </Button>\n              <Button type=\"button\" variant=\"outline\" size=\"sm\" disabled={fileText.trim() === \"\"} onClick={runImport}>\n                {labels.importView}\n              </Button>\n            </ButtonGroup>\n          </div>\n          {atLimit ? <p className=\"text-muted-foreground\">{labels.limit}</p> : null}\n          {views.overLimit ? <p className=\"text-muted-foreground\">{labels.overLimit(views.overLimit)}</p> : null}\n          {problem ? <p className=\"text-destructive\">{problem}</p> : null}\n          <p role=\"status\" className=\"sr-only\">\n            {/* a trailing no-break space on every second message makes a repeated text change, so it is announced again */}\n            {message.text}\n            {message.id % 2 === 0 ? \" \" : \"\"}\n          </p>\n        </div>\n      </PopoverContent>\n    </Popover>\n  );\n}\n",
      "type": "registry:component",
      "target": "components/data-grid-views/views-menu.tsx"
    }
  ],
  "categories": [
    "data"
  ],
  "type": "registry:block"
}
