@rowsncolumns/spreadsheet 10.2.68

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

@@ -0,0 +1,111 @@
+import type { CellInterface, GridRange, SelectionArea } from "@rowsncolumns/grid";
+import type { CanvasGridProps, GetSelectionFromNamedRange, SelectionAttributes } from "../components/canvas-grid/typings";
+import type { useOnStructuredReferenceSelection } from "../hooks/use-structured-reference-selection";
+import type { SheetRange, TableView } from "../types";
+/**
+ * Get stroke style
+ * @param fill
+ * @param isActiveCell
+ * @param isSelection
+ */
+export declare const getSelectionStrokeStyle: (formulaMode: boolean, isFill: boolean, isActiveCell: boolean, emptySelections: boolean) => "dashed" | "solid";
+/**
+ * Get selection stroke width
+ * @param formulaMode
+ * @param isFill
+ * @param isActiveCell
+ * @returns
+ */
+export declare const getSelectionStrokeWidth: (formulaMode: boolean, isFill: boolean, isActiveCell: boolean, isResizingTable: boolean) => 2 | 1;
+/**
+ * Get background opacity of selection
+ * @param formulaMode
+ * @param isFill
+ * @returns
+ */
+export declare const getSelectionFillOpacity: (formulaMode: boolean, isFill: boolean) => 1 | 0 | 0.2;
+/**
+ * Get background color of selection
+ * @param formulaMode
+ * @param isFill
+ * @param isActiveCell
+ * @param selectionColor
+ * @param key
+ * @returns
+ */
+export declare const getSelectionFill: (formulaMode: boolean, isFill: boolean, isActiveCell: boolean, selectionColor: string, index: number | string, isActiveIndex: boolean, isResizingTable: boolean) => string;
+/**
+ * Get border color of selection
+ * @param formulaMode
+ * @param isFill
+ * @param isActiveCell
+ * @param isEmptySelections
+ * @param inProgress
+ * @param selectionBackgroundColor
+ * @param selectionBorderColor
+ * @param key
+ * @returns
+ */
+export declare const getSelectionStroke: (formulaMode: boolean, isFill: boolean, isActiveCell: boolean, isEmptySelections: boolean, inProgress: boolean | undefined, selectionBorderColor: string, key: number | string) => string;
+/**
+ * Generate selections from string
+ * @param value
+ * @param currentSheetName
+ * @returns
+ */
+export declare const generateSelectionsFromFormula: (value: string, sheetId?: number, currentSheetName?: string, activeCell?: CellInterface, rowCount?: number, columnCount?: number, tokenizer?: CanvasGridProps["tokenizer"], getSelectionFromTable?: ReturnType<typeof useOnStructuredReferenceSelection>, getSelectionFromNamedRange?: GetSelectionFromNamedRange) => SelectionArea<SelectionAttributes>[];
+export declare const isSelection: (sel: unknown) => sel is SelectionArea<SelectionAttributes>;
+/**
+ * Selection range to r x c
+ * @param selection
+ */
+export declare const selectionToRxC: (selection: SelectionArea) => string;
+/**
+ * Convert cell address to selection
+ * @param address
+ * @returns
+ */
+export declare const addressToSelection: (address: string, rowCount?: number, columnCount?: number) => SelectionArea | undefined;
+/**
+ * Is selection a cell
+ * @param param0
+ * @returns
+ */
+export declare const isSelectionACell: (selections: SelectionArea[]) => boolean;
+export declare const isSheetRangeACell: (range: SheetRange | GridRange) => boolean;
+/**
+ * Get top left cell in a selection
+ * @param selection
+ * @returns
+ */
+export declare const getFirstCellInSelection: (selection: SelectionArea) => CellInterface;
+export declare const selectionToTableAddress: (selection: SelectionArea, table: TableView, editingCell: CellInterface | undefined) => string;
+/**
+ * Get table from current selection,
+ * @param tables
+ * @param editingCell
+ * @param selection
+ */
+export declare const getTableFromSelection: (tables: TableView[] | undefined, editingCell: CellInterface | undefined, selection: SelectionArea<SelectionAttributes> | undefined, sheetName: string | undefined, getSheetName?: (sheetId: number) => string) => TableView | undefined;
+/**
+ * Get column index from table column name
+ * @param table
+ * @param columnName
+ * @returns
+ */
+export declare const getColumnIndexFromColumnName: (table: TableView, columnName: string | undefined) => number | undefined;
+/**
+ * Get first active cell in selection
+ * @param selection
+ * @returns
+ */
+export declare const getFirstActiveCellInSelection: (selection: SelectionArea | undefined) => CellInterface | undefined;
+/**
+ * Get final selectables
+ * @param activeCell
+ * @param selections
+ * @returns
+ */
+export declare const getUserSelections: (activeCell: CellInterface | undefined, selections?: SelectionArea<SelectionAttributes>[]) => SelectionArea<SelectionAttributes>[];
+export declare const sheetRangeToAddress: (sheetRange: SheetRange, sheetName?: string) => string | null;
+//# sourceMappingURL=selections.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"selections.d.ts","sourceRoot":"","sources":["../../../api/selections.ts"],"names":[],"mappings":"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"}

package/dist/esm/api/selections.js

@@ -0,0 +1,365 @@
+import { tokenize as defaultFormulaTokenizer } from "@rowsncolumns/calculator";
+import { areaInsideArea, isCellWithinBounds, selectionFromActiveCell, } from "@rowsncolumns/grid";
+import { addressToCell, cellToAddress, desanitizeSheetName, getSelectionColorAtIndex, isNil, isNumber, selectionBoundsFromCells, } from "@rowsncolumns/utils";
+import { MAX_COLUMN_COUNT, MAX_ROW_COUNT } from "../config";
+/**
+ * Get stroke style
+ * @param fill
+ * @param isActiveCell
+ * @param isSelection
+ */
+export const getSelectionStrokeStyle = (formulaMode, isFill, isActiveCell, emptySelections) => {
+    if (isFill) {
+        return "dashed";
+    }
+    if (formulaMode) {
+        if (isActiveCell && emptySelections) {
+            return "solid";
+        }
+        return "dashed";
+    }
+    return "solid";
+};
+/**
+ * Get selection stroke width
+ * @param formulaMode
+ * @param isFill
+ * @param isActiveCell
+ * @returns
+ */
+export const getSelectionStrokeWidth = (formulaMode, isFill, isActiveCell, isResizingTable) => {
+    if (isFill) {
+        return 1;
+    }
+    if (formulaMode || isActiveCell || isResizingTable) {
+        return 2;
+    }
+    return 1;
+};
+/**
+ * Get background opacity of selection
+ * @param formulaMode
+ * @param isFill
+ * @returns
+ */
+export const getSelectionFillOpacity = (formulaMode, isFill) => {
+    if (isFill)
+        return 0;
+    if (formulaMode)
+        return 0.2;
+    return 1;
+};
+/**
+ * Get background color of selection
+ * @param formulaMode
+ * @param isFill
+ * @param isActiveCell
+ * @param selectionColor
+ * @param key
+ * @returns
+ */
+export const getSelectionFill = (formulaMode, isFill, isActiveCell, selectionColor, index, isActiveIndex, isResizingTable) => {
+    if (isFill || isActiveCell || isResizingTable) {
+        return "transparent";
+    }
+    if (formulaMode && isNumber(index)) {
+        if (isActiveIndex) {
+            return getSelectionColorAtIndex(index);
+        }
+        return "transparent";
+    }
+    return selectionColor;
+};
+/**
+ * Get border color of selection
+ * @param formulaMode
+ * @param isFill
+ * @param isActiveCell
+ * @param isEmptySelections
+ * @param inProgress
+ * @param selectionBackgroundColor
+ * @param selectionBorderColor
+ * @param key
+ * @returns
+ */
+export const getSelectionStroke = (formulaMode, isFill, isActiveCell, isEmptySelections, inProgress, selectionBorderColor, key) => {
+    if (isFill) {
+        return "gray";
+    }
+    if (formulaMode && isNumber(key)) {
+        if (isActiveCell) {
+            if (isEmptySelections) {
+                return selectionBorderColor;
+            }
+            return "transparent";
+        }
+        return getSelectionColorAtIndex(key);
+    }
+    if (inProgress) {
+        return "transparent";
+    }
+    return selectionBorderColor;
+};
+/**
+ * Generate selections from string
+ * @param value
+ * @param currentSheetName
+ * @returns
+ */
+export const generateSelectionsFromFormula = (value, sheetId, currentSheetName, activeCell, rowCount = MAX_ROW_COUNT, columnCount = MAX_COLUMN_COUNT, tokenizer = defaultFormulaTokenizer, getSelectionFromTable, getSelectionFromNamedRange) => {
+    const selectionAreas = [];
+    const tokens = tokenizer?.(value, currentSheetName) ?? [];
+    for (const token of tokens) {
+        if (token.structured && getSelectionFromTable && !isNil(sheetId)) {
+            const structuredSelection = getSelectionFromTable(sheetId, activeCell, token.tableName, token.columnNames, token.thisRow, token.specialItem);
+            if (structuredSelection) {
+                selectionAreas.push(structuredSelection);
+            }
+        }
+        if (token.isNamedRange && getSelectionFromNamedRange && !isNil(sheetId)) {
+            const namedRangeSelection = getSelectionFromNamedRange(token.image);
+            if (namedRangeSelection && isSelection(namedRangeSelection)) {
+                selectionAreas.push(namedRangeSelection);
+            }
+        }
+        // For cell selections, column range and row range
+        if (token.selection) {
+            const address = token.image.slice(token.image.indexOf("!") + 1);
+            const selectionRange = addressToSelection(address, rowCount, columnCount);
+            if (selectionRange) {
+                selectionAreas.push({
+                    ...selectionRange,
+                    sheetName: desanitizeSheetName(token.sheetName ?? currentSheetName),
+                });
+            }
+        }
+    }
+    return selectionAreas;
+};
+export const isSelection = (sel) => {
+    if (sel?.range) {
+        return true;
+    }
+    return false;
+};
+/**
+ * Selection range to r x c
+ * @param selection
+ */
+export const selectionToRxC = (selection) => {
+    const numRows = selection.range.endRowIndex - selection.range.startRowIndex + 1;
+    const numCols = selection.range.endColumnIndex - selection.range.startColumnIndex + 1;
+    return `${numRows}R x ${numCols}C`;
+};
+/**
+ * Convert cell address to selection
+ * @param address
+ * @returns
+ */
+export const addressToSelection = (address, rowCount = MAX_ROW_COUNT, columnCount = MAX_COLUMN_COUNT) => {
+    // eslint-disable-next-line prefer-const
+    let [from, to] = address.split(":");
+    if (!from) {
+        return undefined;
+    }
+    if (!to) {
+        to = from;
+    }
+    const fromCell = addressToCell(from, {
+        position: "start",
+        rowCount,
+        columnCount,
+    });
+    const toCell = addressToCell(to, {
+        position: "end",
+        rowCount,
+        columnCount,
+    });
+    if (!fromCell || !toCell) {
+        return undefined;
+    }
+    if (fromCell.rowIndex > toCell.rowIndex ||
+        fromCell.columnIndex > toCell.columnIndex) {
+        return undefined;
+    }
+    return {
+        range: selectionBoundsFromCells(fromCell, toCell),
+    };
+};
+/**
+ * Is selection a cell
+ * @param param0
+ * @returns
+ */
+export const isSelectionACell = (selections) => {
+    return selections.every(({ range }) => {
+        return (range.startRowIndex === range.endRowIndex &&
+            range.startColumnIndex === range.endColumnIndex);
+    });
+};
+export const isSheetRangeACell = (range) => {
+    return (range.startRowIndex === range.endRowIndex &&
+        range.startColumnIndex === range.endColumnIndex);
+};
+/**
+ * Get top left cell in a selection
+ * @param selection
+ * @returns
+ */
+export const getFirstCellInSelection = (selection) => {
+    return {
+        rowIndex: selection.range.startRowIndex,
+        columnIndex: selection.range.startColumnIndex,
+    };
+};
+export const selectionToTableAddress = (selection, table, editingCell) => {
+    const { startColumnIndex, endColumnIndex, startRowIndex, endRowIndex } = selection.range;
+    const { title } = table;
+    const headerRow = table.headerRow ?? true;
+    const totalRow = table.totalRow ?? false;
+    const { startColumnIndex: tableStartColumnIndex, endColumnIndex: tableEndColumnIndex, startRowIndex: tableStartRowIndex, endRowIndex: tableEndRowIndex, } = table.range;
+    const tableDataStartRowIndex = headerRow
+        ? tableStartRowIndex + 1
+        : tableStartRowIndex;
+    const tableDataEndRowIndex = totalRow
+        ? tableEndRowIndex - 1
+        : tableEndRowIndex;
+    const firstColumn = table.columns?.[startColumnIndex - tableStartColumnIndex]?.name;
+    const lastColumn = table.columns?.[endColumnIndex - tableStartColumnIndex]?.name;
+    // Only heder
+    const isHeader = headerRow &&
+        startRowIndex === tableStartRowIndex &&
+        endRowIndex === tableStartRowIndex;
+    // Full table
+    const isAll = tableStartRowIndex === startRowIndex &&
+        tableEndRowIndex === endRowIndex &&
+        tableStartColumnIndex === startColumnIndex &&
+        tableEndColumnIndex === endColumnIndex;
+    // Full row range
+    const isFullRowRange = tableStartColumnIndex === startColumnIndex &&
+        tableEndColumnIndex === endColumnIndex;
+    // Full column rnge
+    const isDataColumnRange = tableDataStartRowIndex === startRowIndex &&
+        tableDataEndRowIndex === endRowIndex;
+    // Full data range
+    const isCompleteDataRange = isDataColumnRange && isFullRowRange;
+    // Full column rnge
+    const isFullColumnRange = tableStartRowIndex === startRowIndex && tableEndRowIndex === endRowIndex;
+    const range = isFullRowRange
+        ? ""
+        : firstColumn === lastColumn
+            ? firstColumn // Full column rnge
+            : `[${firstColumn}]:[${lastColumn}]`;
+    const isEditingCellInsideTable = editingCell
+        ? isCellWithinBounds(editingCell, table.range)
+        : false;
+    const tableName = title;
+    if (isAll) {
+        return `${tableName}[#All]`;
+    }
+    if (isCompleteDataRange) {
+        return `${tableName}[#Data]`;
+    }
+    if (isDataColumnRange) {
+        return `${tableName}[${range}]`;
+    }
+    if (isFullColumnRange) {
+        return `${tableName}[[#All],[${range}]]`;
+    }
+    if (isHeader) {
+        return `${tableName}[[#Headers]${range ? "," + range : ""}]`;
+    }
+    return `${isEditingCellInsideTable ? "" : tableName}[@${range}]`;
+};
+/**
+ * Get table from current selection,
+ * @param tables
+ * @param editingCell
+ * @param selection
+ */
+export const getTableFromSelection = (tables, editingCell, selection, sheetName, getSheetName) => {
+    if (!tables || !selection) {
+        return undefined;
+    }
+    const table = tables.find((table) => getSheetName?.(table.sheetId) === sheetName &&
+        areaInsideArea(selection.range, table.range));
+    const isTableHeader = table?.range.startRowIndex === selection.range.startRowIndex &&
+        table?.range.startRowIndex === selection.range.endRowIndex;
+    if (isTableHeader) {
+        return table;
+    }
+    const headerRow = table?.headerRow ?? true;
+    const totalRow = table?.totalRow ?? false;
+    const tableDataStartRowIndex = (table?.range.startRowIndex ?? 0) + (headerRow ? 1 : 0);
+    const tableDataEndRowIndex = (table?.range.endRowIndex ?? 0) - (totalRow ? 1 : 0);
+    // Full column rnge
+    const isFullColumnRange = table?.range.startRowIndex === selection.range.startRowIndex &&
+        table.range.endRowIndex === selection.range.endRowIndex;
+    // Full column rnge
+    const isDataColumnRange = tableDataStartRowIndex === selection.range.startRowIndex &&
+        tableDataEndRowIndex === selection.range.endRowIndex;
+    const isAll = table?.range.startRowIndex === selection.range.startRowIndex &&
+        table?.range.endRowIndex === selection.range.endRowIndex;
+    if (isAll || isDataColumnRange || isFullColumnRange) {
+        return table;
+    }
+    if (selection.range.startRowIndex && !isNil(editingCell))
+        if (selection.range.startRowIndex !== editingCell.rowIndex ||
+            selection.range.endRowIndex !== editingCell.rowIndex) {
+            // The table cell has to be  in the same row as editing cell
+            return undefined;
+        }
+    return table;
+};
+/**
+ * Get column index from table column name
+ * @param table
+ * @param columnName
+ * @returns
+ */
+export const getColumnIndexFromColumnName = (table, columnName) => {
+    const fromIndex = table.columns?.findIndex((col) => col.name === columnName);
+    if (isNil(fromIndex) || fromIndex === -1) {
+        return undefined;
+    }
+    return table.range.startColumnIndex + fromIndex;
+};
+/**
+ * Get first active cell in selection
+ * @param selection
+ * @returns
+ */
+export const getFirstActiveCellInSelection = (selection) => {
+    if (!selection) {
+        return undefined;
+    }
+    return {
+        rowIndex: selection.range.startRowIndex,
+        columnIndex: selection.range.startColumnIndex,
+    };
+};
+/**
+ * Get final selectables
+ * @param activeCell
+ * @param selections
+ * @returns
+ */
+export const getUserSelections = (activeCell, selections) => {
+    return selections?.length
+        ? selections
+        : activeCell
+            ? selectionFromActiveCell(activeCell)
+            : [];
+};
+export const sheetRangeToAddress = (sheetRange, sheetName) => {
+    const tl = cellToAddress({
+        rowIndex: sheetRange.startRowIndex,
+        columnIndex: sheetRange.startColumnIndex,
+    });
+    const br = cellToAddress({
+        rowIndex: sheetRange.endRowIndex,
+        columnIndex: sheetRange.endColumnIndex,
+    });
+    const address = tl === br ? tl : `${tl}:${br}`;
+    return sheetName ? `${sheetName}!${address}` : address;
+};