@rowsncolumns/spreadsheet 10.2.68

package/dist/esm/api/spreadsheet-api.js

@@ -0,0 +1,649 @@
+import { spreadsheetContextAtom } from "../atoms";
+import { DEFAULT_COLUMN_WIDTH, DEFAULT_ROW_HEIGHT } from "../config";
+import { isGridRange } from "../helpers";
+import { multiInstanceAtom } from "../providers/spreadsheet-provider";
+class SpreadsheetCallbacks {
+    callbacks;
+    constructor(props) {
+        this.callbacks = new Proxy({}, {
+            get(_, key) {
+                return props[key];
+            },
+            has(_, key) {
+                return key in props;
+            },
+        });
+    }
+}
+export class SpreadsheetApi extends SpreadsheetCallbacks {
+    store;
+    methods;
+    constructor(props, methods, store, instanceStore, instanceId) {
+        super(props);
+        this.store = store;
+        // Create instance
+        this.createInstance(instanceId, instanceStore);
+        // Add methods
+        this.methods = methods;
+    }
+    createInstance(instanceId, instanceStore) {
+        // Save
+        if (instanceId && instanceStore) {
+            const currentMap = instanceStore?.get(multiInstanceAtom);
+            // Create a new Map with the new instance
+            const newMap = new Map(currentMap);
+            // Add this instance
+            newMap.set(instanceId, this);
+            // Set the new Map back to the atom
+            instanceStore.set(multiInstanceAtom, newMap);
+        }
+    }
+    /**
+     * Dispatch a keyboard event to Spreadsheet container
+     * @param event
+     */
+    dispatchEvent(event) {
+        this.store.get(spreadsheetContextAtom).dispatchEvent?.(event);
+    }
+    /**
+     * Get sheet name from sheet ID
+     * @param sheetId
+     * @returns
+     */
+    getSheetName(sheetId) {
+        return this.callbacks.current?.getSheetName?.(sheetId);
+    }
+    /**
+     * Get sheet ID from sheet ID
+     * @param sheetName
+     * @returns
+     */
+    getSheetId(sheetName) {
+        return this.callbacks.current?.getSheetId?.(sheetName);
+    }
+    scrollToCell(cell, align) {
+        return this.methods?.scrollToCell(cell, align);
+    }
+    /**
+     * Commit the in-progress cell edit, if any. Submits when dirty, cancels when
+     * clean, no-ops when no edit is active. Does not refocus the grid — focus
+     * stays where the user moved it. Useful from a consumer-side outside-click /
+     * blur handler:
+     *
+     * ```tsx
+     * <CanvasGrid onBlur={() => spreadsheet.commit()} />
+     * ```
+     *
+     * Returns true if there was an edit to flush.
+     */
+    commit() {
+        return this.methods?.commit() ?? false;
+    }
+    /**
+     * Change a batch of cells
+     * @param args
+     * @returns
+     */
+    changeBatch(sheetId, range, values, formatting, citations, options) {
+        return this.callbacks.current?.onChangeBatch?.(sheetId, range, values, formatting, citations, options);
+    }
+    /**
+     * Change a batch of cells from a stream
+     * @param args
+     * @returns
+     */
+    changeBatchStream(sheetId, range, stream, options) {
+        return this.callbacks.current?.onChangeBatchStream?.(sheetId, range, stream, options);
+    }
+    /**
+     * Get row count with data
+     * @param sheetId
+     * @returns
+     */
+    getDataRowCount(sheetId) {
+        return this.callbacks.current?.getDataRowCount?.(sheetId);
+    }
+    /**
+     * Get column count with data in a sheet
+     * @param sheetId
+     * @returns
+     */
+    getDataColumnCount(sheetId) {
+        return this.callbacks.current?.getDataColumnCount?.(sheetId);
+    }
+    /**
+     * Set spreadsheet zooming
+     * @param scale
+     * @returns
+     */
+    setScale(scale) {
+        return this.callbacks.current?.onChangeScale?.(scale);
+    }
+    /**
+     * Flash a range of cells
+     * @param range
+     * @param color
+     * @param duration
+     */
+    flash(...args) {
+        this.store.get(spreadsheetContextAtom).flash?.(...args);
+    }
+    /**
+     * Navigate to sheet range
+     * @param range
+     * @param color
+     * @param duration
+     */
+    navigateToSheetRange(...args) {
+        this.store.get(spreadsheetContextAtom).navigateToSheetRange?.(...args);
+    }
+    /**
+     * Mark a range of cells
+     * @param ranges
+     * @param borderColor
+     * @param borderWidth
+     */
+    mark(...args) {
+        this.store.get(spreadsheetContextAtom).mark?.(...args);
+    }
+    /**
+     * UnMark a range of cells
+     */
+    unmark() {
+        this.store.get(spreadsheetContextAtom).unmark?.();
+    }
+    /**
+     * Split text to columns
+     * @param args
+     */
+    splitTextToColumns(...args) {
+        this.store.get(spreadsheetContextAtom).splitTextToColumns?.(...args);
+    }
+    exportRange(range, options) {
+        return this.store
+            .get(spreadsheetContextAtom)
+            .exportRange?.(range, options);
+    }
+    getSheet(sheetId) {
+        return new Sheet(this.callbacks, sheetId);
+    }
+    setActiveSheet(sheetId) {
+        this.callbacks.current?.onChangeActiveSheet?.(sheetId);
+        return this;
+    }
+    getActiveSheet() {
+        const activeSheet = this.callbacks.current?.sheetId;
+        if (activeSheet) {
+            return new Sheet(this.callbacks, activeSheet);
+        }
+    }
+    getActiveSheetId() {
+        return this.callbacks.current?.sheetId;
+    }
+    createNewSheet(sheetSpec) {
+        return this.callbacks.current?.onCreateNewSheet?.(sheetSpec);
+    }
+    updateSheet(sheetId, sheetSpec) {
+        return this.callbacks.current?.onUpdateSheet?.(sheetId, sheetSpec);
+    }
+    // Exposed for assistant tools: delete cells with shift
+    deleteCellsShiftLeft(sheetId, activeCell, selections) {
+        this.callbacks.current?.onDeleteCellsShiftLeft?.(sheetId, activeCell, selections);
+    }
+    deleteCellsShiftUp(sheetId, activeCell, selections) {
+        this.callbacks.current?.onDeleteCellsShiftUp?.(sheetId, activeCell, selections);
+    }
+    // Freeze helpers
+    freezeRow(sheetId, rowIndex) {
+        this.callbacks.current?.onFreezeRow?.(sheetId, rowIndex);
+    }
+    freezeColumn(sheetId, columnIndex) {
+        this.callbacks.current?.onFreezeColumn?.(sheetId, columnIndex);
+    }
+    // Hide helpers (plural alias)
+    hideRows(sheetId, rowIndexes) {
+        this.callbacks.current?.onHideRow?.(sheetId, rowIndexes);
+    }
+    hideColumns(sheetId, columnIndexes) {
+        this.callbacks.current?.onHideColumn?.(sheetId, columnIndexes);
+    }
+    // Table operation methods
+    insertTableRow(tableView, relativeRowIndex, rowData) {
+        return this.callbacks.current?.onInsertTableRow?.(tableView, relativeRowIndex, rowData);
+    }
+    updateTable(sheetId, tableId, updatedTable) {
+        this.callbacks.current?.onUpdateTable?.(sheetId, tableId, updatedTable);
+    }
+    removeTable(tableView) {
+        this.callbacks.current?.onRemoveTable?.(tableView);
+    }
+    insertTableColumn(tableView, relativeColumnIndex, direction) {
+        this.callbacks.current?.onInsertTableColumn?.(tableView, relativeColumnIndex, direction);
+    }
+    deleteTableColumn(tableView, dimensionIndex) {
+        this.callbacks.current?.onDeleteTableColumn?.(tableView, dimensionIndex);
+    }
+    deleteTableRow(tableView, rowIndexes) {
+        this.callbacks.current?.onDeleteTableRow?.(tableView, rowIndexes);
+    }
+    // Sheet operation methods
+    deleteSheet(sheetId) {
+        this.callbacks.current?.onDeleteSheet?.(sheetId);
+    }
+    duplicateSheet(sheetId) {
+        this.callbacks.current?.onDuplicateSheet?.(sheetId);
+    }
+    // Conditional formatting methods
+    createConditionalFormattingRule(rule) {
+        this.callbacks.current?.onCreateConditionalFormattingRule?.(rule);
+    }
+    updateConditionalFormattingRule(updatedRule, previousRule) {
+        this.callbacks.current?.onUpdateConditionalFormattingRule?.(updatedRule, previousRule);
+    }
+    deleteConditionalFormattingRule(rule) {
+        this.callbacks.current?.onDeleteConditionalFormattingRule?.(rule);
+    }
+    // Data validation methods
+    createDataValidationRule(rule) {
+        this.callbacks.current?.onCreateDataValidationRule?.(rule);
+    }
+    updateDataValidationRule(updatedRule, previousRule) {
+        this.callbacks.current?.onUpdateDataValidationRule?.(updatedRule, previousRule);
+    }
+    deleteDataValidationRule(rule) {
+        this.callbacks.current?.onDeleteDataValidationRule?.(rule);
+    }
+    // Formatting/styling methods
+    changeDecimals(sheetId, activeCell, selections, type) {
+        this.callbacks.current?.onChangeDecimals?.(sheetId, activeCell, selections, type);
+    }
+    /**
+     * Read spreadsheet values for agent
+     * @param sheetId
+     * @returns
+     */
+    readSheetData(sheetId, range) {
+        return this.callbacks.current?.getAgentSpreadsheetValues?.(sheetId, range);
+    }
+    changeTheme(theme) {
+        this.callbacks.current?.onChangeTheme?.(theme);
+    }
+    changeBorder(sheetId, activeCell, selections, location, color, style = "solid") {
+        this.callbacks.current?.onChangeBorder?.(sheetId, activeCell, selections, location, color, style);
+    }
+    // Cell/range operation methods
+    cloneCell(sheetId, fromCell, toCell) {
+        this.callbacks.current?.onCloneCell?.(sheetId, fromCell, toCell);
+    }
+    createNamedRange(sheetId, namedRange) {
+        this.callbacks.current?.onCreateNamedRange?.(sheetId, namedRange);
+    }
+    deleteNamedRange(id) {
+        this.callbacks.current?.onDeleteNamedRange?.(id);
+    }
+    deleteCells(sheetId, activeCell, selections) {
+        this.callbacks.current?.onDelete?.(sheetId, activeCell, selections);
+    }
+    // Embed operation methods
+    createEmbed(spec) {
+        this.callbacks.current?.onCreateEmbed?.(spec);
+    }
+    deleteEmbed(embedId) {
+        this.callbacks.current?.onDeleteEmbed?.(embedId);
+    }
+    updateEmbed(embed) {
+        this.callbacks.current?.onUpdateEmbed?.(embed);
+    }
+    moveEmbed(embedId, sheetId, anchorCell, offsetXPixels, offsetYPixels) {
+        this.callbacks.current?.onMoveEmbed?.(embedId, sheetId, anchorCell, offsetXPixels, offsetYPixels);
+    }
+    resizeEmbed(embedId, sheetId, anchorCell, offsetXPixels, offsetYPixels, width, height) {
+        this.callbacks.current?.onResizeEmbed?.(embedId, sheetId, anchorCell, offsetXPixels, offsetYPixels, width, height);
+    }
+    // Programmatic fill (basic mapping to onFillRange)
+    applyFill(sheetId, activeCell, fillSelection, selections) {
+        this.callbacks.current?.onFill?.(sheetId, activeCell, fillSelection, selections);
+    }
+    // Chart helpers
+    isChartsAvailable() {
+        const c = this.callbacks.current;
+        return Boolean(c?.onMoveChart || c?.onResizeChart || c?.onDeleteChart);
+    }
+    createChart(sheetId, activeCell, selections, chartSpec) {
+        // may not be wired in all builds
+        this.callbacks.current?.onCreateChart?.(sheetId, activeCell, selections, chartSpec);
+    }
+    deleteChart(chartId) {
+        this.callbacks.current?.onDeleteChart?.(chartId);
+    }
+    moveChart(chartId, anchorCell, offsetXPixels, offsetYPixels) {
+        this.callbacks.current?.onMoveChart?.(chartId, anchorCell, offsetXPixels, offsetYPixels);
+    }
+    resizeChart(chartId, anchorCell, offsetXPixels, offsetYPixels, width, height) {
+        this.callbacks.current?.onResizeChart?.(chartId, anchorCell, offsetXPixels, offsetYPixels, width, height);
+    }
+    updateChart(chart) {
+        this.callbacks.current?.onUpdateChart?.(chart);
+    }
+    // Insert cells with shift
+    insertCellsShiftDown(sheetId, activeCell, selections) {
+        this.callbacks.current?.onInsertCellsShiftDown?.(sheetId, activeCell, selections);
+    }
+    insertCellsShiftRight(sheetId, activeCell, selections) {
+        this.callbacks.current?.onInsertCellsShiftRight?.(sheetId, activeCell, selections);
+    }
+    // Move rows and columns
+    moveRows(sheetId, rowIndexes, destinationRow) {
+        this.callbacks.current?.onMoveRows?.(sheetId, rowIndexes, destinationRow);
+    }
+    moveColumns(sheetId, columnIndexes, destinationColumn) {
+        this.callbacks.current?.onMoveColumns?.(sheetId, columnIndexes, destinationColumn);
+    }
+    // Formatting methods
+    changeFormatting(sheetId, cell, selections, type, value) {
+        this.callbacks.current?.onChangeFormatting?.(sheetId, cell, selections, type, value);
+    }
+    clearFormatting(sheetId, cell, selections) {
+        this.callbacks.current?.onClearFormatting?.(sheetId, cell, selections);
+    }
+    clearContents(sheetId, activeCell, selections) {
+        this.callbacks.current?.onClearContents?.(sheetId, activeCell, selections);
+    }
+    increaseIndent(sheetId, activeCell, selections) {
+        this.callbacks.current?.onIncreaseIndent?.(sheetId, activeCell, selections);
+    }
+    decreaseIndent(sheetId, activeCell, selections) {
+        this.callbacks.current?.onDecreaseIndent?.(sheetId, activeCell, selections);
+    }
+    // Fill methods
+    fillRange(sheetId, activeCell, selections, direction) {
+        this.callbacks.current?.onFillRange?.(sheetId, activeCell, selections, direction);
+    }
+    // Insert date/time methods
+    insertTime(sheetId, activeCell, selections) {
+        this.callbacks.current?.onInsertTime?.(sheetId, activeCell, selections);
+    }
+    insertDate(sheetId, activeCell, selections) {
+        this.callbacks.current?.onInsertDate?.(sheetId, activeCell, selections);
+    }
+    insertDateTime(sheetId, activeCell, selections) {
+        this.callbacks.current?.onInsertDateTime?.(sheetId, activeCell, selections);
+    }
+    insertAutoSum(sheetId, activeCell) {
+        this.callbacks.current?.onInsertAutoSum?.(sheetId, activeCell);
+    }
+    // Undo/Redo
+    undo() {
+        this.callbacks.current?.onUndo?.();
+    }
+    redo() {
+        this.callbacks.current?.onRedo?.();
+    }
+    // Clipboard operations
+    copy(e, sheetId, copiedSelections) {
+        this.callbacks.current?.onCopy?.(e, sheetId, copiedSelections);
+    }
+    cut(e, sheetId) {
+        this.callbacks.current?.onCut?.(e, sheetId);
+    }
+    paste(e, sourceSheetId, destinationSheetId, copiedSelections, activeCell, selections, finalSelections, shouldDeleteSource) {
+        this.callbacks.current?.onPaste?.(e, sourceSheetId, destinationSheetId, copiedSelections, activeCell, selections, finalSelections, shouldDeleteSource);
+    }
+    // Table operations
+    createTable(sheetId, activeCell, selections, tableSpec, theme, bandedRange) {
+        this.callbacks.current?.onCreateTable?.(sheetId, activeCell, selections, tableSpec, theme, bandedRange);
+    }
+    createBasicFilter(sheetId, activeCell, selections, basicFilterSpec) {
+        this.callbacks.current?.onCreateBasicFilter?.(sheetId, activeCell, selections, basicFilterSpec);
+    }
+    // Protection
+    protectRange(sheetId, cell, selections) {
+        this.callbacks.current?.onProtectRange?.(sheetId, cell, selections);
+    }
+    unprotectRange(sheetId, protectedRangeId) {
+        this.callbacks.current?.onUnProtectRange?.(sheetId, protectedRangeId);
+    }
+    // Request dialogs
+    requestSearch() {
+        this.callbacks.current?.onRequestSearch?.();
+    }
+    requestFormatCells(sheetId, activeCell, selections) {
+        this.callbacks.current?.onRequestFormatCells?.(sheetId, activeCell, selections);
+    }
+    requestConditionalFormat(sheetId, activeCell, selections) {
+        this.callbacks.current?.onRequestConditionalFormat?.(sheetId, activeCell, selections);
+    }
+    requestDataValidation(sheetId, activeCell, selections, initialDataValidationRule, showEditUI) {
+        this.callbacks.current?.onRequestDataValidation?.(sheetId, activeCell, selections, initialDataValidationRule, showEditUI);
+    }
+    requestDefineNamedRange(sheetId, activeCell, selections) {
+        this.callbacks.current?.onRequestDefineNamedRange?.(sheetId, activeCell, selections);
+    }
+    // Change events
+    onChange(sheetId, cell, value, textFormatRuns, previousValue, isDirty) {
+        this.callbacks.current?.onChange?.(sheetId, cell, value, textFormatRuns, previousValue, isDirty);
+    }
+    onDelete(sheetId, cell, selections) {
+        this.callbacks.current?.onDelete?.(sheetId, cell, selections);
+    }
+    changeActiveCell(sheetId, cell) {
+        this.callbacks.current?.onChangeActiveCell?.(sheetId, cell);
+    }
+    changeSelections(sheetId, selections, finishedSelection) {
+        this.callbacks.current?.onChangeSelections?.(sheetId, selections, finishedSelection);
+    }
+    // Resize methods
+    resize(sheetId, indexes, dimension, axis, autoFit) {
+        this.callbacks.current?.onResize?.(sheetId, indexes, dimension, axis, autoFit);
+    }
+    autoResize(sheetId, indexes, axis) {
+        this.callbacks.current?.onAutoResize?.(sheetId, indexes, axis);
+    }
+    // Scale
+    changeScale(scale) {
+        this.callbacks.current?.onChangeScale?.(scale);
+    }
+    // Row/Column operations (direct methods on API)
+    insertRow(sheetId, rowIndex, numRows = 1) {
+        this.callbacks.current?.onInsertRow?.(sheetId, rowIndex, numRows);
+    }
+    insertColumn(sheetId, columnIndex, numColumns = 1) {
+        this.callbacks.current?.onInsertColumn?.(sheetId, columnIndex, numColumns);
+    }
+    deleteRow(sheetId, rowIndexes) {
+        this.callbacks.current?.onDeleteRow?.(sheetId, rowIndexes);
+    }
+    deleteColumn(sheetId, columnIndexes) {
+        this.callbacks.current?.onDeleteColumn?.(sheetId, columnIndexes);
+    }
+    showRow(sheetId, rowIndexes) {
+        this.callbacks.current?.onShowRow?.(sheetId, rowIndexes);
+    }
+    showColumn(sheetId, columnIndexes) {
+        this.callbacks.current?.onShowColumn?.(sheetId, columnIndexes);
+    }
+}
+class Sheet extends SpreadsheetCallbacks {
+    sheetId;
+    constructor(props, sheetId) {
+        super(props);
+        this.sheetId = sheetId;
+    }
+    setSelections(range) {
+        this.callbacks.current?.onChangeSelections?.(this.sheetId, [{ range }]);
+        return this;
+    }
+    setActiveCell(cell) {
+        this.callbacks.current?.onChangeActiveCell?.(this.sheetId, cell);
+        return this;
+    }
+    setRowHeight(rowIndex, dimension) {
+        this.callbacks.current?.onResize?.(this.sheetId, [rowIndex], dimension, "x");
+        return this;
+    }
+    setColumnWidth(columnIndex, dimension) {
+        this.callbacks.current?.onResize?.(this.sheetId, [columnIndex], dimension, "y");
+        return this;
+    }
+    autoSizeColumns(indexes) {
+        this.callbacks.current?.onAutoResize?.(this.sheetId, indexes, "y");
+    }
+    autoSizeRows(indexes) {
+        this.callbacks.current?.onAutoResize?.(this.sheetId, indexes, "x");
+    }
+    resizeColumns(indexes, dimension) {
+        this.callbacks.current?.onResize?.(this.sheetId, indexes, dimension, "y");
+    }
+    resizeRows(indexes, dimension) {
+        this.callbacks.current?.onResize?.(this.sheetId, indexes, dimension, "x");
+    }
+    getColumnWidth(columnIndex) {
+        return (this.callbacks.current?.columnMetadata?.[columnIndex]?.size ??
+            DEFAULT_COLUMN_WIDTH);
+    }
+    getRowHeight(rowIndex) {
+        return (this.callbacks.current?.rowMetadata?.[rowIndex]?.size ??
+            DEFAULT_ROW_HEIGHT);
+    }
+    getActiveCell() {
+        return this.callbacks.current?.activeCell;
+    }
+    getSelections() {
+        return this.callbacks.current?.selections;
+    }
+    getSheetId() {
+        return this.sheetId;
+    }
+    getRange(range) {
+        return new CellRange(this.callbacks, this.sheetId, range);
+    }
+    hideRow(rowIndexes) {
+        this.callbacks.current?.onHideRow?.(this.sheetId, rowIndexes);
+        return this;
+    }
+    hideColumn(columnIndexes) {
+        this.callbacks.current?.onHideColumn?.(this.sheetId, columnIndexes);
+        return this;
+    }
+    showRow(rowIndexes) {
+        this.callbacks.current?.onShowRow?.(this.sheetId, rowIndexes);
+        return this;
+    }
+    showColumn(columnIndexes) {
+        this.callbacks.current?.onShowColumn?.(this.sheetId, columnIndexes);
+        return this;
+    }
+    deleteRow(rowIndexes) {
+        this.callbacks.current?.onDeleteRow?.(this.sheetId, rowIndexes);
+        return this;
+    }
+    deleteColumn(columnIndexes) {
+        this.callbacks.current?.onDeleteColumn?.(this.sheetId, columnIndexes);
+        return this;
+    }
+    insertRow(rowIndex, numRows = 1) {
+        this.callbacks.current?.onInsertRow?.(this.sheetId, rowIndex, numRows);
+        return this;
+    }
+    insertColumn(columnIndex, numColumns = 1) {
+        this.callbacks.current?.onInsertColumn?.(this.sheetId, columnIndex, numColumns);
+        return this;
+    }
+    moveRows(rowIndexes, destinationRow) {
+        this.callbacks.current?.onMoveRows?.(this.sheetId, rowIndexes, destinationRow);
+        return this;
+    }
+    moveColumns(columnIndexes, destinationColumn) {
+        this.callbacks.current?.onMoveColumns?.(this.sheetId, columnIndexes, destinationColumn);
+        return this;
+    }
+    onRequestSearch() {
+        this.callbacks.current?.onRequestSearch?.();
+        return this;
+    }
+    sortRange(selections, sortOrder, specs) {
+        this.callbacks.current?.onSortRange?.(this.sheetId, selections, sortOrder, specs);
+        return this;
+    }
+    sortColumn(columnIndex, sortOrder, options, additionalLevels) {
+        this.callbacks.current?.onSortColumn?.(this.sheetId, columnIndex, sortOrder, options, additionalLevels);
+        return this;
+    }
+}
+class CellRange extends SpreadsheetCallbacks {
+    sheetId;
+    range;
+    constructor(props, sheetId, range) {
+        super(props);
+        this.sheetId = sheetId;
+        this.range = range;
+    }
+    getCellFromRange() {
+        return isGridRange(this.range)
+            ? {
+                rowIndex: this.range.startRowIndex,
+                columnIndex: this.range.startColumnIndex,
+            }
+            : this.range;
+    }
+    setValue(value, textFormatRuns) {
+        this.callbacks.current?.onChange?.(this.sheetId, this.getCellFromRange(), value, textFormatRuns);
+        return this;
+    }
+    /**
+     * Get effective value of a cell
+     * @returns
+     */
+    getEffectiveValue() {
+        const cell = this.getCellFromRange();
+        if (isGridRange(this.range)) {
+            const effectiveValues = [];
+            for (let rowIndex = this.range.startRowIndex; rowIndex <= this.range.endRowIndex; rowIndex++) {
+                const rowValues = [];
+                for (let columnIndex = this.range.startColumnIndex; columnIndex <= this.range.endColumnIndex; columnIndex++) {
+                    rowValues.push(this.callbacks.current?.getEffectiveValue?.(this.sheetId, rowIndex, columnIndex));
+                }
+                effectiveValues.push(rowValues);
+            }
+            return effectiveValues;
+        }
+        else {
+            return this.callbacks.current?.getEffectiveValue?.(this.sheetId, this.range.rowIndex, this.range.columnIndex);
+        }
+    }
+    setValues(values) {
+        if (isGridRange(this.range)) {
+            this.callbacks.current?.onChangeBatch?.(this.sheetId, this.range, values);
+        }
+        else {
+            this.setValue(values?.[0]?.[0]);
+        }
+        return this;
+    }
+    clearFormatting() {
+        this.callbacks.current?.onClearFormatting?.(this.sheetId, this.getCellFromRange(), isGridRange(this.range) ? [{ range: this.range }] : []);
+        return this;
+    }
+    setFormat(type, value) {
+        const selections = isGridRange(this.range) ? [{ range: this.range }] : [];
+        this.callbacks.current?.onChangeFormatting?.(this.sheetId, this.getCellFromRange(), selections, type, value);
+        return this;
+    }
+    increaseIndent() {
+        const selections = isGridRange(this.range) ? [{ range: this.range }] : [];
+        this.callbacks.current?.onIncreaseIndent?.(this.sheetId, this.getCellFromRange(), selections);
+        return this;
+    }
+    decreaseIndent() {
+        const selections = isGridRange(this.range) ? [{ range: this.range }] : [];
+        this.callbacks.current?.onDecreaseIndent?.(this.sheetId, this.getCellFromRange(), selections);
+        return this;
+    }
+    setNote(notes) {
+        this.callbacks.current?.onUpdateNote?.(this.sheetId, this.getCellFromRange(), notes);
+    }
+    delete() {
+        this.callbacks.current?.onDelete?.(this.sheetId, this.getCellFromRange(), isGridRange(this.range) ? [{ range: this.range }] : []);
+        return this;
+    }
+}

package/dist/esm/api/table.d.ts

@@ -0,0 +1,11 @@
+import type { CellInterface } from "@rowsncolumns/grid";
+import type { TableView } from "../types";
+/**
+ * Find table withing a cell
+ * @param sheetId
+ * @param cell
+ * @param tables
+ * @returns
+ */
+export declare const findActiveTableWithinCell: (sheetId: number, cell: CellInterface, tables: TableView[] | undefined | null) => TableView | undefined;
+//# sourceMappingURL=table.d.ts.map

package/dist/esm/api/table.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"table.d.ts","sourceRoot":"","sources":["../../../api/table.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAGxD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAE1C;;;;;;GAMG;AACH,eAAO,MAAM,yBAAyB,GACpC,SAAS,MAAM,EACf,MAAM,aAAa,EACnB,QAAQ,SAAS,EAAE,GAAG,SAAS,GAAG,IAAI,0BAMvC,CAAC"}

package/dist/esm/api/table.js

@@ -0,0 +1,11 @@
+import { isCellWithinBounds } from "@rowsncolumns/grid";
+/**
+ * Find table withing a cell
+ * @param sheetId
+ * @param cell
+ * @param tables
+ * @returns
+ */
+export const findActiveTableWithinCell = (sheetId, cell, tables) => {
+    return tables?.find((table) => table.sheetId === sheetId && isCellWithinBounds(cell, table.range));
+};