@standardbeagle/edit-db 0.4.484 → 0.4.581

package/dist/hooks/useColumnNav.d.ts

@@ -1,7 +1,7 @@
 import { ReactNode } from 'react';
-import { ColumnPanel } from '../data-panel';
+import { DrillFrame } from '../lib/drill-stack';
 interface ColumnNavEntry {
-    panel: ColumnPanel;
+    panel: DrillFrame;
     element: HTMLElement | null;
 }
 interface ColumnNavState {
@@ -13,7 +13,7 @@ interface ColumnNavState {
 }
 interface ColumnNavRegistration {
     mainTable: string | null;
-    columns: ColumnPanel[];
+    columns: DrillFrame[];
     columnRefs: Map<number, HTMLElement | null>;
     onClose: (index: number) => void;
 }

package/dist/hooks/useColumnSizingPersistence.d.ts

@@ -0,0 +1,19 @@
+import { ColumnSizingState } from '@tanstack/react-table';
+export declare const COL_MIN_WIDTH = 60;
+export declare const COL_MAX_AUTO_WIDTH = 450;
+export declare const COL_DEFAULT_WIDTH = 150;
+export interface UseColumnSizingPersistenceResult {
+    columnSizing: ColumnSizingState;
+    setColumnSizing: React.Dispatch<React.SetStateAction<ColumnSizingState>>;
+}
+/**
+ * Owns per-table column sizing, persisted to localStorage.
+ *
+ * Writes are debounced so a live ('onChange') resize drag doesn't write on every
+ * mousemove. `skipPersistRef` suppresses the first run after mount/table-switch,
+ * which would only write back the sizing just loaded from storage.
+ * `pendingSizingRef` carries the latest unsaved state so a table switch or
+ * unmount flushes it instead of dropping a resize made less than the debounce
+ * window ago.
+ */
+export declare function useColumnSizingPersistence(tableName?: string): UseColumnSizingPersistenceResult;

package/dist/hooks/useColumnVisibilityPersistence.d.ts

@@ -0,0 +1,34 @@
+import { VisibilityState } from '@tanstack/react-table';
+/**
+ * Read a stored selection. Returns null — not `{}` — when there is nothing
+ * stored, because "no stored preference" (fall back to the host defaults) and
+ * "stored: everything visible" are different states.
+ */
+export declare function loadColumnVisibility(tableName: string): VisibilityState | null;
+export declare function saveColumnVisibility(tableName: string, visibility: VisibilityState): void;
+export declare function clearColumnVisibility(tableName: string): void;
+/**
+ * Turn a host's list of columns to show into table state: everything named is
+ * visible, everything else in `allColumnIds` is hidden. Columns the host names
+ * that this table doesn't have are ignored, so one config can cover a schema
+ * that varies between deployments.
+ */
+export declare function visibilityFromDefaults(allColumnIds: string[], defaultVisible?: string[]): VisibilityState;
+export interface UseColumnVisibilityPersistenceResult {
+    columnVisibility: VisibilityState;
+    setColumnVisibility: React.Dispatch<React.SetStateAction<VisibilityState>>;
+    /** Drop the stored selection and go back to the host defaults for this table. */
+    resetColumnVisibility: () => void;
+}
+/**
+ * Owns which columns a table shows, persisted per table to localStorage.
+ *
+ * A viewer picking columns is a durable preference, not a per-visit one: the
+ * selection survives reload and return visits. Host defaults apply until the
+ * viewer makes a choice, and `resetColumnVisibility` puts them back.
+ *
+ * Only a change through the returned setter is written. Merely opening a table
+ * must not store its defaults — that would freeze today's defaults into every
+ * viewer's storage and make a later change to them invisible.
+ */
+export declare function useColumnVisibilityPersistence(tableName: string | undefined, defaultVisibility: VisibilityState): UseColumnVisibilityPersistenceResult;

package/dist/hooks/useColumnVisibilityPersistence.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/hooks/useCompositeTableRef.d.ts

@@ -1,4 +1,4 @@
-import { Schema } from '../types/schema';
+import { SchemaContextValue } from '../types/schema';
 export interface CompositeTableRefValue {
     /** Route-encoded composite key (`v1::v2`) suitable as a Select value. */
     route: string;
@@ -10,10 +10,28 @@ export interface CompositeTableRef {
     loading: boolean;
     error: unknown;
     data: CompositeTableRefValue[];
+    /** True when `search` narrows server-side (String label column, `_contains`);
+     *  false means the caller must filter the fetched window client-side. */
+    serverSearch: boolean;
+}
+export interface CompositeTableRefOptions {
+    /** Free-text search term. Applied server-side when the label column is String. */
+    search?: string;
+    /** Defer the list fetch until the dropdown is opened (fetch-on-open). */
+    enabled?: boolean;
+    /** The currently-selected destination-column values, so the selected parent row
+     *  can be looked up and shown even when it falls outside the fetched window. */
+    currentValues?: Record<string, unknown> | null;
 }
 /**
  * Fetch parent rows for a composite-FK Select widget. Returns one row per parent
  * with its label plus every destination column value so the caller can write
  * each composite-FK source column on the child form when a selection is made.
+ *
+ * Mirrors the single-column FK data source (table-ref.ts / useTableRef +
+ * useTableRefValue): the window is sorted by the label column (deterministic),
+ * narrowed server-side when a search term is given and the label is String-typed,
+ * and the currently-selected row is resolved via a single-row lookup when it lies
+ * outside the fetched window so it stays selectable instead of showing blank.
  */
-export declare function useCompositeTableRef(schema: Schema, destTableName: string, destColumnNames: string[]): CompositeTableRef;
+export declare function useCompositeTableRef(schema: SchemaContextValue, destTableName: string, destColumnNames: string[], options?: CompositeTableRefOptions): CompositeTableRef;

package/dist/hooks/useCompositeTableRef.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/hooks/useDataTable.d.ts

@@ -1,19 +1,44 @@
-import { Table, Join } from '../types/schema';
+import { Table, Column, Join } from '../types/schema';
 import { ColumnDef, ColumnFiltersState, SortingState } from '@tanstack/react-table';
-import { ColumnPanel } from '../data-panel';
+import { DrillFrame } from '../lib/drill-stack';
+import { ExportRunner } from '../lib/export';
+import { GridGroupMemberRequest, GroupingRow, GroupingSort } from '../lib/grid-grouping';
 export { getFilterOperators } from '../lib/query-builder';
 export type { ColumnFilterValue } from '../lib/query-builder';
 interface RowData {
     id?: number | string;
     [key: string]: unknown;
 }
+export declare function getJoinedRowPkValue(row: RowData | undefined, joinSchema: Table | undefined): string;
 /**
  * Clamp a page index into the valid [0, pageCount-1] range. Guards against a
  * stale/out-of-range page (e.g. "page 2 of 1" after switching to a smaller
  * table or when the row count shrinks).
  */
 export declare function clampPageIndex(pageIndex: number, pageCount: number): number;
+/**
+ * Reconcile in-memory column-filter state with the URL `cf` param, which is the
+ * source of truth. Returns `prev` unchanged when it already serializes to the
+ * same string as `cfParam` — this both preserves referential identity (no
+ * needless re-render) and stops the setState → syncFiltersToUrl → cfParam →
+ * effect cycle from looping on our own writes. Otherwise it deserializes the URL
+ * value so browser back/forward and table switches (which drop the query string)
+ * drive the filters instead of leaving stale state behind.
+ */
+export declare function reconcileColumnFiltersFromUrl(prev: ColumnFiltersState, cfParam: string): ColumnFiltersState;
 export declare function getMultiJoinRows(row: RowData, join: Join): RowData[];
+/**
+ * Reads the joined parent object a single-link column renders.
+ *
+ * Keyed on the join's FIELD name, not its destination table: a table that
+ * references the same target through several foreign keys has one field per key
+ * (billing_address, shipping_address) and no field named for the table, so a
+ * lookup by table name finds nothing and the cell renders as null. Mirrors
+ * getMultiJoinRows, which has always had to do this for aliased child
+ * collections.
+ */
+export declare function getSingleJoinRow(row: RowData, join: Join): RowData | undefined;
+export declare function getMultiJoinTotal(row: RowData, join: Join): number;
 /**
  * Return type for the useDataTable hook.
  * @interface UseDataTableResult
@@ -35,8 +60,33 @@ interface UseDataTableResult {
     pageCount: number;
     /** Current page data rows */
     rows: RowData[];
-    /** Whether data is currently loading */
+    /** Total matching rows for the active filter/sort (across all pages). */
+    totalRows: number;
+    /** Server aggregate rows for URL-selected grouping; never derived from the page. */
+    grouping: {
+        column: Column;
+        sumColumn: Column | null;
+        rows: GroupingRow[];
+        loading: boolean;
+        error: Error | null;
+        sort: GroupingSort;
+        onSortChange: (sort: GroupingSort) => void;
+        memberRequest: (value: unknown) => GridGroupMemberRequest;
+    } | null;
+    /**
+     * Export the FULL result set for the current filters + sort, paging through
+     * the same fetcher/query — not just the visible page. Null when there is no
+     * active query/table to export.
+     */
+    exportRows: ExportRunner;
+    /** Whether data is currently loading (no rows to show yet) */
     loading: boolean;
+    /**
+     * A refresh is in flight while previous rows remain on screen as
+     * placeholder data (page turn, sort, filter change). Drives the grid's
+     * in-flight indicator; `loading` alone blanks the rows.
+     */
+    fetching: boolean;
     /** Error object if the query failed */
     error: Error | null;
     /** Update sorting state */
@@ -47,6 +97,9 @@ interface UseDataTableResult {
     onPageIndexChange: (pageIndex: number) => void;
     /** Update page size */
     onPageSizeChange: (pageSize: number) => void;
+    /** Rewrites only the URL-owned grouping parameter. */
+    onGroupingChange: (columnName: string | null) => void;
+    onGroupingSumChange: (columnName: string | null) => void;
 }
 /**
  * Hook for managing data table state including sorting, filtering, and pagination.
@@ -65,15 +118,15 @@ interface UseDataTableResult {
  *   pageCount,
  *   onSortingChange,
  *   onPageIndexChange,
- * } = useDataTable(table, recordId, parentTable);
+ * } = useDataTable(table, id, filterTable);
  * ```
  *
  * @param table - Table schema definition
- * @param id - Optional record ID for filtering to a specific row
+ * @param id - Optional row ID for filtering to a specific row
  * @param filterTable - Optional parent table name for relationship filtering
  * @param filterColumn - Optional column name for explicit FK filtering
  * @param onExpandContent - Callback when content expansion is requested
  * @param onOpenColumn - Callback when opening a side panel column
  * @returns Data table state and control functions
  */
-export declare function useDataTable(table: Table | null, id?: string, filterTable?: string, filterColumn?: string, onExpandContent?: (rowIndex: number, columnName: string) => void, onOpenColumn?: (panel: ColumnPanel) => void): UseDataTableResult;
+export declare function useDataTable(table: Table | null, id?: string, filterTable?: string, filterColumn?: string, onExpandContent?: (rowIndex: number, columnName: string) => void, onOpenColumn?: (panel: DrillFrame) => void): UseDataTableResult;

package/dist/hooks/useDebouncedCommit.d.ts

@@ -0,0 +1,19 @@
+export interface DebouncedCommit {
+    /** Debounce `commit`: it replaces any pending commit and runs after the delay. */
+    schedule: (commit: () => void) => void;
+    /** Drop the pending commit (if any) without running it. */
+    cancel: () => void;
+    /** Run the pending commit (if any) immediately instead of waiting out the delay. */
+    flush: () => void;
+}
+/**
+ * Debounce a commit callback with a pending-flush guarantee: the last scheduled
+ * commit either runs after `delayMs`, runs early via `flush()`, or is dropped
+ * via `cancel()` — and a pending commit is flushed automatically on unmount, so
+ * a value entered just before the host unmounts (e.g. Radix closing a dropdown
+ * that contains the filter input) isn't silently lost.
+ *
+ * Shared by the column-filter widgets so debounce/flush bookkeeping isn't
+ * re-implemented per filter type.
+ */
+export declare function useDebouncedCommit(delayMs: number): DebouncedCommit;

package/dist/hooks/useDebouncedCommit.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/hooks/useDeltaMutation.d.ts

@@ -0,0 +1,20 @@
+import { Table } from '../types/schema';
+/**
+ * The server's collection-diff save shape (`<t>_delta`): three optional lists
+ * that apply in inserted → updated → deleted order inside ONE transaction — a
+ * failure anywhere applies nothing — and ride the server's set-based bulk fast
+ * path at batch scale. Payloads must already be wire-ready (coerceDetail /
+ * delete key payloads); this hook only carries the document.
+ */
+export interface DeltaDocument {
+    inserted?: Record<string, unknown>[];
+    updated?: Record<string, unknown>[];
+    deleted?: Record<string, unknown>[];
+}
+export interface UseDeltaMutationResult {
+    saveDelta: (delta: DeltaDocument) => Promise<unknown>;
+    isPending: boolean;
+    error: Error | null;
+}
+export declare function deltaChangeCount(delta: DeltaDocument): number;
+export declare function useDeltaMutation(table: Table): UseDeltaMutationResult;

package/dist/hooks/useEditorConfig.d.ts

@@ -1,4 +1,5 @@
 import { ReactNode } from 'react';
+import { TableAction } from '../lib/table-action';
 /**
  * Optional, opt-in editor features. Kept tiny and separate from the data/schema
  * contexts so feature flags don't force those providers to re-render and so
@@ -11,6 +12,32 @@ export interface EditorConfig {
      * may not want on every connect. Hosts opt in via `<Editor showStats />`.
      */
     showStats: boolean;
+    /**
+     * Restrict the editor to these tables, by GraphQL name or db name. Undefined
+     * exposes everything the server returns — which on a managed host also means
+     * its own bookkeeping tables (Azure SQL surfaces firewall rules this way).
+     * Filtering here rather than in the sidebar keeps excluded tables out of
+     * routing and FK lookups too, not just out of the list.
+     */
+    tables?: string[];
+    /**
+     * Columns visible by default per table, keyed by table name; every other
+     * column starts hidden. Only the starting point — a viewer's own choices are
+     * stored per table and win from then on.
+     */
+    defaultColumns?: Record<string, string[]>;
+    /**
+     * Columns to move to the right end of every grid, in this order. For audit
+     * stamps (created/modified) that are read far less often than the data they
+     * annotate but sit in the middle of the natural column order.
+     */
+    trailingColumns?: string[];
+    /**
+     * Host-contributed actions on each table in the navigation list, rendered in
+     * the table's kebab menu AFTER the built-in Download actions. The host owns
+     * what an action does; edit-db just invokes it with the schema table.
+     */
+    tableActions?: TableAction[];
 }
 export declare function EditorConfigProvider({ config, children }: {
     config: EditorConfig;

package/dist/hooks/useFitMode.d.ts

@@ -0,0 +1,23 @@
+import { RefObject } from 'react';
+/** Sentinel page-size value meaning "fit as many rows as the viewport allows". */
+export declare const FIT_SENTINEL = -1;
+/**
+ * Rows that fit a container of `containerHeight` px: header subtracted, floor
+ * to whole rows, never below 5. The single source of the fit formula — the
+ * hook and its tests both use this.
+ */
+export declare function computeFitRowCount(containerHeight: number): number;
+export interface UseFitModeResult {
+    fitMode: boolean;
+    setFitMode: React.Dispatch<React.SetStateAction<boolean>>;
+    /** Rows that fit the current scroll container height. */
+    computeFitSize: () => number;
+}
+/**
+ * "Fit" page-sizing: derive the page size from the scroll container's height so
+ * the grid shows exactly as many rows as fit, re-fitting when the container
+ * resizes. The resize path is debounced so dragging a splitter/window doesn't
+ * fire a burst of queries (each distinct page size is a new query key) — only
+ * the settled size runs.
+ */
+export declare function useFitMode(scrollRef: RefObject<HTMLDivElement>, onPageSizeChange: (pageSize: number) => void): UseFitModeResult;

package/dist/hooks/useFitMode.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/hooks/usePanelSize.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Persistent, drag-resizable panel dimension.
+ *
+ * Returns the current size plus a pointerdown handler to put on a separator
+ * element. Dragging follows the pointer along the given axis; the size is
+ * clamped to [min, max] and persisted per `key` so a layout survives reload.
+ * `invert` flips the drag direction for separators that sit BEFORE the panel
+ * they size (e.g. a bottom panel resized by the handle above it: dragging the
+ * handle UP must grow the panel).
+ *
+ * The separator also supports keyboard resizing (arrow keys, 16px steps) via
+ * the returned onKeyDown — a drag-only separator is unreachable to keyboard
+ * users. Callers should render the handle with role="separator" and an
+ * aria-orientation matching the axis.
+ */
+export interface PanelSizeOptions {
+    key: string;
+    initial: number;
+    min: number;
+    max: number;
+    axis: 'x' | 'y';
+    invert?: boolean;
+}
+export declare function usePanelSize({ key, initial, min, max, axis, invert }: PanelSizeOptions): {
+    size: number;
+    onPointerDown: (e: React.PointerEvent<HTMLElement>) => void;
+    onKeyDown: (e: React.KeyboardEvent<HTMLElement>) => void;
+};

package/dist/hooks/usePanelSize.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/hooks/usePath.d.ts

@@ -23,10 +23,6 @@ interface SearchParamsResult {
     search: URLSearchParams;
     hash: string;
 }
-interface RouteError {
-    message?: string;
-    status?: number;
-}
 interface LinkProps extends React.AnchorHTMLAttributes<HTMLAnchorElement> {
     to: string;
     children?: ReactNode;
@@ -41,7 +37,6 @@ export declare function useNavigate(): (url: string) => void;
 export declare function useNavigation(): NavigationState;
 export declare function useParams<T extends RouteParams = RouteParams>(): T;
 export declare function useSearchParams(): SearchParamsResult;
-export declare function useRouteError(): RouteError;
 export declare function PathProvider({ path, children }: {
     path: string;
     children: ReactNode;
@@ -68,4 +63,6 @@ export declare function Route({ path, element }: {
     path: string;
     element: ReactElement;
 }): ReactElement;
+export declare const combinePaths: (current: string, newPath: string) => string;
+export declare const matchPath: (route: string, path: string) => PathMatch;
 export {};

package/dist/hooks/useRowHoverActions.d.ts

@@ -0,0 +1,26 @@
+import { PointerEvent, MutableRefObject } from 'react';
+export interface HoveredRow {
+    rowId: string;
+    el: HTMLElement;
+}
+export interface UseRowHoverActionsResult {
+    hoveredRow: HoveredRow | null;
+    hoverRow: (rowId: string, el: HTMLElement) => void;
+    scheduleDismiss: () => void;
+    cancelDismiss: () => void;
+    /** Suppresses the click that follows a long-press so it doesn't also select the row. */
+    suppressClick: MutableRefObject<boolean>;
+    startPress: (rowId: string, el: HTMLElement, e: PointerEvent) => void;
+    onPressMove: () => void;
+    cancelPress: () => void;
+}
+/**
+ * Row hover/long-press action tracking for the data grid.
+ *
+ * Mouse: hovering a row opens its action toolbar (with a small dismiss delay so
+ * moving onto the toolbar doesn't close it). Touch: a long-press (hold) opens
+ * the same actions since hover doesn't exist on touch; a finger move (scroll)
+ * cancels the press, and a fired press suppresses the click that follows the
+ * lift so it doesn't also select.
+ */
+export declare function useRowHoverActions(): UseRowHoverActionsResult;

package/dist/hooks/useSchema.d.ts

@@ -1,5 +1,5 @@
 import { ReactNode } from 'react';
-import { Schema } from '../types/schema';
+import { SchemaContextValue, Table } from '../types/schema';
 /**
  * Provider component for database schema context.
  * Fetches schema via GraphQL and makes it available to child components.
@@ -28,4 +28,10 @@ export declare const SchemaProvider: ({ children }: {
  *
  * @returns Schema context value with tables and metadata
  */
-export declare function useSchema(): Schema;
+export declare function useSchema(): SchemaContextValue;
+/**
+ * Keep only the tables a host allow-listed, matching on either name and ignoring
+ * case so a host can list them the way they read in its own docs. An empty or
+ * absent list means no restriction.
+ */
+export declare function filterAllowedTables(tables: Table[], allowed?: string[]): Table[];

package/dist/hooks/useSchemaFilter.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/hooks/useTableExport.d.ts

@@ -0,0 +1,13 @@
+import { Table } from '../types/schema';
+import { ExportFormat, ExportResult } from '../lib/export';
+/**
+ * Downloads a whole table WITHOUT opening it: the navigation-level counterpart
+ * of the grid toolbar's export. Reuses the grid's export projection
+ * (`buildQuery` with `fields: 'export'` — long text included, non-PK binary
+ * excluded, no join blocks), the shared page-draining serializer, and the same
+ * browser download path, so the two exports cannot drift. Unfiltered by design:
+ * a filtered export belongs to the grid, where the filters live.
+ * <see cref="DEFAULT_ROW_CAP"/> bounds the drain; the result reports
+ * `truncated` so the caller can warn instead of silently shipping a partial file.
+ */
+export declare function useTableExport(): (table: Table, format: ExportFormat) => Promise<ExportResult>;

package/dist/hooks/useTableMutation.d.ts

@@ -1,7 +1,5 @@
 import { Table, Column } from '../types/schema';
-interface ColumnJoin {
-    column: Column;
-}
+import { ColumnJoin } from '../lib/mutation-payload';
 export interface UseTableMutationResult {
     update: (detail: Record<string, unknown>) => Promise<unknown>;
     insert: (detail: Record<string, unknown>) => Promise<unknown>;
@@ -9,4 +7,3 @@ export interface UseTableMutationResult {
     error: Error | null;
 }
 export declare function useTableMutation(table: Table, editColumns: ColumnJoin[], idColumns: Column[], editId?: string): UseTableMutationResult;
-export {};

package/dist/hooks/useTableRef.d.ts

@@ -1,5 +1,4 @@
-import { Schema } from '../types/schema';
-export declare function useTableRef(schema: Schema, tableName: string, columnName: string): TableRef;
+import { SchemaContextValue } from '../types/schema';
 export interface TableRefValue {
     key: string;
     label: string;
@@ -8,4 +7,26 @@ export interface TableRef {
     loading: boolean;
     error: unknown;
     data: TableRefValue[];
+    /** True when `search` narrows server-side (String label column, `_contains`);
+     *  false means the caller must filter the fetched window client-side. */
+    serverSearch: boolean;
 }
+/**
+ * Fetch the option rows for an FK dropdown (key + label per parent row).
+ * When `search` is non-empty and the parent's label column is String-typed the
+ * list is narrowed server-side, so parents beyond the fetch window stay
+ * findable; otherwise one window is fetched and the caller filters it.
+ */
+export declare function useTableRef(schema: SchemaContextValue, tableName: string, columnName: string, search?: string, enabled?: boolean): TableRef;
+export interface TableRefLookup {
+    loading: boolean;
+    error: unknown;
+    value: TableRefValue | null;
+}
+/**
+ * Resolve key + label for a single parent row by its key value. Used when the
+ * currently stored FK value falls outside the fetched dropdown window, so the
+ * Select can still display the stored value instead of a misleading
+ * placeholder. Pass `key` as null/'' to disable the lookup.
+ */
+export declare function useTableRefValue(schema: SchemaContextValue, tableName: string, columnName: string, key: unknown): TableRefLookup;

package/dist/hooks/useTableRef.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/hooks/useTableStats.d.ts

@@ -33,6 +33,13 @@ export interface UseTableStatsResult {
         message: string;
     } | null;
 }
+/**
+ * Builds a GraphQL query to fetch row counts for all tables.
+ *
+ * @param tableNames - Array of table GraphQL names
+ * @returns GraphQL query string
+ */
+export declare function buildRowCountQuery(tableNames: string[]): string | null;
 /**
  * Hook to fetch table statistics including row counts.
  *
@@ -50,27 +57,3 @@ export interface UseTableStatsResult {
  * @returns Table statistics map and loading state
  */
 export declare function useTableStats(enabled?: boolean): UseTableStatsResult;
-/**
- * Formats a number into an abbreviated string representation.
- *
- * @example
- * ```typescript
- * abbreviateNumber(12)      // "12"
- * abbreviateNumber(1200)    // "1.2k"
- * abbreviateNumber(45000)   // "45k"
- * abbreviateNumber(1200000) // "1.2M"
- * ```
- *
- * @param num - Number to abbreviate
- * @returns Abbreviated string representation
- */
-export declare function abbreviateNumber(num: number | null): string;
-/**
- * Calculates a visual bar width (1-10) based on row count.
- * Used for sparkline visualization.
- *
- * @param count - Row count
- * @param maxCount - Maximum row count across all tables for scaling
- * @returns Width value from 1-10
- */
-export declare function calculateBarWidth(count: number | null, maxCount: number): number;

package/dist/hooks/useToast.d.ts

@@ -0,0 +1,15 @@
+import { ReactNode } from 'react';
+/**
+ * Minimal dependency-free toast system for transient success/error feedback
+ * after mutations (create, save, delete, inline content edits). Kept small and
+ * self-contained so the published editor pulls in no extra runtime dependency.
+ */
+export type ToastVariant = 'success' | 'error';
+interface ToastApi {
+    toast: (message: string, variant?: ToastVariant) => void;
+}
+export declare function ToastProvider({ children }: {
+    children: ReactNode;
+}): import("react").JSX.Element;
+export declare function useToast(): ToastApi;
+export {};

package/dist/index.d.ts

@@ -2,6 +2,18 @@ import { Editor } from './editor';
 export default Editor;
 export { Editor };
 export type { GraphQLFetcher } from './common/fetcher';
-export { HttpGraphQLFetcher } from './common/fetcher';
+export { HttpGraphQLFetcher, GraphQLRequestError } from './common/fetcher';
 export { useTableMutation } from './hooks/useTableMutation';
 export type { UseTableMutationResult } from './hooks/useTableMutation';
+export { createSavedObjectsClient, parseSavedObject, SavedObjectConflictError, SAVED_OBJECTS_PATH, } from './common/saved-objects';
+export type { SavedObject, SavedObjectType, SavedObjectsClient, } from './common/saved-objects';
+export { FormRunner, FormRunnerView, resolveDefinitionTable } from './components/form-runner';
+export { FormRunnerHost } from './components/form-runner-host';
+export { parseFormDefinition, visibleFields } from './lib/form-definition';
+export type { FormDefinition, FormField, FormControlType } from './lib/form-definition';
+export type { FieldWidgetHint } from './lib/form-widget';
+export { buildCsv, buildJson, formatCsvCell, exportAllRows, downloadTextFile, filenameFor, mimeFor, UTF8_BOM, DEFAULT_ROW_CAP, } from './lib/export';
+export type { ExportFormat, JsonMode, CsvOptions, JsonOptions, ExportPage, ExportResult, ExportRunner, RunExportOptions, } from './lib/export';
+export { serializeColumnFilters, deserializeColumnFilters } from './lib/query-builder';
+export type { TableAction } from './lib/table-action';
+export type { Table, Column } from './types/schema';

package/dist/lib/column-order.d.ts

@@ -0,0 +1,17 @@
+import { ColumnDef } from '@tanstack/react-table';
+export interface ColumnOrderConfig {
+    /** Columns to place first, in this order. */
+    leading?: string[];
+    /** Columns to place last, in this order. */
+    trailing?: string[];
+}
+/**
+ * Reorder columns around a host's preferences: named leading columns first in the
+ * order named, named trailing columns last in the order named, everything else
+ * keeping its schema order in between. Names the table doesn't have are skipped,
+ * so one host config can cover tables that don't all carry the same columns.
+ *
+ * Order is independent of visibility: a column the viewer switches back on lands
+ * in its configured place rather than at the end.
+ */
+export declare function orderColumns<TData>(columns: ColumnDef<TData, unknown>[], { leading, trailing }: ColumnOrderConfig): ColumnDef<TData, unknown>[];

package/dist/lib/column-order.test.d.ts

@@ -0,0 +1 @@
+export {};