cenitu-table 0.2.0 → 0.3.0

package/dist/react.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const _=require("react/jsx-runtime"),r=require("react"),C=require("./index-BJIaMXd1.cjs"),T=["fixedRowsTop","fixedColumnsStart","readOnly","columns","colHeaders","mergeCells","columnSorting","filters","fillHandle","locale","language","contextMenu"],E=r.forwardRef(function(e,g){const l=r.useRef(null),t=r.useRef(null),u=r.useRef(e);u.current=e,r.useLayoutEffect(()=>{const{className:c,style:h,onChange:S,onSelection:j,onSort:w,onFilter:v,...x}=u.current,d=new C.CenituGrid(l.current,x);return d.addHook("afterChange",(s,a)=>{var n,i;return(i=(n=u.current).onChange)==null?void 0:i.call(n,s,a)}),d.addHook("afterSelection",(s,a,n,i)=>{var y,R;return(R=(y=u.current).onSelection)==null?void 0:R.call(y,s,a,n,i)}),d.addHook("afterColumnSort",(s,a)=>{var n,i;return(i=(n=u.current).onSort)==null?void 0:i.call(n,s,a)}),d.addHook("afterFilter",s=>{var a,n;return(n=(a=u.current).onFilter)==null?void 0:n.call(a,s)}),t.current=d,()=>{d.destroy(),t.current=null}},[]),r.useImperativeHandle(g,()=>t.current,[]);const m=r.useRef(!1);r.useEffect(()=>{if(!m.current)return;const c=t.current;c&&e.data&&!H(c,e.data)&&c.loadData(e.data)},[e.data]);const f=T.map(c=>e[c]);return r.useEffect(()=>{var h;if(!m.current)return;const c={};T.forEach(S=>e[S]!==void 0&&(c[S]=e[S])),(h=t.current)==null||h.updateSettings(c)},f),r.useEffect(()=>{m.current=!0},[]),_.jsx("div",{ref:l,className:e.className,style:e.style})});function H(o,e){if(!C.isObjectData(e))return b(o.getSourceData(),e);if(o.getSourceObjects()===e)return!0;const g=Array.from({length:o.countCols()},(l,t)=>o.colToProp(t));return b(o.getBoundRows(),C.ObjectBinding.create(e,g).toRows())}function b(o,e){const g=Math.max(o.length,e.length);for(let l=0;l<g;l++){const t=o[l]??[],u=e[l]??[],m=Math.max(t.length,u.length);for(let f=0;f<m;f++)if((t[f]??null)!==(u[f]??null))return!1}return!0}exports.CenituGrid=C.CenituGrid;exports.CenituTable=E;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const _=require("react/jsx-runtime"),r=require("react"),C=require("./index-BHarWDHD.cjs"),T=["fixedRowsTop","fixedColumnsStart","readOnly","columns","colHeaders","mergeCells","columnSorting","filters","fillHandle","locale","language","contextMenu","search"],E=r.forwardRef(function(e,g){const l=r.useRef(null),t=r.useRef(null),u=r.useRef(e);u.current=e,r.useLayoutEffect(()=>{const{className:c,style:h,onChange:S,onSelection:j,onSort:w,onFilter:v,...x}=u.current,d=new C.CenituGrid(l.current,x);return d.addHook("afterChange",(s,a)=>{var n,i;return(i=(n=u.current).onChange)==null?void 0:i.call(n,s,a)}),d.addHook("afterSelection",(s,a,n,i)=>{var y,R;return(R=(y=u.current).onSelection)==null?void 0:R.call(y,s,a,n,i)}),d.addHook("afterColumnSort",(s,a)=>{var n,i;return(i=(n=u.current).onSort)==null?void 0:i.call(n,s,a)}),d.addHook("afterFilter",s=>{var a,n;return(n=(a=u.current).onFilter)==null?void 0:n.call(a,s)}),t.current=d,()=>{d.destroy(),t.current=null}},[]),r.useImperativeHandle(g,()=>t.current,[]);const m=r.useRef(!1);r.useEffect(()=>{if(!m.current)return;const c=t.current;c&&e.data&&!H(c,e.data)&&c.loadData(e.data)},[e.data]);const f=T.map(c=>e[c]);return r.useEffect(()=>{var h;if(!m.current)return;const c={};T.forEach(S=>e[S]!==void 0&&(c[S]=e[S])),(h=t.current)==null||h.updateSettings(c)},f),r.useEffect(()=>{m.current=!0},[]),_.jsx("div",{ref:l,className:e.className,style:e.style})});function H(o,e){if(!C.isObjectData(e))return b(o.getSourceData(),e);if(o.getSourceObjects()===e)return!0;const g=Array.from({length:o.countCols()},(l,t)=>o.colToProp(t));return b(o.getBoundRows(),C.ObjectBinding.create(e,g).toRows())}function b(o,e){const g=Math.max(o.length,e.length);for(let l=0;l<g;l++){const t=o[l]??[],u=e[l]??[],m=Math.max(t.length,u.length);for(let f=0;f<m;f++)if((t[f]??null)!==(u[f]??null))return!1}return!0}exports.CenituGrid=C.CenituGrid;exports.CenituTable=E;

package/dist/react.js

@@ -1,6 +1,6 @@
 import { jsx as T } from "react/jsx-runtime";
-import { forwardRef as E, useRef as S, useLayoutEffect as O, useImperativeHandle as R, useEffect as C } from "react";
-import { C as b, i as j, O as v } from "./index-DG98ykBX.js";
+import { forwardRef as E, useRef as h, useLayoutEffect as O, useImperativeHandle as R, useEffect as C } from "react";
+import { C as b, i as j, O as v } from "./index-BpjIy-X9.js";
 const _ = [
   "fixedRowsTop",
   "fixedColumnsStart",
@@ -13,11 +13,12 @@ const _ = [
   "fillHandle",
   "locale",
   "language",
-  "contextMenu"
+  "contextMenu",
+  "search"
 ], G = E(function(t, d) {
-  const a = S(null), e = S(null), o = S(t);
+  const a = h(null), e = h(null), o = h(t);
   o.current = t, O(() => {
-    const { className: c, style: h, onChange: g, onSelection: N, onSort: F, onFilter: I, ...w } = o.current, f = new b(a.current, w);
+    const { className: c, style: S, onChange: g, onSelection: N, onSort: F, onFilter: I, ...w } = o.current, f = new b(a.current, w);
     return f.addHook("afterChange", (u, l) => {
       var n, s;
       return (s = (n = o.current).onChange) == null ? void 0 : s.call(n, u, l);
@@ -34,7 +35,7 @@ const _ = [
       f.destroy(), e.current = null;
     };
   }, []), R(d, () => e.current, []);
-  const m = S(!1);
+  const m = h(!1);
   C(() => {
     if (!m.current) return;
     const c = e.current;
@@ -42,10 +43,10 @@ const _ = [
   }, [t.data]);
   const i = _.map((c) => t[c]);
   return C(() => {
-    var h;
+    var S;
     if (!m.current) return;
     const c = {};
-    _.forEach((g) => t[g] !== void 0 && (c[g] = t[g])), (h = e.current) == null || h.updateSettings(c);
+    _.forEach((g) => t[g] !== void 0 && (c[g] = t[g])), (S = e.current) == null || S.updateSettings(c);
   }, i), C(() => {
     m.current = !0;
   }, []), /* @__PURE__ */ T("div", { ref: a, className: t.className, style: t.style });

package/dist/types/export/index.d.ts

@@ -4,3 +4,5 @@ export { toXLSX, toXLSXCompressed, xlsxParts, sanitizeSheetNames, pxToColWidth,
 export { numberFormatFromMeta, isDateFormat, formatDateCode, dateCodeFromPattern } from './numberFormat.js';
 export { downloadBlob, CSV_MIME } from './download.js';
 export { crc32, zipStore, zipDeflate, type ZipEntry } from './zip.js';
+export { readXLSX, workbookEngine, type ImportOptions, type ImportSheet, type ImportWorkbook } from './xlsxRead.js';
+export { ZipReader, type UnzipOptions } from './unzip.js';

package/dist/types/export/types.d.ts

@@ -6,6 +6,7 @@ export interface ExportCellFormat {
     bold?: boolean;
     italic?: boolean;
     underline?: boolean;
+    strike?: boolean;
     /** '#rrggbb' (or '#rgb'). */
     color?: string;
     background?: string;

package/dist/types/export/unzip.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Minimal ZIP reader (PKWARE APPNOTE 6.3), enough for spreadsheet packages: finds entries through
+ * the central directory and inflates them with the platform DecompressionStream. No ZIP64 and no
+ * encryption. Sizes are enforced while inflating, so a crafted archive cannot exhaust memory.
+ */
+export interface UnzipOptions {
+    /** Upper limit for the total uncompressed size in bytes (default 1 GiB). */
+    maxSize?: number;
+}
+/** Lists a package and gives access to its entries by path. */
+export declare class ZipReader {
+    private readonly bytes;
+    private readonly entries;
+    private remaining;
+    constructor(bytes: Uint8Array, opts?: UnzipOptions);
+    has(path: string): boolean;
+    get paths(): string[];
+    /** Uncompressed content of an entry; undefined when the package has no such entry. */
+    read(path: string): Promise<Uint8Array | undefined>;
+    readText(path: string): Promise<string | undefined>;
+}

package/dist/types/export/xlsxRead.d.ts

@@ -0,0 +1,35 @@
+import { FormulaEngine } from '../formula/engine.js';
+import type { ExportCellFormat, ExportSheet } from './types.js';
+import { type UnzipOptions } from './unzip.js';
+export interface ImportOptions extends UnzipOptions {
+    /** 'keep' (default) imports formulas; 'values' replaces them with the results stored in the file. */
+    formulas?: 'keep' | 'values';
+}
+/** One worksheet of a file; the same shape the exporters take, plus what only applies to imports. */
+export interface ImportSheet extends ExportSheet {
+    hiddenColumns: number[];
+    /** Sheet is hidden in the file. */
+    hidden: boolean;
+    format: (row: number, col: number) => ExportCellFormat | undefined;
+}
+export interface ImportWorkbook {
+    sheets: ImportSheet[];
+    /** Workbook-level defined names: name -> expression (`=Sheet1!$A$1`). */
+    names: {
+        name: string;
+        expression: string;
+    }[];
+}
+type Binary = ArrayBuffer | Uint8Array | Blob;
+/**
+ * Reads an .xlsx file: values, formulas, number formats, fonts, fills, alignment, column widths,
+ * row heights, frozen panes, merges and defined names. Charts, images, comments, conditional
+ * formats and data validation are not read.
+ */
+export declare function readXLSX(file: Binary, opts?: ImportOptions): Promise<ImportWorkbook>;
+/**
+ * Engine holding all sheets of a workbook (still empty) and its defined names. Create one grid per
+ * sheet on it and call `loadSheet`, so cross-sheet formulas find each other in any order.
+ */
+export declare function workbookEngine(workbook: ImportWorkbook): FormulaEngine;
+export {};

package/dist/types/export/xlsxStyles.d.ts

@@ -0,0 +1,23 @@
+import type { CellMeta, NumericFormat } from '../grid/cellTypes.js';
+import type { ExportCellFormat } from './types.js';
+export declare function parseThemeColors(xml: string | undefined): string[];
+/** Resolved cell formats of a workbook: cell `s` attribute -> grid-independent format. */
+export declare class XlsxStyles {
+    private readonly theme;
+    private readonly codes;
+    private readonly fonts;
+    private readonly fills;
+    private readonly xfs;
+    private readonly cache;
+    constructor(xml: string | undefined, theme: string[]);
+    private parse;
+    numberFormat(style: number): string | undefined;
+    isDate(style: number): boolean;
+    format(style: number): ExportCellFormat | undefined;
+}
+/** Date pattern for a format code, when every token has a grid equivalent. */
+export declare function patternFromDateCode(code: string): string | undefined;
+/** Number display settings for a simple format code; complex codes keep the default display. */
+export declare function numericFormatFromCode(code: string): NumericFormat | undefined;
+/** Cell settings that make the grid display a format like the file does. */
+export declare function metaFromFormat(f: ExportCellFormat): CellMeta;

package/dist/types/export/xmlReader.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Streaming XML scanner for package parts. Namespace prefixes are dropped from element and
+ * attribute names (`x:row` -> `row`), which is what spreadsheet parts need. DOCTYPE declarations
+ * are skipped and only the predefined and numeric entities are decoded, so a crafted file cannot
+ * expand entities or reach external resources.
+ */
+export type XmlAttrs = Record<string, string>;
+export interface XmlHandler {
+    open?(name: string, attrs: XmlAttrs, selfClosing: boolean): void;
+    close?(name: string): void;
+    text?(text: string): void;
+}
+export declare function decodeEntities(s: string): string;
+/** Reports elements and text in document order; throws on an unterminated construct. */
+export declare function scanXml(xml: string, h: XmlHandler): void;

package/dist/types/grid/cellTypes.d.ts

@@ -51,7 +51,9 @@ export interface CellMeta {
     width?: number;
     readOnly?: boolean;
     numericFormat?: NumericFormat;
-    /** Tokens: DD, MM, YYYY, YY (default "DD.MM.YYYY" for tr, "YYYY-MM-DD" otherwise). */
+    /** Spreadsheet format code written to XLSX instead of one derived from these settings (set on import). */
+    formatCode?: string;
+    /** Tokens: DD, MM, YYYY, YY, HH, mm, ss (default "DD.MM.YYYY" for tr, "YYYY-MM-DD" otherwise). */
     dateFormat?: string;
     /** Allowed values of a dropdown cell. */
     source?: string[];

package/dist/types/grid/clipboardHtml.d.ts

@@ -0,0 +1,13 @@
+import type { CellStyle } from './cellTypes.js';
+/**
+ * The "text/html" clipboard flavour. Values always travel as tab-separated text; the HTML table
+ * only adds styling, which is what spreadsheet apps read from each other.
+ */
+export declare function styleToCss(s: CellStyle): string;
+export declare function tableHtml(texts: string[][], styles: (CellStyle | undefined)[][]): string;
+export interface HtmlTable {
+    texts: string[][];
+    styles: (CellStyle | undefined)[][];
+}
+/** First table of a clipboard document, with spans expanded; null when there is none. */
+export declare function parseHtmlTable(html: string, view: Window & typeof globalThis): HtmlTable | null;

package/dist/types/grid/columnMenu.d.ts

@@ -3,13 +3,16 @@ import type { Messages } from './messages.js';
 export interface ColumnMenuOptions {
     anchor: HTMLElement;
     messages: Messages;
+    locale?: string;
     sort: SortOrder | null;
+    /** Another column is sorted, so this one can be added as a further key. */
+    sortedElsewhere: boolean;
     filter: ColumnFilter | undefined;
     /** Distinct display texts of the column ("" = blanks), already sorted. */
     values: string[];
     sortable: boolean;
     filterable: boolean;
-    onSort(order: SortOrder | null): void;
+    onSort(order: SortOrder | null, add?: boolean): void;
     onFilter(filter: ColumnFilter | null): void;
     onClose(): void;
 }

package/dist/types/grid/filters.d.ts

@@ -9,6 +9,7 @@ export interface ColumnFilter {
     values?: string[];
 }
 export type SortOrder = 'asc' | 'desc';
-export declare function matchesFilter(value: CellValue, text: string, filter: ColumnFilter): boolean;
+/** Text comparisons follow `locale`, so Turkish I/ı and İ/i pair up correctly. */
+export declare function matchesFilter(value: CellValue, text: string, filter: ColumnFilter, locale?: string): boolean;
 /** Spreadsheet sort order: numbers, text, booleans, errors; blanks always last. */
-export declare function compareForSort(a: CellValue, b: CellValue, order: SortOrder): number;
+export declare function compareForSort(a: CellValue, b: CellValue, order: SortOrder, locale?: string): number;

package/dist/types/grid/grid.d.ts

@@ -1,14 +1,16 @@
-import { type CellRange } from '../formula/address.js';
+import { type CellAddress, type CellRange } from '../formula/address.js';
 import { FormulaEngine } from '../formula/engine.js';
 import { type CellValue, type RawCell } from '../formula/values.js';
 import { type DataRow } from './binding.js';
 import { type CellMeta, type CellStyle, type ConditionalFormat } from './cellTypes.js';
 import { type CsvOptions } from '../export/csv.js';
+import { type ImportOptions, type ImportSheet } from '../export/xlsxRead.js';
 import type { ExportSheet } from '../export/types.js';
 import { type MenuEntry } from './contextMenu.js';
 import { type ColumnFilter, type SortOrder } from './filters.js';
 import { type MergeArea } from './merges.js';
 import { type Messages } from './messages.js';
+import { type SearchOptions } from './search.js';
 export interface GridOptions {
     /** Rows as arrays, or as objects bound to columns through `columns[i].data` (edits are written back). */
     data?: RawCell[][] | DataRow[];
@@ -60,6 +62,14 @@ export interface GridOptions {
     conditionalFormats?: ConditionalFormat[];
     /** Columns hidden initially. */
     hiddenColumns?: number[];
+    /** Ctrl+F / Ctrl+H open a find and replace box (they stay the browser's shortcuts otherwise). */
+    search?: boolean;
+    /** Shows a bar above the grid with the active cell's address and content; editable. */
+    formulaBar?: boolean;
+}
+export interface SortKey {
+    col: number;
+    order: SortOrder;
 }
 /** Row indexes: `row` is visual (as displayed, -1 if hidden), `physicalRow` is the data row. */
 export interface CellChange {
@@ -71,7 +81,7 @@ export interface CellChange {
     oldValue: RawCell;
     newValue: RawCell;
 }
-export type ChangeSource = 'edit' | 'paste' | 'cut' | 'clear' | 'autofill' | 'undo' | 'redo' | 'api';
+export type ChangeSource = 'edit' | 'paste' | 'cut' | 'clear' | 'autofill' | 'replace' | 'undo' | 'redo' | 'api';
 export type AlterAction = 'insert_row_above' | 'insert_row_below' | 'remove_row' | 'insert_col_start' | 'insert_col_end' | 'remove_col';
 interface HookMap {
     /** Return false to cancel; changes may be modified in place. */
@@ -80,6 +90,7 @@ interface HookMap {
     afterSelection: (row: number, col: number, row2: number, col2: number) => void;
     afterAlter: (action: AlterAction, index: number, amount: number) => void;
     afterColumnSort: (col: number, order: SortOrder | null) => void;
+    afterSort: (keys: SortKey[]) => void;
     afterFilter: (filters: Map<number, ColumnFilter>) => void;
     afterAutofill: (source: CellRange, target: CellRange) => void;
     afterValidate: (row: number, col: number, error: string | undefined) => void;
@@ -116,7 +127,7 @@ export declare class CenituGrid {
     private cellMeta;
     private labels;
     private filters;
-    private sortState;
+    private sortKeys;
     private invalid;
     /** Custom row heights by physical row. */
     private rowHeights;
@@ -146,6 +157,12 @@ export declare class CenituGrid {
     private undoStack;
     private redoStack;
     private clipboard;
+    private searchPanel?;
+    private searchQuery;
+    private searchOptions;
+    /** Matches shown highlighted while the search box is open (physical cell keys). */
+    private searchHits;
+    private bar?;
     private frame;
     private cleanup;
     constructor(container: HTMLElement, options?: GridOptions);
@@ -183,11 +200,23 @@ export declare class CenituGrid {
     setDataAtCell(row: number, col: number, value: RawCell, source?: ChangeSource): void;
     setDataAtCell(changes: [number, number, RawCell][], source?: ChangeSource): void;
     loadData(data: RawCell[][] | DataRow[]): void;
+    /**
+     * Replaces the grid's content with an imported sheet, including its formats, sizes, frozen
+     * panes and merges. Hidden rows are shown: the grid only hides rows through filters.
+     */
+    loadSheet(sheet: ImportSheet): void;
+    /**
+     * Reads one sheet of an .xlsx file into this grid (default the first) and adds the workbook's
+     * defined names to the engine. References to other sheets need all of them: see `workbookEngine`.
+     */
+    importXLSX(file: ArrayBuffer | Uint8Array | Blob, opts?: ImportOptions & {
+        sheet?: number | string;
+    }): Promise<ImportSheet>;
     /** Effective settings of a cell at a visual position. */
     getCellMeta(row: number, col: number): CellMeta;
     setCellMeta(row: number, col: number, meta: CellMeta): void;
     /** Updates a subset of options at runtime. */
-    updateSettings(s: Pick<GridOptions, 'fixedRowsTop' | 'fixedColumnsStart' | 'readOnly' | 'columns' | 'colHeaders' | 'mergeCells' | 'columnSorting' | 'filters' | 'fillHandle' | 'locale' | 'language' | 'contextMenu' | 'conditionalFormats'>): void;
+    updateSettings(s: Pick<GridOptions, 'fixedRowsTop' | 'fixedColumnsStart' | 'readOnly' | 'columns' | 'colHeaders' | 'mergeCells' | 'columnSorting' | 'filters' | 'fillHandle' | 'locale' | 'language' | 'contextMenu' | 'conditionalFormats' | 'search'>): void;
     selectCell(row: number, col: number, row2?: number, col2?: number): void;
     private announce;
     /** Selection as [[row, col, row2, col2]] (visual). */
@@ -223,15 +252,36 @@ export declare class CenituGrid {
     downloadXLSX(fileName?: string, others?: CenituGrid[]): Promise<void>;
     /** Sorts by one column (visual order only; data and formulas are untouched). null restores data order. */
     sort(col: number, order: SortOrder | null): void;
-    getSortState(): {
-        col: number;
-        order: SortOrder;
-    } | null;
+    /** Sorts by several columns: the first key decides, later keys break ties. Empty restores data order. */
+    sortBy(keys: SortKey[]): void;
+    private applySort;
+    /** The primary sort key, or null. */
+    getSortState(): SortKey | null;
+    getSortKeys(): SortKey[];
     setFilter(col: number, filter: ColumnFilter | null): void;
     clearFilters(): void;
     getFilters(): Map<number, ColumnFilter>;
     /** Re-evaluates the filters against current values (they are not re-applied automatically on edit). */
     applyFilters(): void;
+    /** Visual positions of the cells matching `query`, in reading order; hidden columns are skipped. */
+    findCells(query: string, opts?: SearchOptions): CellAddress[];
+    /** Selects the match after (or before) the active cell, wrapping around; null when there is none. */
+    findNext(query: string, opts?: SearchOptions, backward?: boolean): CellAddress | null;
+    /**
+     * Replaces the match in the active cell (when it is one) and moves to the next. Formula cells
+     * change only with `lookIn: 'formulas'`: replacing in their result would delete the formula.
+     */
+    replaceNext(query: string, replacement: string, opts?: SearchOptions): CellAddress | null;
+    /** Replaces every match in one undo step; returns the number of cells changed. */
+    replaceAll(query: string, replacement: string, opts?: SearchOptions): number;
+    /** Opens the find box (`search` option), with the replace row when `replace` is true. */
+    openSearch(replace?: boolean): void;
+    closeSearch(): void;
+    private searchText;
+    private nextHit;
+    private highlightHits;
+    private stepSearch;
+    private replaceIn;
     /** Merges an area (visual coordinates). Refused while sorting/filtering is active or across frozen edges. */
     mergeCells(row: number, col: number, rowspan: number, colspan: number): boolean;
     unmergeCells(row: number, col: number): boolean;
@@ -263,9 +313,11 @@ export declare class CenituGrid {
     copy(cut?: boolean): string | undefined;
     /**
      * Pastes text at the selection. Text from this grid's own copy keeps formulas, with relative
-     * references moved to the new location. A single value fills the whole selection.
+     * references moved to the new location and its cell styles. `html` is the clipboard's HTML
+     * flavour from another app; only the styles of its table are used. A single value fills the
+     * whole selection.
      */
-    paste(text: string): void;
+    paste(text: string, html?: string): void;
     /** Fills `target` (adjacent to `source`, visual coordinates) by extending the source series. */
     autofill(source: CellRange, target: CellRange): void;
     render(): void;
@@ -281,6 +333,7 @@ export declare class CenituGrid {
     private applyChanges;
     private clearRange;
     private replay;
+    private replayEntry;
     private applyMeta;
     private applyEngineOp;
     private undoEngineOp;
@@ -344,6 +397,11 @@ export declare class CenituGrid {
     openEditor(initial?: string): void;
     closeEditor(commit: boolean): void;
     private focusInput;
+    private barFocused;
+    private buildFormulaBar;
+    private onBarKey;
+    /** Shows the active cell in the bar; while editing, the bar mirrors the editor. */
+    private syncFormulaBar;
     /** Keeps the textarea over the active cell (in its pane), so IME windows appear in the right place. */
     private placeInput;
     private autoSizeInput;

package/dist/types/grid/messages.d.ts

@@ -2,6 +2,8 @@ export interface Messages {
     sortAsc: string;
     sortDesc: string;
     sortClear: string;
+    sortThenAsc: string;
+    sortThenDesc: string;
     filterByCondition: string;
     filterByValue: string;
     search: string;
@@ -42,6 +44,22 @@ export interface Messages {
     hideColumns: string;
     showColumns: string;
     cellAnnouncement: string;
+    find: string;
+    replace: string;
+    replaceAll: string;
+    replaceWith: string;
+    matchCase: string;
+    wholeCell: string;
+    lookInFormulas: string;
+    noMatches: string;
+    /** {total} is the number of matches. */
+    matchCount: string;
+    /** {count} is the number of cells changed. */
+    replacedCount: string;
+    next: string;
+    previous: string;
+    close: string;
+    formulaBar: string;
 }
 export declare const enUS: Messages;
 export declare const trTR: Messages;

package/dist/types/grid/search.d.ts

@@ -0,0 +1,41 @@
+import type { Messages } from './messages.js';
+export interface SearchOptions {
+    matchCase?: boolean;
+    /** Match only when the whole cell equals the query. */
+    wholeCell?: boolean;
+    /** 'values' (default) searches what cells display; 'formulas' searches what was entered. */
+    lookIn?: 'values' | 'formulas';
+}
+type Span = [number, number];
+/** Occurrences of `query` in `text` as [start, end) in `text`'s own indexes. */
+export declare function matchSpans(text: string, query: string, o?: SearchOptions, locale?: string): Span[];
+/** `text` with every occurrence of `query` replaced. */
+export declare function replaceSpans(text: string, spans: Span[], replacement: string): string;
+export interface SearchPanelOptions {
+    root: HTMLElement;
+    messages: Messages;
+    query: string;
+    options: SearchOptions;
+    /** Shows the replace row; false for read-only grids. */
+    replace: boolean;
+    /** Re-runs the search; returns the number of matches. */
+    onSearch(query: string, options: SearchOptions): number;
+    /** Moves to the next match; returns its 1-based position and the total. */
+    onNext(backward: boolean): {
+        index: number;
+        total: number;
+    };
+    onReplace(replacement: string): {
+        index: number;
+        total: number;
+    };
+    onReplaceAll(replacement: string): number;
+    onClose(): void;
+}
+export interface SearchPanel {
+    close(): void;
+    focus(replace: boolean): void;
+}
+/** Floating find/replace box over the grid's top right corner. */
+export declare function openSearchPanel(o: SearchPanelOptions): SearchPanel;
+export {};

package/dist/types/index.d.ts

@@ -1,7 +1,8 @@
-export { CenituGrid, type GridOptions, type CellChange, type ChangeSource, type AlterAction, type HookName, } from './grid/grid.js';
+export { CenituGrid, type GridOptions, type CellChange, type ChangeSource, type AlterAction, type SortKey, type HookName, } from './grid/grid.js';
 export type { CellMeta, CellStyle, ConditionalFormat, NumericFormat, CellRenderContext, CellType as GridCellType } from './grid/cellTypes.js';
 export type { ColumnFilter, ConditionOp, SortOrder } from './grid/filters.js';
 export type { MergeArea } from './grid/merges.js';
+export type { SearchOptions } from './grid/search.js';
 export type { MenuEntry, MenuItem } from './grid/contextMenu.js';
 export type { DataRow } from './grid/binding.js';
 export { enUS, trTR, type Messages } from './grid/messages.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cenitu-table",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Spreadsheet-like data grid with a built-in multi-sheet formula engine. Zero runtime dependencies.",
   "type": "module",
   "license": "MIT",