@everygrid/grid 0.4.7

package/dist/src/components/ColumnSelectorComponent.d.ts

@@ -0,0 +1,8 @@
+import { Everygrid } from '../core/Everygrid';
+export interface ColumnSelectorProps<T extends Record<string, unknown>> {
+    allFields: string[];
+    container: HTMLElement;
+    grid: Everygrid<T>;
+    onClose: () => void;
+}
+export declare const ColumnSelectorComponent: <T extends Record<string, unknown>>({ allFields, container, grid, onClose, }: ColumnSelectorProps<T>) => import("react").JSX.Element;

package/dist/src/components/DiffPopupComponent.d.ts

@@ -0,0 +1,14 @@
+import { Everygrid } from '../core/Everygrid';
+interface DiffPopupProps<T extends Record<string, unknown>> {
+    grid: Everygrid<T>;
+    containerId: string;
+    onClose: () => void;
+}
+/**
+ * The diff, shown by Everygrid itself: a second, read-only grid mounted inside the popup whose
+ * rows are the changes since load — an updated row's cells before → after, an inserted or
+ * deleted row field by field. Everything the grid does (search, sort, columns, export) works on
+ * the diff too. Destroyed with the popup.
+ */
+export declare const DiffPopupComponent: <T extends Record<string, unknown>>({ grid, containerId, onClose }: DiffPopupProps<T>) => import("react").JSX.Element;
+export {};

package/dist/src/components/EmptyGridPlaceholderComponent.d.ts

@@ -0,0 +1,15 @@
+import { default as React } from 'react';
+interface EmptyGridPlaceholderProps {
+    targetId: string;
+    dataUrl?: string;
+    /** While the grid is indexing, show a skeleton to fill the body instead of the "no data" message. */
+    indexing?: boolean;
+    /** Skeleton row count — the page size, so the body is the size of the table that replaces it. */
+    rows?: number;
+    /** Skeleton row height in px, matching the real table's rows. */
+    rowHeight?: number;
+    /** Skeleton header height in px, matching the real table's header. */
+    headerHeight?: number;
+}
+export declare const EmptyGridPlaceholder: React.FC<EmptyGridPlaceholderProps>;
+export {};

package/dist/src/components/EverygridComponent.d.ts

@@ -0,0 +1,5 @@
+import { IEverygrid } from '../core/types';
+export declare const EverygridComponent: <T extends Record<string, unknown>>({ grid, container, }: {
+    grid: IEverygrid<T>;
+    container: HTMLElement;
+}) => import("react").JSX.Element;

package/dist/src/components/ExcelViewComponent.d.ts

@@ -0,0 +1,20 @@
+import { default as React } from 'react';
+export interface ExcelViewProps {
+    data: unknown[];
+    limit?: number;
+    isExcel?: boolean;
+}
+export declare const ExcelViewComponent: ({ data, limit, isExcel }: ExcelViewProps) => React.JSX.Element;
+/** Rows per preview page when the grid has no pagination of its own to follow. */
+export declare const EXCEL_PAGE_SIZE = 50;
+export declare const ExcelViewWrapperComponent: <T extends Record<string, unknown>>({ data, toolbar, header, footer, onBodyScroll, }: {
+    data: T[];
+    toolbar: React.ReactNode;
+    /** The strip between toolbar and table — row count, and the preview's top pager when the grid
+     *  paginates on top. Mirrors the normal view so toggling the preview keeps the same layout. */
+    header?: React.ReactNode;
+    /** Pagination for the preview — it pages through the whole result rather than truncating it. */
+    footer?: React.ReactNode;
+    /** Set for grids that scroll rather than page: fires as the preview body nears its end. */
+    onBodyScroll?: React.UIEventHandler<HTMLDivElement>;
+}) => React.JSX.Element;

package/dist/src/components/GridTableComponent.d.ts

@@ -0,0 +1,28 @@
+import { default as React } from 'react';
+import { GridColumn, IEverygrid } from '../core/types';
+export interface GridTableProps<T extends Record<string, unknown>> {
+    grid: IEverygrid<T>;
+    columns: GridColumn[];
+    /** In virtual mode a row whose block hasn't arrived yet is `undefined` — render a placeholder. */
+    displayItems: (T | undefined)[];
+    container: HTMLElement;
+    containerId: string;
+    editableFields: string[];
+    currentWidths: Map<string, number>;
+    gridTitle?: string;
+    startIndex?: number;
+    filterText?: string;
+    isIndexing?: boolean;
+    isExporting?: boolean;
+    /** Narrow layout: columns fit the viewport (no horizontal scroll), resizing/pinning are off. */
+    isMobile?: boolean;
+    /** Set when the target scrolls virtually: spacer heights standing in for the unrendered rows. */
+    virtual?: {
+        topPad: number;
+        bottomPad: number;
+        rowHeight: number;
+    };
+    /** Rows inserted since load: drawn first, tinted, above the data rows. Not part of `displayItems`. */
+    insertedItems?: T[];
+}
+export declare const GridTableComponent: <T extends Record<string, unknown>>(props: GridTableProps<T>) => React.ReactElement;

package/dist/src/components/GridToolbarComponent.d.ts

@@ -0,0 +1,49 @@
+import { KeyTree } from '../core/types';
+export interface GridToolbarProps {
+    isExcelViewMode: boolean;
+    /** While an export runs, filter/sort/reload/reset are locked (they'd corrupt the in-flight file). */
+    isExporting?: boolean;
+    /** When set (indexing / processing / exporting), loading progress shows inside the search box. */
+    statusText?: string;
+    /** Numeric progress 0–100 for the loading bar; -1 = indeterminate. */
+    progress?: number;
+    /** When set, the progress pill shows a Cancel action (abortable worker export only). */
+    onCancelExport?: () => void;
+    /** True when any column has a custom width — highlights the width-reset segment. */
+    hasCustomWidths?: boolean;
+    onToggleExcelView: () => void;
+    onResetWidths: () => void;
+    onShowColumnSelector: () => void;
+    onShowHiddenColumnSelector: () => void;
+    onDownloadExcel: (scope: 'filtered' | 'all') => void;
+    /** Row counts shown under each export-scope option. */
+    filteredCount?: number;
+    allCount?: number;
+    /** Omitted when the grid has no re-fetchable source, which hides the reload button. */
+    /** Set when the grid's rowActions allow inserting; the toolbar then ends with a "+ row" button. */
+    onInsertRow?: () => void;
+    /** Opens the read-only list of every change since load; enabled while there are changes. */
+    onShowDiff?: () => void;
+    /** Opens the grid's effective configuration in the popup viewer (toolbar.showConfig). */
+    onShowConfig?: () => void;
+    onReloadData?: () => void;
+    isReloading?: boolean;
+    onReset: () => void;
+    onResetSort: () => void;
+    hasChanges: boolean;
+    hiddenFields: Set<string>;
+    sortInfo: {
+        field: string;
+        direction: 'asc' | 'desc' | null;
+    } | undefined;
+    filterText?: string;
+    onFilter?: (text: string) => void;
+    /** Searchable-key tree for the search-box autocomplete (sub-keys per scope). */
+    searchKeys?: KeyTree;
+    /** Localized display name for a suggestion key — shown as `key(label)`; the inserted query keeps
+     *  the real key. Returns the key unchanged when no label is configured. */
+    labelOf?: (key: string) => string;
+    gridTitle?: string;
+    isIndexing?: boolean;
+}
+export declare const GridToolbarComponent: ({ isExcelViewMode, isExporting, statusText, progress, onCancelExport, hasCustomWidths, onToggleExcelView, onResetWidths, onShowColumnSelector, onShowHiddenColumnSelector, onDownloadExcel, filteredCount, allCount, onReloadData, onInsertRow, onShowDiff, onShowConfig, isReloading, onReset, onResetSort, hasChanges, hiddenFields, sortInfo, filterText, onFilter, searchKeys, labelOf, gridTitle, isIndexing, }: GridToolbarProps) => import("react").JSX.Element;

package/dist/src/components/HiddenColumnSelectorComponent.d.ts

@@ -0,0 +1,7 @@
+import { Everygrid } from '../core/Everygrid';
+export interface HiddenColumnSelectorProps<T extends Record<string, unknown>> {
+    container: HTMLElement;
+    grid: Everygrid<T>;
+    onClose: () => void;
+}
+export declare const HiddenColumnSelectorComponent: <T extends Record<string, unknown>>({ container, grid, onClose, }: HiddenColumnSelectorProps<T>) => import("react").JSX.Element;

package/dist/src/components/InsertedRowsComponent.d.ts

@@ -0,0 +1,21 @@
+import { GridColumn, IEverygrid } from '../core/types';
+interface InsertedRowsProps<T extends Record<string, unknown>> {
+    grid: IEverygrid<T>;
+    columns: GridColumn[];
+    items: T[];
+    container: HTMLElement;
+    containerId: string;
+    editableFields: string[];
+    filterText: string;
+    rowHeight?: number;
+    visibleFields?: string[];
+    isMobile?: boolean;
+}
+/**
+ * Rows inserted since load, drawn first in a table body — tinted, before any virtual spacer: new
+ * rows belong above the data and are not part of the loaded data the window is computed over.
+ * The checkbox column stays empty (a new row has no key to be checked by yet). Rendered by the
+ * main table and the pinned table alike, so the two stay row-for-row aligned.
+ */
+export declare const InsertedRowsComponent: <T extends Record<string, unknown>>({ grid, columns, items, container, containerId, editableFields, filterText, rowHeight, visibleFields, isMobile, }: InsertedRowsProps<T>) => import("react").JSX.Element;
+export {};

package/dist/src/components/MobileColumnSelectorComponent.d.ts

@@ -0,0 +1,8 @@
+import { Everygrid } from '../core/Everygrid';
+export interface MobileColumnSelectorProps<T extends Record<string, unknown>> {
+    allFields: string[];
+    container: HTMLElement;
+    grid: Everygrid<T>;
+    onClose: () => void;
+}
+export declare const MobileColumnSelectorComponent: <T extends Record<string, unknown>>({ allFields, container, grid, onClose, }: MobileColumnSelectorProps<T>) => import("react").JSX.Element;

package/dist/src/components/NestedTableComponent.d.ts

@@ -0,0 +1,10 @@
+import { default as React } from 'react';
+interface NestedTableProps {
+    data: unknown;
+    depth?: number;
+    onShowPopup?: () => void;
+    filterText?: string;
+    elementGate?: (el: unknown) => string;
+}
+declare const NestedTableComponent: React.FC<NestedTableProps>;
+export { NestedTableComponent };

package/dist/src/components/PaginationComponent.d.ts

@@ -0,0 +1,21 @@
+import { IEverygrid } from '../core/types';
+import { RowCountProps } from './RowCountComponent';
+export interface PaginationProps<T extends Record<string, unknown>> {
+    grid: IEverygrid<T>;
+    container: HTMLElement;
+    currentPage: number;
+    totalPages: number;
+    /** Greys the controls out without removing them — used while a reload is in flight. */
+    disabled?: boolean;
+    /**
+     * Set to render the row count inside the bar — the layout from before the count moved to the
+     * strip under the toolbar. Selected per grid with `pagination.rowCount: 'inline'`.
+     */
+    rowCount?: Omit<RowCountProps, 'className'>;
+    /**
+     * Overrides where a page click goes. The Excel preview pages through the same result on its own
+     * axis, so it drives its own state rather than moving the grid underneath.
+     */
+    onPageChange?: (page: number) => void;
+}
+export declare const PaginationComponent: <T extends Record<string, unknown>>({ grid, container, currentPage, totalPages, disabled, rowCount, onPageChange, }: PaginationProps<T>) => import("react").JSX.Element | null;

package/dist/src/components/PinnedTableComponent.d.ts

@@ -0,0 +1,26 @@
+import { default as React } from 'react';
+import { GridColumn, IEverygrid } from '../core/types';
+interface PinnedTableComponentProps<T extends Record<string, unknown>> {
+    instance: IEverygrid<T>;
+    columns: GridColumn[];
+    displayItems: (T | undefined)[];
+    container: HTMLElement;
+    containerId: string;
+    editableFields: string[];
+    gridTitle?: string;
+    startIndex?: number;
+    filterText?: string;
+    isIndexing?: boolean;
+    isExporting?: boolean;
+    /** Must match the main table's spacers exactly — that identity is what keeps the two
+     *  tables' rows aligned without any JS height syncing. */
+    virtual?: {
+        topPad: number;
+        bottomPad: number;
+        rowHeight: number;
+    };
+    /** Same rows as the main table's — the two must stay row-for-row aligned. */
+    insertedItems?: T[];
+}
+export declare const PinnedTableComponent: <T extends Record<string, unknown>>(props: PinnedTableComponentProps<T>) => React.ReactElement;
+export {};

package/dist/src/components/PopupComponent.d.ts

@@ -0,0 +1,29 @@
+import { default as React } from 'react';
+interface PopupProps {
+    onClose: () => void;
+    title?: string;
+    /** Muted line under the title, e.g. the file a config came from. */
+    subtitle?: string;
+    /** Hover text for the subtitle (e.g. the full URL when `subtitle` is just the file name). */
+    subtitleTitle?: string;
+    children: React.ReactNode;
+    data?: unknown;
+    /**
+     * Box size. `s` / `m` / `l` are fixed squares, so detail and text popups all open at the same
+     * shape whatever they hold. `auto` is a content-height rectangle for popups with an action
+     * footer (the editor), where a square wastes space and crowds the buttons.
+     */
+    size?: 's' | 'm' | 'l' | 'auto';
+    /** Expand the box to fill the viewport (the caller owns the toggle; see MaximizeToggle). */
+    maximized?: boolean;
+    /** Render the MaximizeToggle in the header, next to the close button, and own its state. */
+    maximizable?: boolean;
+}
+/** Icon button toggling a popup between its normal box and the viewport-filling one. */
+export declare const MaximizeToggle: ({ maximized, onToggle, className }: {
+    maximized: boolean;
+    onToggle: () => void;
+    className?: string;
+}) => React.JSX.Element;
+declare const PopupComponent: React.FC<PopupProps>;
+export { PopupComponent };

package/dist/src/components/RowCountComponent.d.ts

@@ -0,0 +1,18 @@
+export interface RowCountProps {
+    /** 1-based index of the first row on screen, or 0 when there are none. */
+    start: number;
+    /** 1-based index of the last row on screen. */
+    end: number;
+    /** Rows remaining after the filter. */
+    total: number;
+    /** Rows before the filter, for the "x of y" form. */
+    rawTotal: number;
+    /** Extra class, so the pagination bar can style its own copy differently. */
+    className?: string;
+}
+/**
+ * The "Showing 1–5 of 10" line. It lives between the toolbar and the table rather than inside the
+ * pagination, because it describes the data whether or not the grid is paged — a virtual or
+ * single-page grid has just as much use for it, and there is no pagination there to carry it.
+ */
+export declare const RowCountComponent: ({ start, end, total, rawTotal, className }: RowCountProps) => import("react").JSX.Element;

package/dist/src/components/RowDetailComponent.d.ts

@@ -0,0 +1,8 @@
+import { Everygrid } from '../core/Everygrid';
+export interface RowDetailProps<T extends Record<string, unknown>> {
+    row: T;
+    container: HTMLElement;
+    grid: Everygrid<T>;
+    onClose: () => void;
+}
+export declare const RowDetailComponent: <T extends Record<string, unknown>>({ row, container, grid, onClose, }: RowDetailProps<T>) => import("react").JSX.Element;

package/dist/src/components/TableCellComponent.d.ts

@@ -0,0 +1,18 @@
+import { JSX } from 'react';
+import { GridColumn, IEverygrid } from '../core/types';
+export interface TableCellProps<T extends Record<string, unknown>> {
+    grid: IEverygrid<T>;
+    col: GridColumn;
+    item: T;
+    rowIndex: number;
+    containerId: string;
+    container: HTMLElement;
+    editableFields?: string[];
+    filterText?: string;
+    /** Mobile only: the data fields shown as visible columns, so the detail button can flag a match
+     *  that lives in one of the hidden (detail-only) fields. */
+    visibleFields?: string[];
+    /** Narrow layout: cells truncate, so a match hidden past the ellipsis needs a whole-cell flag. */
+    isMobile?: boolean;
+}
+export declare const TableCellComponent: <T extends Record<string, unknown>>(props: TableCellProps<T>) => JSX.Element;

package/dist/src/components/TextEditorPopupComponent.d.ts

@@ -0,0 +1,6 @@
+export declare const TextEditorPopupComponent: ({ field, data, onClose, onSave }: {
+    field: string;
+    data: unknown;
+    onClose: () => void;
+    onSave: (data: unknown) => void;
+}) => import("react").JSX.Element;