rowvia 0.1.0

package/dist/types/features/editService.d.ts

@@ -0,0 +1,62 @@
+import type { Column, RowNode } from '../types';
+import type { EventService } from '../core/eventService';
+import type { Grid } from '../grid';
+export interface FocusedCell {
+    rowIndex: number;
+    column: Column;
+    rowNode: RowNode;
+}
+export declare class EditService {
+    private grid;
+    private eventService;
+    private editing;
+    /** full-row editing: one editor per editable cell in the row */
+    private fullRowEditors;
+    private fullRowNode;
+    private focusedCell;
+    private suppressClickEdit;
+    constructor(grid: Grid, eventService: EventService);
+    getFocusedCell(): FocusedCell | null;
+    setFocusedCell(rowIndex: number, column: Column): void;
+    clearFocusedCell(): void;
+    /** remove the focus ring from every cell (only one cell can be focused) */
+    private clearFocusClass;
+    private findCellElement;
+    isEditing(): boolean;
+    getEditingCells(): Array<{
+        rowIndex: number;
+        colId: string;
+    }>;
+    startEditingCell(params: {
+        rowIndex: number;
+        colKey: string | Column;
+        charPress?: string;
+    }): void;
+    private startFullRowEditing;
+    private createEditor;
+    stopEditing(cancel?: boolean): boolean;
+    private applyValueSetter;
+    private stopFullRowEditing;
+    private onEditorKeyDown;
+    /** grid level key handling */
+    onGridKeyDown(event: KeyboardEvent): void;
+    private isTextInput;
+    private getPageJump;
+    moveFocus(rowDelta: number, colDelta: number): void;
+    tabToNextCell(): void;
+    tabToPreviousCell(): void;
+    /** cell click → focus + maybe edit */
+    onCellClicked(params: {
+        node: RowNode;
+        column: Column;
+        event: MouseEvent;
+        rowIndex: number;
+    }): void;
+    onCellDoubleClicked(params: {
+        node: RowNode;
+        column: Column;
+        event: MouseEvent;
+        rowIndex: number;
+    }): void;
+    destroy(): void;
+}

package/dist/types/features/exportService.d.ts

@@ -0,0 +1,39 @@
+import type { ExportParams } from '../types';
+import type { Grid } from '../grid';
+import { escapeHtml } from '../core/utils';
+export declare class ExportService {
+    private grid;
+    private lastCopied;
+    constructor(grid: Grid);
+    private getExportColumns;
+    private getExportRows;
+    private getCellValueForExport;
+    getDataAsCsv(params?: ExportParams): string;
+    private csvRow;
+    getDataAsExcel(params?: ExportParams): Blob;
+    exportToCsv(params?: ExportParams): void;
+    exportToExcel(params?: ExportParams): void;
+    /** PDF export — paginated, Helvetica, header row shaded and bold. */
+    getDataAsPdf(params?: ExportParams & {
+        pageSize?: string;
+        title?: string;
+    }): Blob;
+    exportToPdf(params?: ExportParams & {
+        pageSize?: string;
+        title?: string;
+    }): void;
+    /** Excel import — reads .xlsx files and loads the first sheet as row data. */
+    importExcel(file: Blob | ArrayBuffer, params?: {
+        sheetIndex?: number;
+        onSuccess?: (rows: any[]) => void;
+    }): Promise<any[]>;
+    private fileName;
+    private download;
+    copyToClipboard(params?: any): void;
+    cutToClipboard(params?: any): void;
+    pasteFromClipboard(): void;
+    pasteText(text: string): void;
+    private writeToClipboard;
+    private fallbackCopy;
+}
+export { escapeHtml };

package/dist/types/features/filterGui.d.ts

@@ -0,0 +1,19 @@
+import type { Column } from '../types';
+import type { Grid } from '../grid';
+import { PopupService } from './popupService';
+export declare class FilterGui {
+    private grid;
+    private popupService;
+    constructor(grid: Grid, popupService: PopupService);
+    openFilter(column: Column, anchor: HTMLElement): void;
+    private buildSetFilter;
+    private buildConditionSelect;
+    /** Multi Filter: several filter types combined with AND/OR on one column. */
+    openMultiFilter(column: Column, anchor: HTMLElement): void;
+    /** Advanced Filter: cross-column expression builder. */
+    openAdvancedFilter(anchor: HTMLElement): void;
+    /** Custom column filter component (colDef.filterComponent). */
+    private openCustomFilter;
+    private getDefaultModel;
+    private isMeaningful;
+}

package/dist/types/features/filterService.d.ts

@@ -0,0 +1,36 @@
+import type { Column, FilterModelItem } from '../types';
+import type { Grid } from '../grid';
+export interface AdvancedFilterCondition {
+    colId: string;
+    type: string;
+    filter?: any;
+    filterTo?: any;
+    dateFrom?: string;
+    dateTo?: string;
+}
+export interface AdvancedFilterModel {
+    filterType: 'advanced';
+    operator: 'AND' | 'OR';
+    conditions: AdvancedFilterCondition[];
+}
+export declare class FilterService {
+    private grid;
+    private filterModel;
+    private advancedFilterModel;
+    constructor(grid: Grid);
+    getAdvancedFilterModel(): AdvancedFilterModel | null;
+    setAdvancedFilterModel(model: AdvancedFilterModel | null): void;
+    isAdvancedFilterEnabled(): boolean;
+    /** evaluate the advanced filter model against a node */
+    doesNodePassAdvancedFilter(node: any): boolean;
+    getFilterModel(): Record<string, FilterModelItem>;
+    getFilterInstance(colId: string): FilterModelItem | undefined;
+    setFilterModel(model: Record<string, FilterModelItem> | null): void;
+    setColumnFilterModel(colKey: string | Column, model: FilterModelItem | null): void;
+    isFilterActive(column: Column): boolean;
+    private isModelMeaningful;
+    /** build a filter model from a floating-filter value */
+    handleFloatingFilterChange(column: Column, value: string): void;
+    resetFilters(): void;
+    onFilterChanged(source: string): void;
+}

package/dist/types/features/findService.d.ts

@@ -0,0 +1,27 @@
+import type { Grid } from '../grid';
+import type { PopupService } from './popupService';
+export declare class FindService {
+    private grid;
+    private popupService;
+    private matches;
+    private activeMatch;
+    private searchText;
+    private matchCase;
+    private ePopup;
+    private eCount;
+    private eInput;
+    private closePopup;
+    constructor(grid: Grid, popupService: PopupService);
+    isOpen(): boolean;
+    open(): void;
+    close(): void;
+    setFindText(text: string): void;
+    getFindText(): string;
+    getNumMatches(): number;
+    getActiveMatch(): number;
+    find(text: string): void;
+    findNext(): boolean;
+    findPrevious(): boolean;
+    private goToActive;
+    applyHighlight(): void;
+}

package/dist/types/features/formulaEditor.d.ts

@@ -0,0 +1,11 @@
+import type { Column } from '../types';
+import type { Grid } from '../grid';
+import type { PopupService } from './popupService';
+/** Formula editor popup — edits a column's formula (calculated columns). */
+export declare class FormulaEditorService {
+    private grid;
+    private popupService;
+    constructor(grid: Grid, popupService: PopupService);
+    isFormulaColumn(column: Column): boolean;
+    openFormulaEditor(column: Column, anchor: HTMLElement): void;
+}

package/dist/types/features/notesService.d.ts

@@ -0,0 +1,23 @@
+import type { Grid } from '../grid';
+import type { PopupService } from './popupService';
+interface NoteKey {
+    rowNodeId: string;
+    colId: string;
+}
+/**
+ * Cell Notes (ag-grid Notes) — note markers in cell corners with an editor popup.
+ * Notes can be declared per column (colDef.note) or set at runtime via the API.
+ */
+export declare class NotesService {
+    private grid;
+    private popupService;
+    private runtimeNotes;
+    constructor(grid: Grid, popupService: PopupService);
+    private keyOf;
+    /** the note text for a cell, or undefined when there is none */
+    getNote(rowNodeId: string, colId: string, colDefNote?: any, params?: any): string | undefined;
+    setNote(rowNodeId: string, colId: string, note: string | undefined): void;
+    /** open the note editor popup anchored to the note marker */
+    openNoteEditor(rowNodeId: string, colId: string, anchor: HTMLElement): void;
+}
+export type { NoteKey };

package/dist/types/features/overlays.d.ts

@@ -0,0 +1,14 @@
+import type { Grid } from '../grid';
+export declare class OverlayService {
+    private grid;
+    private eOverlayWrapper;
+    private current;
+    constructor(grid: Grid);
+    private show;
+    showLoadingOverlay(): void;
+    showNoRowsOverlay(): void;
+    hideOverlay(): void;
+    /** auto-show/hide based on row count */
+    updateAuto(): void;
+    getCurrent(): 'loading' | 'noRows' | null;
+}

package/dist/types/features/paginationService.d.ts

@@ -0,0 +1,32 @@
+import type { Grid } from '../grid';
+import type { EventService } from '../core/eventService';
+export declare class PaginationService {
+    private grid;
+    private eventService;
+    private enabled;
+    private pageSize;
+    private currentPage;
+    private pageSizeSelector;
+    private ePanel;
+    private ePageInfo;
+    private ePageInput;
+    private ePageSizeSelect;
+    private ePageSizeContainer;
+    private eFromToContainer;
+    constructor(grid: Grid, eventService: EventService);
+    isEnabled(): boolean;
+    setEnabled(enabled: boolean): void;
+    getPageSize(): number;
+    setPageSize(size: number): void;
+    getCurrentPage(): number;
+    getTotalPages(): number;
+    goToPage(page: number): void;
+    goToNextPage(): void;
+    goToPreviousPage(): void;
+    goToFirstPage(): void;
+    goToLastPage(): void;
+    /** clamp the current page when row count shrinks; refresh labels */
+    update(): void;
+    getPanel(): HTMLElement;
+    isLastPageFound(): boolean;
+}

package/dist/types/features/pdfWriter.d.ts

@@ -0,0 +1,24 @@
+/** Minimal PDF writer (Helvetica base-14 fonts, no dependencies). */
+export interface PdfCell {
+    text: string;
+    bold?: boolean;
+    align?: 'left' | 'right' | 'center';
+}
+export interface PdfTable {
+    /** column widths in points; the table is laid out left to right */
+    columnWidths: number[];
+    rows: PdfCell[][];
+    /** optional row fill colour (0-1 rgb) e.g. header shading */
+    rowFill?: Array<[number, number, number] | undefined>;
+}
+export interface PdfOptions {
+    pageSize?: 'a4-landscape' | 'a4-portrait' | 'letter-landscape' | 'letter-portrait';
+    margin?: number;
+    fontSize?: number;
+    title?: string;
+    headerColor?: [number, number, number];
+    borderColor?: [number, number, number];
+    rowHeight?: number;
+}
+/** build the PDF bytes from page content streams */
+export declare function createPdf(pages: PdfTable[], options?: PdfOptions): Blob;

package/dist/types/features/popupService.d.ts

@@ -0,0 +1,15 @@
+import type { Grid } from '../grid';
+/** Generic popup used by filters, menus, find bar and chart panel. */
+export declare class PopupService {
+    private grid;
+    private openPopups;
+    constructor(grid: Grid);
+    getParent(): HTMLElement;
+    createPopup(width?: number, className?: string): {
+        ePopup: HTMLElement;
+        close: () => void;
+        onClose: (cb: () => void) => void;
+    };
+    positionAt(ePopup: HTMLElement, anchor: HTMLElement, offsetX?: number): void;
+    closeAll(): void;
+}

package/dist/types/features/rangeSelection.d.ts

@@ -0,0 +1,43 @@
+import type { Grid } from '../grid';
+import type { EventService } from '../core/eventService';
+import type { Column } from '../types';
+interface RangeState {
+    rowStartIndex: number;
+    rowEndIndex: number;
+    colStartId: string;
+    colEndId: string;
+}
+export declare class RangeSelectionService {
+    private grid;
+    private eventService;
+    private ranges;
+    private currentRange;
+    private eOverlay;
+    private eHandle;
+    private dragState;
+    constructor(grid: Grid, eventService: EventService);
+    isEnabled(): boolean;
+    getRanges(): RangeState[];
+    clearRanges(): void;
+    onCellMouseDown(params: {
+        event: MouseEvent;
+        column: Column;
+        rowIndex: number;
+    }): void;
+    onHandleMouseDown(event: MouseEvent): void;
+    private onMouseMove;
+    private onMouseUp;
+    private getCenterColumns;
+    private getRangeBounds;
+    updateOverlay(): void;
+    /** toggle the highlight class on every rendered cell */
+    applyHighlight(): void;
+    /** cells covered by the first range */
+    getRangeCells(range: RangeState): Array<{
+        node: any;
+        column: Column;
+    }>;
+    getCurrentRange(): RangeState | null;
+    onGridKeyDown(event: KeyboardEvent): void;
+}
+export {};

package/dist/types/features/rowDragService.d.ts

@@ -0,0 +1,25 @@
+import type { Grid } from '../grid';
+import type { EventService } from '../core/eventService';
+import type { RowNode } from '../types';
+/**
+ * Row Dragging — managed (grid reorders the data) and unmanaged (app receives
+ * the drop) modes, matching ag-grid's rowDragManaged / rowDragEnd events.
+ */
+export declare class RowDragService {
+    private grid;
+    private eventService;
+    private dragState;
+    constructor(grid: Grid, eventService: EventService);
+    isEnabled(): boolean;
+    private hasDragHandle;
+    /** begin dragging a row from its drag handle */
+    startDrag(rowNode: RowNode, event: MouseEvent): void;
+    private rowLabel;
+    private onMouseMove;
+    private onMouseUp;
+    private onMouseMoveBind;
+    private onMouseUpBind;
+    private indexOf;
+    /** managed reorder — moves the row data and re-applies it */
+    private moveRow;
+}

package/dist/types/features/rowGroupPanel.d.ts

@@ -0,0 +1,10 @@
+import type { Grid } from '../grid';
+/** The "Row Groups" drop strip shown above the header (rowGroupPanelShow). */
+export declare class RowGroupPanel {
+    private grid;
+    private ePanel;
+    private eChips;
+    constructor(grid: Grid);
+    refresh(): void;
+    private refreshVisibility;
+}

package/dist/types/features/selectionService.d.ts

@@ -0,0 +1,34 @@
+import type { RowNode } from '../types';
+import type { EventService } from '../core/eventService';
+export declare class SelectionService {
+    private eventService;
+    private getOptions;
+    private isNodeSelectable;
+    private selectedNodes;
+    private lastSelectedNode;
+    constructor(eventService: EventService, getOptions: () => any, isNodeSelectable: (node: RowNode) => boolean);
+    isEnabled(): boolean;
+    getSelectedNodes(): RowNode[];
+    getSelectedRows(): any[];
+    getSelectedCount(): number;
+    isNodeSelected(node: RowNode): boolean;
+    selectNode(node: RowNode, clearSelection?: boolean): void;
+    deselectNode(node: RowNode): void;
+    private selectChildrenRecursively;
+    selectAll(): void;
+    selectAllFiltered(): void;
+    deselectAll(): void;
+    toggleNode(node: RowNode): void;
+    /** row click handling honouring modifiers */
+    handleRowClick(node: RowNode, event: MouseEvent): boolean;
+    private selectRange;
+    /** called when rows are removed so stale nodes don't linger */
+    syncWithModel(): void;
+    getLastSelectedNode(): RowNode | null;
+    setSelectAllCheckboxState(checked: boolean): void;
+    getSelectAllState(): {
+        checked: boolean;
+        indeterminate: boolean;
+    };
+    private dispatchChanged;
+}

package/dist/types/features/sideBar.d.ts

@@ -0,0 +1,29 @@
+import type { Grid } from '../grid';
+export interface ToolPanelDef {
+    id: string;
+    label: string;
+}
+export declare class SideBarService {
+    private grid;
+    private eBar;
+    private eButtons;
+    private ePanel;
+    private panels;
+    private activePanelId;
+    private visible;
+    private position;
+    constructor(grid: Grid);
+    private defaultLabel;
+    private buildButtons;
+    getElement(): HTMLElement;
+    setPosition(position: 'left' | 'right'): void;
+    setVisible(visible: boolean): void;
+    isVisible(): boolean;
+    openPanel(id: string): void;
+    getActivePanel(): string | null;
+    refresh(): void;
+    private buildColumnsPanel;
+    private buildColumnItem;
+    private buildFiltersPanel;
+    private buildFilterItem;
+}

package/dist/types/features/sortService.d.ts

@@ -0,0 +1,12 @@
+import type { Column, SortDirection, SortModelItem } from '../types';
+import type { Grid } from '../grid';
+export declare class SortService {
+    private grid;
+    constructor(grid: Grid);
+    getSortingOrder(): SortDirection[];
+    onSortRequested(column: Column, event: MouseEvent, multiSort: boolean): void;
+    private renumberSortIndices;
+    getSortModel(): SortModelItem[];
+    setSortModel(model: SortModelItem[]): void;
+    onSortChanged(source: string): void;
+}

package/dist/types/features/statusBar.d.ts

@@ -0,0 +1,14 @@
+import type { Grid } from '../grid';
+import type { EventService } from '../core/eventService';
+export declare class StatusBarService {
+    private grid;
+    private eventService;
+    private eBar;
+    private panels;
+    constructor(grid: Grid, eventService: EventService);
+    getElement(): HTMLElement;
+    isVisible(): boolean;
+    setVisible(visible: boolean): void;
+    update(): void;
+    private renderPanel;
+}

package/dist/types/features/undoRedoService.d.ts

@@ -0,0 +1,40 @@
+import type { Grid } from '../grid';
+import type { EventService } from '../core/eventService';
+export interface UndoRedoAction {
+    rowNodeId: string;
+    colId: string;
+    oldValue: any;
+    newValue: any;
+    /** batch id — edits committed in one batch share an id and undo together */
+    batchId: number;
+}
+/**
+ * Undo / Redo for cell edits (ag-grid undoRedoCellEditing).
+ * Records every committed edit and can replay them in both directions.
+ */
+export declare class UndoRedoService {
+    private grid;
+    private eventService;
+    private undoStack;
+    private redoStack;
+    private limit;
+    private batchDepth;
+    private batchBuffer;
+    private batchCounter;
+    private currentBatchId;
+    constructor(grid: Grid, eventService: EventService);
+    isEnabled(): boolean;
+    /** record a committed edit */
+    pushAction(action: UndoRedoAction): void;
+    canUndo(): boolean;
+    canRedo(): boolean;
+    getUndoStackSize(): number;
+    getRedoStackSize(): number;
+    undo(): number;
+    redo(): number;
+    private applyValue;
+    startBatchEdit(): void;
+    endBatchEdit(cancel?: boolean): void;
+    isBatchEditing(): boolean;
+    clear(): void;
+}

package/dist/types/features/xlsxReader.d.ts

@@ -0,0 +1,7 @@
+/** XLSX reader — ZIP central directory + DOMParser (deflate via DecompressionStream). */
+export interface XlsxSheet {
+    name: string;
+    rows: string[][];
+}
+/** read every sheet of an xlsx file as string rows */
+export declare function readXlsx(buffer: ArrayBuffer): Promise<XlsxSheet[]>;

package/dist/types/features/xlsxWriter.d.ts

@@ -0,0 +1,10 @@
+/** Minimal XLSX writer: ZIP (store, no compression) + SpreadsheetML. No dependencies. */
+export interface XlsxCell {
+    value: string | number | boolean | null | undefined;
+    bold?: boolean;
+}
+export interface XlsxSheet {
+    name: string;
+    rows: XlsxCell[][];
+}
+export declare function createXlsx(sheets: XlsxSheet[]): Blob;

package/dist/types/gantt/component.d.ts

@@ -0,0 +1,25 @@
+import type { GridApi } from '../types';
+import { GanttChart } from './ganttChart';
+import type { GanttUnit } from './ganttChart';
+import type { GanttTask, TeamMember } from './data';
+export interface GanttOptions {
+    tasks: GanttTask[];
+    members?: TeamMember[];
+    title?: string;
+    unit?: GanttUnit;
+    tableWidth?: number;
+    onTaskChange?: (task: GanttTask) => void;
+    /** Overrides the built-in text detail dialog when provided. */
+    onTaskOpen?: (task: GanttTask) => void;
+}
+export interface GanttApi {
+    grid: GridApi;
+    chart: GanttChart;
+    setTasks(tasks: GanttTask[]): void;
+    expandAll(): void;
+    collapseAll(): void;
+    scrollToTask(id: string): void;
+    destroy(): void;
+}
+/** Mount an isolated tree grid and timeline. The caller owns persistence. */
+export declare function createGantt(container: HTMLElement, options: GanttOptions): GanttApi;

package/dist/types/gantt/data.d.ts

@@ -0,0 +1,31 @@
+export interface TeamMember {
+    id: string;
+    name: string;
+}
+export type TaskKind = 'phase' | 'feature' | 'task';
+export type TaskStatus = 'not-started' | 'in-progress' | 'done' | 'delayed';
+export interface GanttTask {
+    id: string;
+    path: string[];
+    name: string;
+    kind: TaskKind;
+    /** member id; null means nobody assigned yet (one-click fill in the gantt) */
+    owner: string | null;
+    status: TaskStatus;
+    /** YYYY-MM-DD; group rows carry the rolled-up span of their children */
+    start: string | null;
+    end: string | null;
+    /** 0-100 for leaf tasks */
+    progress: number;
+    hours: number;
+    milestone: boolean;
+    dependsOn: string[];
+}
+export declare function toDateKey(date: Date): string;
+export declare function parseDateKey(key: string): Date;
+export declare function addDays(date: Date, days: number): Date;
+export declare function dayDiff(from: Date | string, to: Date | string): number;
+export declare function todayKey(): string;
+/** 已延期 is derived: unfinished work whose end date has passed */
+export declare function effectiveTaskStatus(task: GanttTask): TaskStatus;
+export declare function formatCnDate(key: string): string;

package/dist/types/gantt/filterSort.d.ts

@@ -0,0 +1,50 @@
+import type { GridApi } from '../types';
+/** 表格外的筛选 / 排序面板（工具栏按钮 + 浮层）。 */
+type FieldKind = 'text' | 'number' | 'date';
+interface FilterFieldDef {
+    colId: string;
+    label: string;
+    kind: FieldKind;
+    /** 值域已知的字段用下拉选择，值用原始数据（筛选按字段原值匹配） */
+    options?: Array<{
+        value: string;
+        label: string;
+    }>;
+}
+interface SortFieldDef {
+    colId: string;
+    label: string;
+}
+/** 两个浮层共用的容器管理：打开一个会关掉另一个 */
+export declare class FilterSortPanels {
+    private api;
+    private host;
+    private hooks;
+    private filterFields;
+    private sortFields;
+    private filterRows;
+    private sorts;
+    private filterPanel;
+    private sortPanel;
+    private filterAnchor;
+    private sortAnchor;
+    constructor(api: GridApi, host: HTMLElement, fields: {
+        filter: FilterFieldDef[];
+        sort: SortFieldDef[];
+    }, hooks: {
+        onFilterButton: (active: boolean, count: number) => void;
+        onSortButton: (active: boolean, count: number) => void;
+    });
+    private onDocumentMouseDown;
+    openFilterPanel(anchor: HTMLElement): void;
+    private renderFilterRow;
+    private applyFilter;
+    private closeFilterPanel;
+    openSortPanel(anchor: HTMLElement): void;
+    private applySort;
+    private closeSortPanel;
+    private mount;
+    destroy(): void;
+    closeAll(): void;
+}
+export {};