@syidax/advanced 0.0.0-stage → 1.0.1

package/dist/types/components/grid/core/grouping/display-types.d.ts

@@ -0,0 +1,165 @@
+import { BLANK_GROUP_KEY, foldGroupKey, type GroupMarkerRow } from '../pipeline/group.ts';
+export type DisplayRowKind = 'data' | 'group' | 'group-footer' | 'tree' | 'tree-filler' | 'pivot' | 'pivot-grand-total';
+export declare const DISPLAY_ROW_KINDS: readonly [
+    "data",
+    "group",
+    "group-footer",
+    "tree",
+    "tree-filler",
+    "pivot",
+    "pivot-grand-total"
+];
+export type DisplayRowIdentityKind = 'row-id' | 'key-path' | 'singleton';
+export interface DisplayRowPolicy {
+    readonly kind: DisplayRowKind;
+    readonly hasBackingData: boolean;
+    readonly identity: DisplayRowIdentityKind;
+    readonly selectableAsData: boolean;
+    readonly selectsDescendants: boolean;
+    readonly editable: boolean;
+    readonly focusable: boolean;
+    readonly exportsAsDataRow: boolean;
+    readonly exportsAsSummary: boolean;
+    readonly quickFilterSubject: boolean;
+}
+export declare const DISPLAY_ROW_POLICY: Readonly<Record<DisplayRowKind, DisplayRowPolicy>>;
+export declare const SYNTHETIC_ROW_KINDS: readonly DisplayRowKind[];
+export interface DisplayRowClassification<TRow = unknown> {
+    readonly kind: DisplayRowKind;
+    readonly policy: DisplayRowPolicy;
+    readonly data: TRow | null;
+    readonly keyPath: readonly string[] | null;
+    readonly level: number;
+    readonly label: string | null;
+}
+export declare function classifyDisplayRow<TRow = unknown>(row: unknown): DisplayRowClassification<TRow>;
+export declare function groupMarkerKeyPath(marker: GroupMarkerRow): readonly string[];
+export declare function isTreeDataRow(row: unknown): boolean;
+export declare function isSyntheticGroupRow(row: unknown): boolean;
+export type DisplayRowFeature = 'select' | 'focus' | 'edit' | 'export' | 'quick-filter' | 'expand';
+export declare const DISPLAY_ROW_FEATURES: readonly [
+    "select",
+    "focus",
+    "edit",
+    "export",
+    "quick-filter",
+    "expand"
+];
+export type DisplayRowRefusalReason = 'no-backing-data' | 'selects-descendants-instead' | 'derived-row' | 'not-expandable';
+export declare const DISPLAY_ROW_REFUSAL_REASONS: readonly [
+    "no-backing-data",
+    "selects-descendants-instead",
+    "derived-row",
+    "not-expandable"
+];
+export interface DisplayRowDecision {
+    readonly allowed: boolean;
+    readonly feature: DisplayRowFeature;
+    readonly kind: DisplayRowKind;
+    readonly reason: DisplayRowRefusalReason | null;
+    readonly instead: string;
+}
+export declare function decideDisplayRowFeature(row: unknown, feature: DisplayRowFeature, options?: {
+    readonly hasChildren?: boolean;
+}): DisplayRowDecision;
+export declare function rowHasChildren(row: unknown): boolean;
+export type GroupDisplayType = 'singleColumn' | 'multipleColumns' | 'groupRows' | 'custom';
+export declare const GROUP_DISPLAY_TYPES: readonly [
+    "singleColumn",
+    "multipleColumns",
+    "groupRows",
+    "custom"
+];
+export declare const AUTO_GROUP_COLUMN_PREFIX = "__sy_auto_group__";
+export declare function autoGroupColumnId(level: number): string;
+export interface AutoGroupColumnCustomization {
+    readonly headerName?: string;
+    readonly width?: number;
+    readonly minWidth?: number;
+    readonly pinned?: 'left' | 'right' | null;
+    readonly field?: string;
+    readonly headerNames?: readonly string[];
+    readonly hideGroupedColumns?: boolean;
+    readonly hideOpenParents?: boolean;
+    readonly cellAlign?: 'start' | 'end';
+}
+export interface AutoGroupColumnPlan {
+    readonly colId: string;
+    readonly headerName: string;
+    readonly showsLevel: number;
+    readonly width: number;
+    readonly minWidth: number;
+    readonly pinned: 'left' | 'right' | null;
+    readonly field: string | null;
+    readonly hideOpenParents: boolean;
+    readonly cellAlign: 'start' | 'end';
+}
+export type GroupDisplayRefusalReason = 'custom-columns-missing' | 'custom-id-collision' | 'custom-duplicate-id' | 'no-group-fields' | 'header-names-short';
+export declare const GROUP_DISPLAY_REFUSAL_REASONS: readonly [
+    "custom-columns-missing",
+    "custom-id-collision",
+    "custom-duplicate-id",
+    "no-group-fields",
+    "header-names-short"
+];
+export interface GroupDisplayRefusal {
+    readonly reason: GroupDisplayRefusalReason;
+    readonly requested: string;
+    readonly applied: string;
+    readonly detail: string;
+}
+export interface GroupDisplaySpec {
+    readonly displayType: GroupDisplayType;
+    readonly groupFields: readonly string[];
+    readonly autoGroupColumn?: AutoGroupColumnCustomization;
+    readonly customColumns?: readonly {
+        readonly colId: string;
+        readonly headerName?: string;
+        readonly showsLevel?: number;
+    }[];
+    readonly treeData?: boolean;
+}
+export interface GroupDisplayPlan {
+    readonly displayType: GroupDisplayType;
+    readonly groupFields: readonly string[];
+    readonly autoGroupColumns: readonly AutoGroupColumnPlan[];
+    readonly hiddenSourceFields: readonly string[];
+    readonly groupRowIsFullWidth: boolean;
+    readonly headerRowKind: DisplayRowKind;
+    readonly refusals: readonly GroupDisplayRefusal[];
+}
+export declare function resolveGroupDisplay(spec: GroupDisplaySpec): GroupDisplayPlan;
+export declare function autoGroupColumnForRow(plan: GroupDisplayPlan, row: unknown): string | null;
+export declare const QUICK_FILTER_STAGE: "pre-group";
+export interface QuickFilterResult<TRow> {
+    readonly rows: readonly TRow[];
+    readonly examined: number;
+    readonly derivedDropped: number;
+}
+export declare function quickFilterGroupedRows<TRow>(displayRows: readonly unknown[], matches: (row: TRow) => boolean): QuickFilterResult<TRow>;
+export type GroupExportMode = 'data-only' | 'with-group-rows' | 'group-rows-only';
+export declare const GROUP_EXPORT_MODES: readonly [
+    "data-only",
+    "with-group-rows",
+    "group-rows-only"
+];
+export interface GroupExportRow<TRow> {
+    readonly kind: DisplayRowKind;
+    readonly data: TRow | null;
+    readonly label: string | null;
+    readonly level: number;
+    readonly indent: number;
+}
+export declare function exportGroupedRows<TRow>(displayRows: readonly unknown[], mode?: GroupExportMode): readonly GroupExportRow<TRow>[];
+export interface GroupDisplayReport {
+    readonly displayType: GroupDisplayType;
+    readonly autoGroupColumnCount: number;
+    readonly groupRowIsFullWidth: boolean;
+    readonly refusalCount: number;
+    readonly kindCounts: Readonly<Record<DisplayRowKind, number>>;
+    readonly backedRows: number;
+    readonly syntheticRows: number;
+    readonly maxLevel: number;
+}
+export declare function groupDisplayReport(plan: GroupDisplayPlan, displayRows: readonly unknown[]): GroupDisplayReport;
+export { foldGroupKey, BLANK_GROUP_KEY };

package/dist/types/components/grid/core/grouping/group-selection.d.ts

@@ -0,0 +1,165 @@
+import { type AggFunc, type BuiltInAggFunc } from '../pipeline/aggregate.ts';
+import { type GroupMarkerRow } from '../pipeline/group.ts';
+import { groupMarkerKeyPath } from './display-types.ts';
+export type GroupCheckState = 'checked' | 'unchecked' | 'indeterminate';
+export declare const GROUP_CHECK_STATES: readonly [
+    "checked",
+    "unchecked",
+    "indeterminate"
+];
+export type GroupCheckEvidence = 'complete' | 'partial';
+export declare const GROUP_CHECK_EVIDENCE: readonly [
+    "complete",
+    "partial"
+];
+export type SelectionScopeKind = 'explicit' | 'all' | 'all-filtered';
+export declare const SELECTION_SCOPE_KINDS: readonly [
+    "explicit",
+    "all",
+    "all-filtered"
+];
+export type DescendantScope = 'all' | 'filtered';
+export declare const DESCENDANT_SCOPES: readonly [
+    "all",
+    "filtered"
+];
+export interface GroupSelectionState {
+    readonly kind: SelectionScopeKind;
+    readonly ids: ReadonlySet<string>;
+}
+export interface GroupCheckResult {
+    readonly state: GroupCheckState;
+    readonly evidence: GroupCheckEvidence;
+    readonly selected: number;
+    readonly total: number;
+    readonly unloaded: number;
+    readonly unloadedSelected: boolean | null;
+}
+export declare function resolveUnloadedSelection(selection: GroupSelectionState, attributableIds: ReadonlySet<string>): boolean | null;
+export declare function foldGroupCheckState(selected: number, total: number, unloaded: number, unloadedSelected: boolean | null): GroupCheckResult;
+export interface GroupLeaf {
+    readonly id: string;
+    readonly visible: boolean;
+}
+export interface GroupNodeInput {
+    readonly key: string;
+    readonly parentKey: string | null;
+    readonly level: number;
+    readonly label: string;
+    readonly leaves?: readonly GroupLeaf[];
+    readonly unloadedCount?: number;
+}
+export interface GroupNode {
+    readonly key: string;
+    readonly parentKey: string | null;
+    readonly level: number;
+    readonly label: string;
+    readonly childKeys: readonly string[];
+    readonly descendantLeaves: readonly GroupLeaf[];
+    readonly unloadedTotal: number;
+}
+export interface GroupHierarchy {
+    readonly nodes: ReadonlyMap<string, GroupNode>;
+    readonly rootKeys: readonly string[];
+    readonly attributableIds: ReadonlySet<string>;
+    readonly leaves: readonly GroupLeaf[];
+    readonly duplicateKeys: readonly string[];
+    readonly orphanKeys: readonly string[];
+}
+export declare function indexGroupHierarchy(inputs: readonly GroupNodeInput[]): GroupHierarchy;
+export declare function hierarchyFromDisplayRows<TRow>(displayRows: readonly unknown[], getRowId: (row: TRow) => string, isVisible?: (row: TRow) => boolean): GroupHierarchy;
+export declare function markerHierarchyKey(marker: GroupMarkerRow): string;
+export { groupMarkerKeyPath };
+export interface GroupCheckOptions {
+    readonly descendantScope?: DescendantScope;
+}
+export declare function isLeafSelected(selection: GroupSelectionState, id: string): boolean;
+export declare function resolveGroupCheckState(hierarchy: GroupHierarchy, key: string, selection: GroupSelectionState, options?: GroupCheckOptions): GroupCheckResult;
+export declare function resolveAllGroupCheckStates(hierarchy: GroupHierarchy, selection: GroupSelectionState, options?: GroupCheckOptions): ReadonlyMap<string, GroupCheckResult>;
+export type GroupSelectionAction = 'select' | 'deselect' | 'toggle';
+export declare const GROUP_SELECTION_ACTIONS: readonly [
+    "select",
+    "deselect",
+    "toggle"
+];
+export interface GroupSelectionEvent {
+    readonly type: 'groupSelectionChanged';
+    readonly key: string;
+    readonly before: GroupCheckState;
+    readonly after: GroupCheckState;
+    readonly beforeEvidence: GroupCheckEvidence;
+    readonly afterEvidence: GroupCheckEvidence;
+}
+export interface GroupAggregationEvent {
+    readonly type: 'aggregationChanged';
+    readonly key: string;
+    readonly fields: readonly string[];
+}
+export type GroupSelectionModelEvent = GroupSelectionEvent | GroupAggregationEvent;
+export interface GroupSelectionWrite {
+    readonly selection: GroupSelectionState;
+    readonly events: readonly GroupSelectionModelEvent[];
+    readonly changedLeafIds: readonly string[];
+}
+export declare function selectGroupDescendants(hierarchy: GroupHierarchy, key: string, action: GroupSelectionAction, selection: GroupSelectionState, options?: GroupCheckOptions & {
+    readonly aggFields?: readonly string[];
+}): GroupSelectionWrite;
+export declare function applySelectAll(hierarchy: GroupHierarchy, action: 'select' | 'clear', kind: SelectionScopeKind): GroupSelectionState;
+export declare function diffGroupSelection(before: ReadonlyMap<string, GroupCheckResult>, after: ReadonlyMap<string, GroupCheckResult>, aggFields?: readonly string[]): readonly GroupSelectionModelEvent[];
+export interface StickyGroupEntry {
+    readonly index: number;
+    readonly level: number;
+    readonly key: string;
+    readonly label: string;
+    readonly pushOffAt: number;
+    readonly offset: number;
+}
+export interface StickyGroupOptions {
+    readonly maxLevels?: number;
+    readonly rowHeight?: number;
+}
+export declare function resolveStickyGroups(displayRows: readonly unknown[], firstVisibleIndex: number, options?: StickyGroupOptions): readonly StickyGroupEntry[];
+export type TotalPlacement = 'off' | 'top' | 'bottom';
+export declare const TOTAL_PLACEMENTS: readonly [
+    "off",
+    "top",
+    "bottom"
+];
+export interface GroupTotalRow {
+    readonly __syGroupTotal: true;
+    readonly scope: 'group' | 'grand';
+    readonly key: string | null;
+    readonly label: string;
+    readonly level: number;
+    readonly placement: 'top' | 'bottom';
+    readonly aggregates: Readonly<Record<string, unknown>>;
+    readonly count: number;
+}
+export declare function isGroupTotalRow(row: unknown): row is GroupTotalRow;
+export interface TotalRowOptions<TRow = unknown> {
+    readonly groupTotals?: TotalPlacement;
+    readonly grandTotal?: TotalPlacement;
+    readonly aggSpecs?: ReadonlyArray<{
+        readonly field: string;
+        readonly agg: BuiltInAggFunc | AggFunc<TRow>;
+    }>;
+    readonly readField?: (row: TRow, field: string) => unknown;
+    readonly grandTotalLabel?: string;
+}
+export interface TotalRowResult {
+    readonly rows: readonly unknown[];
+    readonly groupTotalCount: number;
+    readonly grandTotalCount: number;
+}
+export declare function insertTotalRows<TRow = unknown>(displayRows: readonly unknown[], options?: TotalRowOptions<TRow>): TotalRowResult;
+export interface GroupSelectionReport {
+    readonly nodeCount: number;
+    readonly leafCount: number;
+    readonly selectedLeafCount: number;
+    readonly states: Readonly<Record<GroupCheckState, number>>;
+    readonly partialNodes: number;
+    readonly unloadedNodes: number;
+    readonly duplicateKeys: readonly string[];
+    readonly orphanKeys: readonly string[];
+}
+export declare function groupSelectionReport(hierarchy: GroupHierarchy, selection: GroupSelectionState, options?: GroupCheckOptions): GroupSelectionReport;

package/dist/types/components/grid/core/hover/row.d.ts

@@ -0,0 +1,8 @@
+export interface RowHoverState {
+    readonly hoveredRowId: string | number | null;
+}
+export declare function isValidRowId(id: unknown): id is string | number;
+export declare function createHoverState(): RowHoverState;
+export declare function isRowHovered(state: RowHoverState, rowId: unknown): boolean;
+export declare function setHoveredRow(state: RowHoverState, rowId: string | number | null): RowHoverState;
+export declare function clearHoveredRow(state: RowHoverState): RowHoverState;

package/dist/types/components/grid/core/import/csv/index.d.ts

@@ -0,0 +1 @@
+export { parseCsv, detectDelimiter, inferColumnTypes, csvToGrid, type CsvDelimiter, type ParseCsvOptions, type CsvColumnType, type CsvGridColumn, type CsvToGridOptions, type CsvGridData, } from './parse-csv';

package/dist/types/components/grid/core/import/csv/parse-csv.d.ts

@@ -0,0 +1,30 @@
+declare const CANDIDATE_DELIMITERS: readonly [
+    ",",
+    ";",
+    "\t",
+    "|"
+];
+export type CsvDelimiter = (typeof CANDIDATE_DELIMITERS)[number] | string;
+export interface ParseCsvOptions {
+    readonly delimiter?: CsvDelimiter;
+}
+export declare function detectDelimiter(text: string): CsvDelimiter;
+export declare function parseCsv(text: string, options?: ParseCsvOptions): string[][];
+export type CsvColumnType = 'number' | 'boolean' | 'string';
+export declare function inferColumnTypes(dataRows: ReadonlyArray<ReadonlyArray<string>>, columnCount: number): CsvColumnType[];
+export interface CsvGridColumn {
+    readonly field: string;
+    readonly headerName: string;
+    readonly type: CsvColumnType;
+}
+export interface CsvToGridOptions {
+    readonly delimiter?: CsvDelimiter;
+    readonly hasHeader?: boolean;
+}
+export interface CsvGridData {
+    readonly columns: CsvGridColumn[];
+    readonly rowData: Array<Record<string, string | number | boolean | null>>;
+    readonly delimiter: CsvDelimiter;
+}
+export declare function csvToGrid(text: string, options?: CsvToGridOptions): CsvGridData;
+export {};

package/dist/types/components/grid/core/import/xlsx/cell-ref.d.ts

@@ -0,0 +1,11 @@
+export interface CellRef {
+    readonly col: number;
+    readonly row: number;
+}
+export declare function decodeCellRef(ref: string): CellRef;
+export interface CellRange {
+    readonly start: CellRef;
+    readonly end: CellRef;
+}
+export declare function parseRange(ref: string): CellRange;
+export declare function encodeCellRef(col: number, row: number): string;

package/dist/types/components/grid/core/import/xlsx/errors.d.ts

@@ -0,0 +1,9 @@
+export type XlsxErrorReason = 'not_zip' | 'corrupt_zip' | 'truncated' | 'unsupported_encryption' | 'unsupported_zip64' | 'unsupported_compression' | 'unsupported_runtime' | 'missing_workbook' | 'missing_sheet_part' | 'malformed_xml' | 'unresolvable_reference' | 'inverted_range' | 'overlapping_merge' | 'unknown';
+export interface XlsxErrorClassification {
+    readonly reason: XlsxErrorReason;
+    readonly messageKo: string;
+    readonly messageEn: string;
+    readonly hint?: string;
+    readonly original: unknown;
+}
+export declare function classifyXlsxError(err: unknown): XlsxErrorClassification;

package/dist/types/components/grid/core/import/xlsx/formula.d.ts

@@ -0,0 +1,4 @@
+import type { XlsxSheet } from './sheet.ts';
+export declare function shiftFormulaRefs(formula: string, deltaCol: number, deltaRow: number, forceShift?: boolean): string;
+export declare function resolveSharedFormulas(sheet: XlsxSheet): XlsxSheet;
+export declare function collectArrayFormulaRanges(sheet: XlsxSheet): Map<string, string>;

package/dist/types/components/grid/core/import/xlsx/grid-import-chunk.d.ts

@@ -0,0 +1,3 @@
+export { parseXlsx, xlsxSheetToRowData } from './parse-xlsx.ts';
+export type { SheetToRowDataOptions, XlsxGridSnapshot, XlsxImportResult, } from './parse-xlsx';
+export { pickXlsxSheet } from './pick-sheet.ts';

package/dist/types/components/grid/core/import/xlsx/index.d.ts

@@ -0,0 +1,26 @@
+export { inflateRawBytes, supportsRawInflate } from './inflate.ts';
+export { ZIP_SIGNATURE_CENTRAL_DIR, ZIP_SIGNATURE_EOCD, ZIP_SIGNATURE_LOCAL_FILE, ZIP_SIGNATURE_ZIP64_EOCD, ZIP_SIGNATURE_ZIP64_LOCATOR, ZipFormatError, crc32, extractZipEntry, readZipArchive, readZipDirectory } from './zip-reader.ts';
+export type { ZipCompressionMethod, ZipDirectory, ZipDirectoryEntry } from './zip-reader';
+export { XmlParseError, localName, parseXml } from './xml-parser.ts';
+export type { XmlAttributes, XmlSaxHandlers } from './xml-parser';
+export { lookupSharedString, parseSharedStrings } from './shared-strings.ts';
+export { EMPTY_STYLE_SHEET, parseStyles } from './styles.ts';
+export type { XlsxCellXf, XlsxStyleSheet } from './styles';
+export { decodeCellRef, encodeCellRef, parseRange } from './cell-ref.ts';
+export type { CellRange, CellRef } from './cell-ref';
+export { buildMergedCellIndex, findMergeAt, isMergeAnchor, isMergeCovered } from './merged-cells.ts';
+export type { MergedRangeInfo } from './merged-cells';
+export { parseSheet } from './sheet.ts';
+export type { ParseSheetOptions, XlsxCell, XlsxCellType, XlsxFormulaMeta, XlsxRow, XlsxSheet } from './sheet';
+export { collectArrayFormulaRanges, resolveSharedFormulas, shiftFormulaRefs } from './formula.ts';
+export { BUILT_IN_NUMFMTS, applyNumberFormat, classifyFormat, excelSerialToDate, formatExcelDate, formatExcelNumber, getFormatCode, parseFormatSections } from './number-format.ts';
+export type { FormatKind, FormatSections } from './number-format';
+export { parseRelationships, parseWorkbook } from './workbook.ts';
+export type { RelationshipMap, XlsxDefinedName, XlsxWorkbook, XlsxWorkbookSheet } from './workbook';
+export { XlsxImportError, parseXlsx, xlsxSheetToRowData } from './parse-xlsx.ts';
+export type { SheetToRowDataOptions, XlsxColumnDef, XlsxGridSnapshot, XlsxImportResult, XlsxImportSheet } from './parse-xlsx';
+export { classifyXlsxError } from './errors.ts';
+export type { XlsxErrorClassification, XlsxErrorReason } from './errors';
+export { collectStreamingRows, parseSheetRows } from './sheet-streaming.ts';
+export type { SheetStreamingOptions } from './sheet-streaming';
+export { pickXlsxSheet } from './pick-sheet.ts';

package/dist/types/components/grid/core/import/xlsx/inflate.d.ts

@@ -0,0 +1,2 @@
+export declare function supportsRawInflate(): boolean;
+export declare function inflateRawBytes(input: Uint8Array): Promise<Uint8Array>;

package/dist/types/components/grid/core/import/xlsx/merged-cells.d.ts

@@ -0,0 +1,9 @@
+import { type CellRange } from './cell-ref.ts';
+export interface MergedRangeInfo {
+    readonly rangeRef: string;
+    readonly range: CellRange;
+}
+export declare function buildMergedCellIndex(rangeRefs: ReadonlyArray<string>): Map<string, MergedRangeInfo>;
+export declare function isMergeAnchor(index: Map<string, MergedRangeInfo>, col: number, row: number): boolean;
+export declare function isMergeCovered(index: Map<string, MergedRangeInfo>, col: number, row: number): boolean;
+export declare function findMergeAt(index: Map<string, MergedRangeInfo>, ref: string): MergedRangeInfo | undefined;

package/dist/types/components/grid/core/import/xlsx/number-format.d.ts

@@ -0,0 +1,16 @@
+import type { XlsxStyleSheet } from './styles.ts';
+export declare const BUILT_IN_NUMFMTS: Readonly<Record<number, string>>;
+export declare function getFormatCode(styleSheet: Pick<XlsxStyleSheet, 'numFmts'>, numFmtId: number): string;
+export interface FormatSections {
+    readonly positive: string;
+    readonly negative: string;
+    readonly zero: string;
+    readonly text: string;
+}
+export declare function parseFormatSections(format: string): FormatSections;
+export type FormatKind = 'general' | 'number' | 'percent' | 'scientific' | 'date' | 'time' | 'datetime' | 'text' | 'fraction';
+export declare function classifyFormat(section: string): FormatKind;
+export declare function excelSerialToDate(serial: number): Date;
+export declare function formatExcelDate(serial: number, format: string): string;
+export declare function formatExcelNumber(value: number, format: string): string;
+export declare function applyNumberFormat(value: string | number | boolean | null, formatCode: string): string;

package/dist/types/components/grid/core/import/xlsx/parse-xlsx.d.ts

@@ -0,0 +1,34 @@
+import { type XlsxWorkbook, type XlsxWorkbookSheet } from './workbook.ts';
+import { type XlsxStyleSheet } from './styles.ts';
+import { type XlsxSheet } from './sheet.ts';
+import { type MergedRangeInfo } from './merged-cells.ts';
+export interface XlsxImportSheet {
+    readonly meta: XlsxWorkbookSheet;
+    readonly sheet: XlsxSheet;
+    readonly mergedIndex: ReadonlyMap<string, MergedRangeInfo>;
+}
+export interface XlsxImportResult {
+    readonly workbook: XlsxWorkbook;
+    readonly sharedStrings: ReadonlyArray<string>;
+    readonly styles: XlsxStyleSheet;
+    readonly sheets: ReadonlyMap<string, XlsxImportSheet>;
+}
+export declare class XlsxImportError extends Error {
+    readonly cause?: unknown;
+    constructor(message: string, cause?: unknown);
+}
+export declare function parseXlsx(input: Uint8Array | ArrayBuffer | ArrayBufferView): Promise<XlsxImportResult>;
+export interface SheetToRowDataOptions {
+    readonly firstRowAsHeader?: boolean;
+    readonly fieldFromHeader?: (header: string, columnIndex: number) => string;
+    readonly preserveFormulas?: boolean;
+}
+export interface XlsxColumnDef {
+    readonly field: string;
+    readonly headerName: string;
+}
+export interface XlsxGridSnapshot {
+    readonly columnDefs: ReadonlyArray<XlsxColumnDef>;
+    readonly rowData: ReadonlyArray<Record<string, unknown>>;
+}
+export declare function xlsxSheetToRowData(imported: XlsxImportSheet, styles: XlsxStyleSheet, options?: SheetToRowDataOptions): XlsxGridSnapshot;

package/dist/types/components/grid/core/import/xlsx/pick-sheet.d.ts

@@ -0,0 +1,2 @@
+import type { XlsxImportResult, XlsxImportSheet } from './parse-xlsx.ts';
+export declare function pickXlsxSheet(result: XlsxImportResult, sheetName?: string): XlsxImportSheet | undefined;

package/dist/types/components/grid/core/import/xlsx/shared-strings.d.ts

@@ -0,0 +1,2 @@
+export declare function parseSharedStrings(input: Uint8Array | string): string[];
+export declare function lookupSharedString(table: ReadonlyArray<string>, index: number): string;

package/dist/types/components/grid/core/import/xlsx/sheet-streaming.d.ts

@@ -0,0 +1,11 @@
+import { type ParseSheetOptions, type XlsxRow, type XlsxSheet } from './sheet.ts';
+export interface SheetStreamingOptions extends ParseSheetOptions {
+    readonly onProgress?: (rowsEmitted: number) => void;
+    readonly progressInterval?: number;
+}
+export declare function parseSheetRows(input: Uint8Array | string, options?: SheetStreamingOptions): AsyncIterable<XlsxRow> & {
+    metaPromise: Promise<Omit<XlsxSheet, 'rows'>>;
+};
+export declare function collectStreamingRows(iter: AsyncIterable<XlsxRow> & {
+    metaPromise: Promise<Omit<XlsxSheet, 'rows'>>;
+}): Promise<XlsxSheet>;

package/dist/types/components/grid/core/import/xlsx/sheet.d.ts

@@ -0,0 +1,31 @@
+export type XlsxCellType = 'n' | 'b' | 's' | 'str' | 'inlineStr' | 'e' | 'd';
+export interface XlsxCell {
+    readonly ref: string;
+    readonly col: number;
+    readonly row: number;
+    readonly type: XlsxCellType;
+    readonly value: string | number | boolean | null;
+    readonly styleIndex: number;
+    readonly formula?: string;
+    readonly formulaMeta?: XlsxFormulaMeta;
+}
+export interface XlsxFormulaMeta {
+    readonly kind: 'normal' | 'array' | 'shared' | 'dataTable';
+    readonly ref?: string;
+    readonly si?: number;
+}
+export interface XlsxRow {
+    readonly index: number;
+    readonly heightPt?: number;
+    readonly hidden: boolean;
+    readonly cells: ReadonlyArray<XlsxCell>;
+}
+export interface XlsxSheet {
+    readonly dimension?: string;
+    readonly rows: ReadonlyArray<XlsxRow>;
+    readonly mergedRanges: ReadonlyArray<string>;
+}
+export interface ParseSheetOptions {
+    readonly sharedStrings?: ReadonlyArray<string>;
+}
+export declare function parseSheet(input: Uint8Array | string, options?: ParseSheetOptions): XlsxSheet;

package/dist/types/components/grid/core/import/xlsx/styles.d.ts

@@ -0,0 +1,21 @@
+export interface XlsxCellXf {
+    readonly numFmtId: number;
+    readonly fontId: number;
+    readonly fillId: number;
+    readonly borderId: number;
+    readonly xfId: number;
+    readonly applyNumberFormat: boolean;
+    readonly applyFont: boolean;
+    readonly applyFill: boolean;
+    readonly applyBorder: boolean;
+    readonly applyAlignment: boolean;
+}
+export interface XlsxStyleSheet {
+    readonly numFmts: ReadonlyMap<number, string>;
+    readonly cellXfs: ReadonlyArray<XlsxCellXf>;
+    readonly fontCount: number;
+    readonly fillCount: number;
+    readonly borderCount: number;
+}
+export declare function parseStyles(input: Uint8Array | string): XlsxStyleSheet;
+export declare const EMPTY_STYLE_SHEET: XlsxStyleSheet;

package/dist/types/components/grid/core/import/xlsx/workbook.d.ts

@@ -0,0 +1,22 @@
+export interface XlsxDefinedName {
+    readonly name: string;
+    readonly localSheetIndex?: number;
+    readonly value: string;
+    readonly hidden: boolean;
+}
+export interface XlsxWorkbookSheet {
+    readonly name: string;
+    readonly sheetId: number;
+    readonly relId: string;
+    readonly state: 'visible' | 'hidden' | 'veryHidden';
+}
+export interface XlsxWorkbook {
+    readonly sheets: ReadonlyArray<XlsxWorkbookSheet>;
+    readonly definedNames: ReadonlyArray<XlsxDefinedName>;
+    readonly date1904: boolean;
+}
+export declare function parseWorkbook(input: Uint8Array | string): XlsxWorkbook;
+export interface RelationshipMap {
+    readonly byId: ReadonlyMap<string, string>;
+}
+export declare function parseRelationships(input: Uint8Array | string, partDir: string): RelationshipMap;

package/dist/types/components/grid/core/import/xlsx/xml-parser.d.ts

@@ -0,0 +1,15 @@
+export declare class XmlParseError extends Error {
+    readonly line: number;
+    readonly column: number;
+    constructor(message: string, line: number, column: number);
+}
+export interface XmlAttributes {
+    readonly [name: string]: string;
+}
+export interface XmlSaxHandlers {
+    onOpenTag?: (name: string, attrs: XmlAttributes, selfClosing: boolean) => void;
+    onCloseTag?: (name: string) => void;
+    onText?: (text: string) => void;
+}
+export declare function parseXml(xml: string, handlers: XmlSaxHandlers): void;
+export declare function localName(qualifiedName: string): string;

package/dist/types/components/grid/core/import/xlsx/zip-reader.d.ts

@@ -0,0 +1,28 @@
+export declare const ZIP_SIGNATURE_LOCAL_FILE = 67324752;
+export declare const ZIP_SIGNATURE_CENTRAL_DIR = 33639248;
+export declare const ZIP_SIGNATURE_EOCD = 101010256;
+export declare const ZIP_SIGNATURE_ZIP64_EOCD = 101075792;
+export declare const ZIP_SIGNATURE_ZIP64_LOCATOR = 117853008;
+export type ZipCompressionMethod = 0 | 8;
+export interface ZipDirectoryEntry {
+    readonly fileName: string;
+    readonly fileNameBytes: Uint8Array;
+    readonly compressionMethod: ZipCompressionMethod;
+    readonly crc32: number;
+    readonly compressedSize: number;
+    readonly uncompressedSize: number;
+    readonly localHeaderOffset: number;
+    readonly generalPurposeBitFlag: number;
+    readonly rawCompressionMethod: number;
+}
+export interface ZipDirectory {
+    readonly entries: ReadonlyArray<ZipDirectoryEntry>;
+    readonly comment: string;
+}
+export declare class ZipFormatError extends Error {
+    constructor(message: string);
+}
+export declare function readZipDirectory(bytes: Uint8Array): ZipDirectory;
+export declare function crc32(bytes: Uint8Array): number;
+export declare function extractZipEntry(bytes: Uint8Array, entry: ZipDirectoryEntry): Promise<Uint8Array>;
+export declare function readZipArchive(bytes: Uint8Array): Promise<Map<string, Uint8Array>>;