@everygrid/grid 0.4.7

package/dist/src/core/useVirtualWindow.d.ts

@@ -0,0 +1,89 @@
+/** The slice of rows to render, plus the spacer heights that stand in for the rest. */
+export interface VirtualWindow {
+    /** First rendered row index. */
+    start: number;
+    /** One past the last rendered row index. */
+    end: number;
+    /** Spacer height above the rendered rows, in px. */
+    topPad: number;
+    /** Spacer height below the rendered rows, in px. */
+    bottomPad: number;
+}
+/**
+ * Largest spacer height a virtual scroller may ask for.
+ *
+ * Browsers clamp how tall an element can be, and a spacer past that limit silently stops growing —
+ * the scrollbar then covers only part of the data and the rows beyond it cannot be reached at all.
+ * Chrome cuts off at 16,777,214px (2^24 - 2), measured; Firefox and Safari sit near the same mark.
+ */
+export declare const MAX_SEGMENT_PX = 16777000;
+/** Row height a virtualised target falls back to when its config does not set one. */
+export declare const DEFAULT_ROW_HEIGHT = 36;
+/**
+ * Rows per segment, before the height limit is taken into account.
+ *
+ * Comfortably under what the limit alone would allow. A shorter segment keeps the scroller itself
+ * short — 6.8M px rather than 16.7M at a 34px row — and the scrollbar thumb correspondingly less
+ * twitchy: a pixel of thumb travel covers about a third as many rows, which is what makes dragging
+ * through a very large result feel controllable rather than like a slot machine.
+ */
+export declare const SEGMENT_ROWS = 200000;
+/**
+ * How many rows one scrollable segment holds, for a given row height.
+ *
+ * A result larger than this is scrolled a segment at a time (the pager moves between them) rather
+ * than being squeezed into one over-long scroller. Keeping every segment laid out 1:1 is what makes
+ * scrolling smooth: a row is exactly `rowHeight` tall and travelling `rowHeight` advances exactly
+ * one row. Compressing the whole result into one scroller instead would break that correspondence —
+ * the rows would step rather than slide.
+ *
+ * The height limit is the backstop, not the target: an unusually tall row yields a shorter segment
+ * rather than one that overflows what the browser will lay out.
+ */
+export declare function segmentRows(rowHeight: number): number;
+/**
+ * Ceiling on how far ahead of the viewport the window may reach while scrolling.
+ *
+ * Deliberately short. Its original job — covering the frame the window used to lag behind by — is
+ * gone now that the window is committed before the frame paints, so what is left is a head start
+ * on the engine's block fetches. Every row it adds is a row rendered on each scroll event, and
+ * during a fast fling that render is what the scroll outruns, so a big lead makes the thing it was
+ * meant to help worse.
+ */
+export declare const MAX_LEAD_ROWS = 16;
+/**
+ * Rows to render past the window, in the direction of travel.
+ *
+ * A scroll event's state update paints one frame later, so by the time the rows appear the
+ * scroller has already moved on — at speed, further than the overscan covers, and the viewport
+ * ends up over bare spacer. Extending the window along the direction of travel by the distance
+ * just covered closes that gap.
+ *
+ * It is measured as a row delta, not pixels: under the compressed mapping a pixel spans many rows,
+ * so `Δpx / rowHeight` would badly under-reach. Deriving it from two window computations makes it
+ * correct in both modes without either knowing about the other.
+ */
+export declare function leadRows(scrollTop: number, prevScrollTop: number, viewportHeight: number, rowHeight: number, overscan: number, totalRows: number): number;
+/**
+ * Pure window maths — no DOM, no React. Everything the virtual body needs is derived here so it
+ * can be reasoned about (and tested) on its own.
+ */
+export declare function computeWindow(scrollTop: number, viewportHeight: number, rowHeight: number, overscan: number, totalRows: number, lead?: number): VirtualWindow;
+/**
+ * Tracks a scroll container and reports the row window to render.
+ *
+ * Scroll events are coalesced to one measurement per frame: a fast wheel or drag fires dozens of
+ * events between paints, and re-rendering the body on each one is what makes naive virtual lists
+ * stutter.
+ */
+export declare function useVirtualWindow(totalRows: number, rowHeight: number, overscan: number): {
+    scrollerRef: (el: HTMLDivElement | null) => void;
+    onScroll: () => void;
+    scrollToTop: () => void;
+    window: {
+        start: number;
+        end: number;
+        topPad: number;
+        bottomPad: number;
+    };
+};

package/dist/src/core/useVirtualWindow.test.d.ts

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

package/dist/src/core/utils.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Checks if a value is a valid JSON string that represents an object or array.
+ * Supports non-standard JSON values like Infinity and NaN for better developer experience.
+ */
+export declare const isJsonString: (val: unknown) => boolean;
+export declare const formatIsoTimestamp: (val: string) => string;
+export declare const parseIfJson: (val: unknown) => unknown;
+/**
+ * Determines if an object/array is too complex to be rendered in-place.
+ */
+export declare const isTooComplex: (val: unknown) => boolean;
+/**
+ * Generates a summary label for objects and arrays.
+ */
+export declare const getSummaryLabel: (val: unknown) => string;
+/**
+ * Checks if a value is a valid XML string.
+ */
+export declare const isXmlString: (val: unknown) => boolean;

package/dist/src/i18n/I18n.d.ts

@@ -0,0 +1,16 @@
+export declare class I18n {
+    private static locale;
+    private static explicit;
+    private static translations;
+    static setLocale(locale: 'ko' | 'en'): void;
+    static getLocale(): 'ko' | 'en';
+    /**
+     * Retrieves translated text using dot notation.
+     * Example: I18n.t('toolbar.showExcelPreview')
+     */
+    static t(key: string, params?: Record<string, string | number>): string;
+    /**
+     * Initializes the locale based on the browser language settings.
+     */
+    static initFromBrowser(): void;
+}

package/dist/src/icons/ChevronDownIcon.d.ts

@@ -0,0 +1,2 @@
+import { default as React } from 'react';
+export declare const ChevronDownIcon: (props: React.SVGProps<SVGSVGElement>) => React.JSX.Element;

package/dist/src/icons/ColumnWidthIcon.d.ts

@@ -0,0 +1,3 @@
+export declare const ColumnWidthIcon: ({ className }: {
+    className?: string;
+}) => import("react").JSX.Element;

package/dist/src/icons/ColumnsIcon.d.ts

@@ -0,0 +1,3 @@
+export declare const ColumnsIcon: ({ className }: {
+    className?: string;
+}) => import("react").JSX.Element;

package/dist/src/icons/CommaIcon.d.ts

@@ -0,0 +1 @@
+export declare const CommaIcon: () => import("react").JSX.Element;

package/dist/src/icons/ConfigIcon.d.ts

@@ -0,0 +1,4 @@
+/** Toolbar "config": curly braces, in the toolbar's stroke weight and box. */
+export declare const ConfigIcon: ({ className }: {
+    className?: string;
+}) => import("react").JSX.Element;

package/dist/src/icons/DiffIcon.d.ts

@@ -0,0 +1,4 @@
+/** Toolbar "diff": the code brackets, in the toolbar's stroke weight and box. */
+export declare const DiffIcon: ({ className }: {
+    className?: string;
+}) => import("react").JSX.Element;

package/dist/src/icons/DownloadIcon.d.ts

@@ -0,0 +1,3 @@
+export declare const DownloadIcon: ({ className }: {
+    className?: string;
+}) => import("react").JSX.Element;

package/dist/src/icons/EditIcon.d.ts

@@ -0,0 +1 @@
+export declare const EditIcon: () => import("react").JSX.Element;

package/dist/src/icons/ExcelIcon.d.ts

@@ -0,0 +1,3 @@
+export declare const ExcelIcon: ({ className }: {
+    className?: string;
+}) => import("react").JSX.Element;

package/dist/src/icons/GlobeIcon.d.ts

@@ -0,0 +1,2 @@
+import { default as React } from 'react';
+export declare const GlobeIcon: (props: React.SVGProps<SVGSVGElement>) => React.JSX.Element;

package/dist/src/icons/HideIcon.d.ts

@@ -0,0 +1 @@
+export declare const HideIcon: () => import("react").JSX.Element;

package/dist/src/icons/InfoIcon.d.ts

@@ -0,0 +1,2 @@
+import { default as React } from 'react';
+export declare const InfoIcon: (props: React.SVGProps<SVGSVGElement>) => React.JSX.Element;

package/dist/src/icons/InsertRowIcon.d.ts

@@ -0,0 +1,4 @@
+/** Toolbar "insert row": a plus, drawn with the same stroke weight and box as the other toolbar icons. */
+export declare const InsertRowIcon: ({ className }: {
+    className?: string;
+}) => import("react").JSX.Element;

package/dist/src/icons/MobileColumnsIcon.d.ts

@@ -0,0 +1,3 @@
+export declare const MobileColumnsIcon: ({ className }: {
+    className?: string;
+}) => import("react").JSX.Element;

package/dist/src/icons/PinEmptyIcon.d.ts

@@ -0,0 +1 @@
+export declare const PinEmptyIcon: () => import("react").JSX.Element;

package/dist/src/icons/PinFilledIcon.d.ts

@@ -0,0 +1 @@
+export declare const PinFilledIcon: () => import("react").JSX.Element;

package/dist/src/icons/ReloadIcon.d.ts

@@ -0,0 +1,3 @@
+export declare const ReloadIcon: ({ className }: {
+    className?: string;
+}) => import("react").JSX.Element;

package/dist/src/icons/RowDetailIcon.d.ts

@@ -0,0 +1,3 @@
+export declare const RowDetailIcon: ({ className }: {
+    className?: string;
+}) => import("react").JSX.Element;

package/dist/src/icons/SearchIcon.d.ts

@@ -0,0 +1,3 @@
+export declare const SearchIcon: ({ className }: {
+    className?: string;
+}) => import("react").JSX.Element;

package/dist/src/icons/SortDownIcon.d.ts

@@ -0,0 +1 @@
+export declare const SortDownIcon: () => import("react").JSX.Element;

package/dist/src/icons/SortResetIcon.d.ts

@@ -0,0 +1,3 @@
+export declare const SortResetIcon: ({ className }: {
+    className?: string;
+}) => import("react").JSX.Element;

package/dist/src/icons/SortUpIcon.d.ts

@@ -0,0 +1 @@
+export declare const SortUpIcon: () => import("react").JSX.Element;

package/dist/src/icons/TrashIcon.d.ts

@@ -0,0 +1,3 @@
+export declare const TrashIcon: ({ className }: {
+    className?: string;
+}) => import("react").JSX.Element;

package/dist/src/icons/UndoIcon.d.ts

@@ -0,0 +1,3 @@
+export declare const UndoIcon: ({ className }: {
+    className?: string;
+}) => import("react").JSX.Element;

package/dist/src/index.d.ts

@@ -0,0 +1,14 @@
+import { Everygrid } from './core/Everygrid';
+export { Everygrid } from './core/Everygrid';
+export { Everygrid as default } from './core/Everygrid';
+export { GridHandle, RowHandle, CellHandle, ColumnHandle } from './core/GridHandle';
+export type { RowKey, RowStatus, CellChange, RowChange, ColumnChange, RowPatch, RowDeletion, Patch, CellChangeEvent, CheckEvent, GridEvents } from './core/GridHandle';
+export declare const loadEverygridConfig: typeof Everygrid.loadEverygridConfig;
+export declare const createGrid: typeof Everygrid.createGrid;
+export { useGrid, EverygridGrid } from './react';
+export type { EverygridGridProps } from './react';
+export { GridEngineWasm } from './wasm/GridEngineWasm';
+export { I18n } from './i18n/I18n';
+export { GlobeIcon } from './icons/GlobeIcon';
+export { ChevronDownIcon } from './icons/ChevronDownIcon';
+export type { ReloadOptions, GridOptions, GridColumn, ColumnI18n, GridMobileColumnsConfig, GridTargetConfig, GridPaginationConfig, GridColorConfig, EditableColConfig, GridRowKeyConfig, GridRowActionsConfig, GridToolbarConfig, GridLinkConfig, IEverygrid, GridLoadProgress, ServerFetchParams, ServerFetchResult, } from './core/types';

package/dist/src/react/index.d.ts

@@ -0,0 +1,20 @@
+import { CSSProperties } from 'react';
+type Fetcher = string | (() => Promise<Record<string, unknown>[]>);
+/**
+ * Mount an Everygrid grid for the life of the component that renders its `<div id={id}/>`.
+ *
+ * One line per grid: it creates the grid (config is auto-loaded from the app-root
+ * `everygrid.config.json`) and tears it down on unmount. `mount` coalesces concurrent creates of the
+ * same id, and the teardown is deferred + cancelled on remount, so React StrictMode's double-invoke
+ * neither double-creates nor unmounts a root mid-render.
+ */
+export declare function useGrid(id: string, fetcher?: Fetcher): void;
+export interface EverygridGridProps {
+    id: string;
+    fetcher?: Fetcher;
+    className?: string;
+    style?: CSSProperties;
+}
+/** Renders the grid's container `<div>` and manages its lifecycle via {@link useGrid}. */
+export declare function EverygridGrid({ id, fetcher, className, style }: EverygridGridProps): import("react").JSX.Element;
+export {};

package/dist/src/standalone-entry.d.ts

@@ -0,0 +1,2 @@
+import { Everygrid } from './core/Everygrid';
+export default Everygrid;

package/dist/src/wasm/ExcelExportClient.d.ts

@@ -0,0 +1,14 @@
+export interface ExportResult {
+    bytes: Uint8Array;
+    isZip: boolean;
+}
+export declare function runExcelExport(opts: {
+    baseName: string;
+    total: number;
+    chunkSize: number;
+    fetchChunk: (page: number, size: number) => Promise<unknown[]>;
+    onProgress?: (done: number, total: number) => void;
+    signal?: AbortSignal;
+    relational?: boolean;
+    keyField?: string;
+}): Promise<ExportResult>;

package/dist/src/wasm/ExportWorker.d.ts

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

package/dist/src/wasm/GridEngineWasm.d.ts

@@ -0,0 +1,70 @@
+/**
+ * GridEngineWasm.ts
+ * Main-thread proxy for the WASM GridEngine running inside a Web Worker.
+ * All heavy operations (setData, filter, sort, getPage) execute off the main thread,
+ * so the UI never freezes even with millions of rows.
+ */
+export declare class GridEngineWasm {
+    private static healthLogged;
+    private readonly engineId;
+    private readonly worker;
+    private seq;
+    private readonly pending;
+    private progressCallback?;
+    private constructor();
+    private send;
+    /** Creates a new engine instance with its own dedicated Worker. */
+    static create(engineId: string, onProgress?: (stage: 'indexing' | 'ready', progress: number) => void): Promise<GridEngineWasm>;
+    /** Loads the full dataset. Runs in the worker — non-blocking. */
+    setData(data: unknown[], reportProgress?: boolean): Promise<void>;
+    /**
+     * Streaming load — begin. Clears the engine and resets the worker-side byte scanner.
+     * Pair with streamChunk() (many) and streamEnd() (once).
+     */
+    streamStart(reportProgress?: boolean): Promise<void>;
+    /**
+     * Streaming load — feed one raw byte chunk straight from fetch's ReadableStream.
+     * The buffer is transferred (zero-copy); the caller must not reuse `bytes` afterward.
+     * All JSON parsing happens in the worker, so the main thread never blocks.
+     * @returns running total of complete rows parsed so far.
+     */
+    streamChunk(bytes: Uint8Array): Promise<number>;
+    /** Streaming load — finish. Flushes remaining rows and builds the index in the worker. */
+    streamEnd(reportProgress?: boolean): Promise<void>;
+    /**
+     * Patches rows in place at their raw (unfiltered, unsorted) positions — the cheap path for
+     * an edit. `setData` would re-upload and re-index the whole dataset, and report progress
+     * while doing it, to change one cell.
+     */
+    updateRows(rows: {
+        index: number;
+        row: unknown;
+    }[]): Promise<void>;
+    /** Inserts rows at a raw position — the row-add path. */
+    insertRows(index: number, rows: unknown[]): Promise<void>;
+    /** Removes rows at raw positions. */
+    removeRows(indices: number[]): Promise<void>;
+    /** Applies filter+sort and fetches the page in a single atomic Worker call — prevents interleaving. */
+    filterSortAndGetPage(text: string, col: string, asc: boolean, page: number, pageSize: number): Promise<{
+        rows: unknown[];
+        filtered: number;
+        raw: number;
+    }>;
+    /** Returns a page of rows plus the filtered total. */
+    getPage(page: number, pageSize: number): Promise<{
+        rows: unknown[];
+        total: number;
+    }>;
+    /** Returns a page of the raw (unfiltered) rows plus the raw total — used by "export all". */
+    getRawPage(page: number, pageSize: number): Promise<{
+        rows: unknown[];
+        total: number;
+    }>;
+    /** Returns the filtered row count. */
+    getTotalCount(): Promise<number>;
+    /** Returns the raw (unfiltered) row count. */
+    getRawCount(): Promise<number>;
+    /** Terminates the worker thread, releasing its WASM memory and the thread itself immediately.
+     *  Each grid has its own worker, so this only affects this engine. */
+    terminate(): void;
+}

package/dist/src/wasm/GridEngineWorker.d.ts

@@ -0,0 +1,102 @@
+/**
+ * GridEngineWorker.ts
+ * Web Worker script — runs inside a dedicated worker thread.
+ * Loads the Rust WASM module and handles postMessage commands from the main thread.
+ * Each GridEngine instance is keyed by an `id` so one worker can serve multiple grids.
+ * Each grid has its own independent command queue to prevent interleaving.
+ */
+export type WorkerRequest = {
+    id: string;
+    seq: number;
+    cmd: 'init';
+} | {
+    id: string;
+    seq: number;
+    cmd: 'setData';
+    bytes: Uint8Array;
+} | {
+    id: string;
+    seq: number;
+    cmd: 'appendChunk';
+    bytes: Uint8Array;
+} | {
+    id: string;
+    seq: number;
+    cmd: 'streamStart';
+} | {
+    id: string;
+    seq: number;
+    cmd: 'streamChunk';
+    bytes: Uint8Array;
+} | {
+    id: string;
+    seq: number;
+    cmd: 'streamEnd';
+} | {
+    id: string;
+    seq: number;
+    cmd: 'filterSortAndGetPage';
+    text: string;
+    col: string;
+    asc: boolean;
+    page: number;
+    pageSize: number;
+} | {
+    id: string;
+    seq: number;
+    cmd: 'getPage';
+    page: number;
+    pageSize: number;
+} | {
+    id: string;
+    seq: number;
+    cmd: 'getRawPage';
+    page: number;
+    pageSize: number;
+} | {
+    id: string;
+    seq: number;
+    cmd: 'getTotalCount';
+} | {
+    id: string;
+    seq: number;
+    cmd: 'getRawCount';
+} | {
+    id: string;
+    seq: number;
+    cmd: 'updateRows';
+    indices: Uint32Array;
+    rowsJson: string;
+} | {
+    id: string;
+    seq: number;
+    cmd: 'insertRows';
+    index: number;
+    rowsJson: string;
+} | {
+    id: string;
+    seq: number;
+    cmd: 'removeRows';
+    indices: Uint32Array;
+} | {
+    id: string;
+    seq: number;
+    cmd: 'finalize';
+};
+export type WorkerResponse = {
+    id: string;
+    seq: number;
+    ok: true;
+    result?: unknown;
+} | {
+    id: string;
+    seq: number;
+    ok: false;
+    error: string;
+} | {
+    id: string;
+    seq: -1;
+    type: 'progress';
+    stage: 'indexing' | 'ready';
+    progress: number;
+};