@leankylin-sheet/core 1.2.0 → 1.2.1

package/dist/api/cell.d.ts

@@ -0,0 +1,10 @@
+import { Context } from "../context";
+import { Cell, SingleRange } from "../types";
+import { CommonOptions } from "./common";
+export declare function getCellValue(ctx: Context, row: number, column: number, options?: CommonOptions & {
+    type?: keyof Cell;
+}): any;
+export declare function setCellValue(ctx: Context, row: number, column: number, value: any, cellInput: HTMLDivElement | null, options?: CommonOptions): void;
+export declare function clearCell(ctx: Context, row: number, column: number, options?: CommonOptions): void;
+export declare function setCellFormat(ctx: Context, row: number, column: number, attr: keyof Cell, value: any, options?: CommonOptions): void;
+export declare function autoFillCell(ctx: Context, copyRange: SingleRange, applyRange: SingleRange, direction: "up" | "down" | "left" | "right"): void;

package/dist/api/common.d.ts

@@ -0,0 +1,57 @@
+import { Context } from "../context";
+import { CellMatrix, CellWithRowAndCol, Sheet } from "../types";
+export type CommonOptions = {
+    index?: number;
+    id?: string;
+};
+export declare const dataToCelldata: (data: CellMatrix | undefined) => CellWithRowAndCol[];
+export declare const celldataToData: (celldata: CellWithRowAndCol[], rowCount?: number, colCount?: number) => CellMatrix | null;
+export declare function getSheet(ctx: Context, options?: CommonOptions): Sheet;
+export declare function getSheetWithLatestCelldata(ctx: Context, options?: CommonOptions): {
+    celldata: CellWithRowAndCol[];
+    name: string;
+    config?: import("../types").SheetConfig | undefined;
+    order?: number | undefined;
+    color?: string | undefined;
+    data?: CellMatrix | undefined;
+    id?: string | undefined;
+    images?: import("../types").Image[] | undefined;
+    zoomRatio?: number | undefined;
+    column?: number | undefined;
+    row?: number | undefined;
+    addRows?: number | undefined;
+    status?: number | undefined;
+    hide?: number | undefined;
+    luckysheet_select_save?: import("../types").Selection[] | undefined;
+    luckysheet_selection_range?: {
+        row: number[];
+        column: number[];
+    }[] | undefined;
+    calcChain?: any[] | undefined;
+    defaultRowHeight?: number | undefined;
+    defaultColWidth?: number | undefined;
+    showGridLines?: number | boolean | undefined;
+    pivotTable?: any;
+    isPivotTable?: boolean | undefined;
+    filter?: Record<string, any> | undefined;
+    filter_select?: {
+        row: number[];
+        column: number[];
+    } | undefined;
+    luckysheet_conditionformat_save?: any[] | undefined;
+    luckysheet_alternateformat_save?: any[] | undefined;
+    dataVerification?: any;
+    hyperlink?: Record<string, {
+        linkType: string;
+        linkAddress: string;
+    }> | undefined;
+    dynamicArray_compute?: any;
+    dynamicArray?: any[] | undefined;
+    frozen?: {
+        type: "row" | "column" | "both" | "rangeRow" | "rangeColumn" | "rangeBoth";
+        range?: {
+            row_focus: number;
+            column_focus: number;
+        } | undefined;
+    } | undefined;
+};

package/dist/api/errors.d.ts

@@ -0,0 +1,2 @@
+export declare const INVALID_PARAMS: Error;
+export declare const SHEET_NOT_FOUND: Error;

package/dist/api/index.d.ts

@@ -0,0 +1,9 @@
+import { getSheetWithLatestCelldata, CommonOptions, dataToCelldata, celldataToData } from "./common";
+export type { CommonOptions };
+export { getSheetWithLatestCelldata, dataToCelldata, celldataToData };
+export * from "./cell";
+export * from "./rowcol";
+export * from "./range";
+export * from "./merge";
+export * from "./sheet";
+export * from "./workbook";

package/dist/api/merge.d.ts

@@ -0,0 +1,5 @@
+import { Context } from "..";
+import { Range } from "../types";
+import { CommonOptions } from "./common";
+export declare function mergeCells(ctx: Context, ranges: Range, type: string, options?: CommonOptions): void;
+export declare function cancelMerge(ctx: Context, ranges: Range, options?: CommonOptions): void;

package/dist/api/range.d.ts

@@ -0,0 +1,22 @@
+import { Selection } from "..";
+import { Context } from "../context";
+import { Cell, Range, SingleRange } from "../types";
+import { CommonOptions } from "./common";
+export declare function getSelection(ctx: Context): {
+    row: number[];
+    column: number[];
+}[] | undefined;
+export declare function getFlattenRange(ctx: Context, range?: Range): {
+    r: number;
+    c: number;
+}[];
+export declare function getCellsByFlattenRange(ctx: Context, range?: {
+    r: number;
+    c: number;
+}[]): (Cell | null)[];
+export declare function getSelectionCoordinates(ctx: Context): string[];
+export declare function getCellsByRange(ctx: Context, range: Selection, options?: CommonOptions): (Cell | null)[][];
+export declare function getHtmlByRange(ctx: Context, range: Range, options?: CommonOptions): string | null;
+export declare function setSelection(ctx: Context, range: Range, options: CommonOptions): void;
+export declare function setCellValuesByRange(ctx: Context, data: any[][], range: SingleRange, cellInput: HTMLDivElement | null, options?: CommonOptions): void;
+export declare function setCellFormatByRange(ctx: Context, attr: keyof Cell, value: any, range: Range | SingleRange, options?: CommonOptions): void;

package/dist/api/rowcol.d.ts

@@ -0,0 +1,12 @@
+import { Context } from "../context";
+import { CommonOptions } from "./common";
+export declare function freeze(ctx: Context, type: "row" | "column" | "both", range: {
+    row: number;
+    column: number;
+}, options?: CommonOptions): void;
+export declare function insertRowOrColumn(ctx: Context, type: "row" | "column", index: number, count: number, direction: "lefttop" | "rightbottom", options?: CommonOptions): void;
+export declare function deleteRowOrColumn(ctx: Context, type: "row" | "column", start: number, end: number, options?: CommonOptions): void;
+export declare function setRowHeight(ctx: Context, rowInfo: Record<string, number>, options?: CommonOptions, custom?: boolean): void;
+export declare function setColumnWidth(ctx: Context, columnInfo: Record<string, number>, options?: CommonOptions, custom?: boolean): void;
+export declare function getRowHeight(ctx: Context, rows: number[], options?: CommonOptions): Record<number, number>;
+export declare function getColumnWidth(ctx: Context, columns: number[], options?: CommonOptions): Record<number, number>;

package/dist/api/sheet.d.ts

@@ -0,0 +1,10 @@
+import { getSheet } from "./common";
+import { Context } from "../context";
+import { CellMatrix, Sheet } from "../types";
+export declare function getAllSheets(ctx: Context): Sheet[];
+export { getSheet };
+export declare function initSheetData(draftCtx: Context, index: number, newData: Sheet): CellMatrix | null;
+export declare function hideSheet(ctx: Context, sheetId: string): void;
+export declare function showSheet(ctx: Context, sheetId: string): void;
+export declare function copySheet(ctx: Context, sheetId: string): void;
+export declare function calculateSheetFromula(ctx: Context, id: string): void;

package/dist/api/workbook.d.ts

@@ -0,0 +1,15 @@
+import { Context, Sheet } from "..";
+import { Settings } from "../settings";
+import { CommonOptions } from "./common";
+export declare function addSheet(ctx: Context, settings?: Required<Settings>, newSheetID?: string, isPivotTable?: boolean, sheetname?: string | undefined, sheetData?: Sheet | undefined): void;
+export declare function deleteSheet(ctx: Context, options?: CommonOptions): void;
+export declare function updateSheet(ctx: Context, data: Sheet[]): void;
+export declare function activateSheet(ctx: Context, options?: CommonOptions): void;
+export declare function setSheetName(ctx: Context, name: string, options?: CommonOptions): void;
+export declare function setSheetOrder(ctx: Context, orderList: Record<string, number>): void;
+export declare function scroll(ctx: Context, scrollbarX: HTMLDivElement | null, scrollbarY: HTMLDivElement | null, options: {
+    scrollLeft?: number;
+    scrollTop?: number;
+    targetRow?: number;
+    targetColumn?: number;
+}): void;

package/dist/canvas.d.ts

@@ -0,0 +1,46 @@
+import { defaultContext } from "./context";
+export declare const defaultStyle: {
+    fillStyle: string;
+    textBaseline: string;
+    strokeStyle: string;
+    rowFillStyle: string;
+    textAlign: string;
+};
+export declare class Canvas {
+    canvasElement: HTMLCanvasElement;
+    sheetCtx: ReturnType<typeof defaultContext>;
+    measureTextCacheTimeOut: any;
+    cellOverflowMapCache: any;
+    constructor(canvasElement: HTMLCanvasElement, ctx: ReturnType<typeof defaultContext>);
+    drawRowHeader(scrollHeight: number, drawHeight?: number, offsetTop?: number): void;
+    drawColumnHeader(scrollWidth: number, drawWidth?: number, offsetLeft?: number): void;
+    drawMain({ scrollWidth, scrollHeight, drawWidth, drawHeight, offsetLeft, offsetTop, columnOffsetCell, rowOffsetCell, clear, }: {
+        scrollWidth: number;
+        scrollHeight: number;
+        drawWidth?: number;
+        drawHeight?: number;
+        offsetLeft?: number;
+        offsetTop?: number;
+        columnOffsetCell?: number;
+        rowOffsetCell?: number;
+        clear?: boolean;
+    }): void;
+    getCellOverflowMap(canvas: CanvasRenderingContext2D, colStart: number, colEnd: number, rowStart: number, rowEnd: number): any;
+    nullCellRender(r: number, c: number, startY: number, startX: number, endY: number, endX: number, renderCtx: CanvasRenderingContext2D, afCompute: any, cfCompute: any, offsetLeft: number, offsetTop: number, dynamicArrayCompute: any, cellOverflowMap: any, colStart: number, colEnd: number, scrollHeight: number, scrollWidth: number, bodrder05: any, isMerge?: boolean): void;
+    cellRender(r: number, c: number, startY: number, startX: number, endY: number, endX: number, value: any, renderCtx: CanvasRenderingContext2D, afCompute: any, cfCompute: any, offsetLeft: number, offsetTop: number, dynamicArrayCompute: any, cellOverflowMap: any, colStart: number, colEnd: number, scrollHeight: number, scrollWidth: number, bodrder05: number, isMerge?: boolean): void;
+    cellOverflowRender(r: number, c: number, stc: number, edc: number, renderCtx: CanvasRenderingContext2D, scrollHeight: number, scrollWidth: number, offsetLeft: number, offsetTop: number, afCompute: any, cfCompute: any): void;
+    cellOverflow_trace(r: number, curC: number, traceC: number, traceDir: string, horizonAlign: string, textMetrics: number): any;
+    cellOverflow_colIn(map: any, r: number, c: number, col_st: number, col_ed: number): {
+        colIn: boolean;
+        colLast: boolean;
+        rowIndex: number | undefined;
+        colIndex: number | undefined;
+        stc: number | undefined;
+        edc: number | undefined;
+    };
+    cellTextRender(textInfo: any, ctx: CanvasRenderingContext2D, option: any): void;
+    drawFreezeLine({ horizontalTop, verticalLeft, }: {
+        horizontalTop?: number;
+        verticalLeft?: number;
+    }): void;
+}

package/dist/context.d.ts

@@ -0,0 +1,178 @@
+import { SheetConfig } from ".";
+import { FormulaCache } from "./modules";
+import { Hooks } from "./settings";
+import { Sheet, Selection, Cell, CommentBox, Rect, Image, Presence, LinkCardProps, FilterOptions, RangeDialogProps, DataRegulationProps, ConditionRulesProps, GlobalCache } from "./types";
+interface MutableRefObject<T> {
+    current: T;
+}
+type RefValues = {
+    globalCache: GlobalCache;
+    cellInput: MutableRefObject<HTMLDivElement | null>;
+    fxInput: MutableRefObject<HTMLDivElement | null>;
+    canvas: MutableRefObject<HTMLCanvasElement | null>;
+    cellArea: MutableRefObject<HTMLDivElement | null>;
+    workbookContainer: MutableRefObject<HTMLDivElement | null>;
+};
+export type Context = {
+    luckysheetfile: Sheet[];
+    defaultcolumnNum: number;
+    defaultrowNum: number;
+    addDefaultRows: number;
+    fullscreenmode: boolean;
+    devicePixelRatio: number;
+    commentBoxes?: CommentBox[];
+    editingCommentBox?: CommentBox;
+    hoveredCommentBox?: CommentBox;
+    insertedImgs?: Image[];
+    editingInsertedImgs?: Image;
+    activeImg?: string;
+    presences?: Presence[];
+    showSearch?: boolean;
+    showReplace?: boolean;
+    linkCard?: LinkCardProps;
+    rangeDialog?: RangeDialogProps;
+    warnDialog?: string;
+    dataVerification?: {
+        selectStatus: boolean;
+        selectRange: [];
+        optionLabel_en: any;
+        optionLabel_zh: any;
+        optionLabel_zh_tw: any;
+        optionLabel_es: any;
+        dataRegulation?: DataRegulationProps;
+    };
+    dataVerificationDropDownList?: boolean;
+    conditionRules: ConditionRulesProps;
+    contextMenu: {
+        x?: number;
+        y?: number;
+        headerMenu?: boolean;
+        pageX?: number;
+        pageY?: number;
+    };
+    sheetTabContextMenu: {
+        x?: number;
+        y?: number;
+        sheet?: Sheet;
+        onRename?: () => void;
+    };
+    filterContextMenu?: {
+        x: number;
+        y: number;
+        col: number;
+        startRow: number;
+        endRow: number;
+        startCol: number;
+        endCol: number;
+        hiddenRows: number[];
+        listBoxMaxHeight: number;
+    };
+    currentSheetId: string;
+    calculateSheetId: string;
+    config: SheetConfig;
+    visibledatarow: number[];
+    visibledatacolumn: number[];
+    ch_width: number;
+    rh_height: number;
+    cellmainWidth: number;
+    cellmainHeight: number;
+    toolbarHeight: number;
+    infobarHeight: number;
+    calculatebarHeight: number;
+    rowHeaderWidth: number;
+    columnHeaderHeight: number;
+    cellMainSrollBarSize: number;
+    sheetBarHeight: number;
+    statisticBarHeight: number;
+    luckysheetTableContentHW: number[];
+    defaultcollen: number;
+    defaultrowlen: number;
+    scrollLeft: number;
+    scrollTop: number;
+    sheetScrollRecord: Record<string, any>;
+    luckysheet_select_status: boolean;
+    luckysheet_select_save: Sheet["luckysheet_select_save"];
+    luckysheet_selection_range: Sheet["luckysheet_selection_range"];
+    formulaRangeHighlight: ({
+        rangeIndex: number;
+        backgroundColor: string;
+    } & Rect)[];
+    formulaRangeSelect: ({
+        rangeIndex: number;
+    } & Rect) | undefined;
+    functionCandidates: any[];
+    functionHint: string | null | undefined;
+    luckysheet_copy_save?: {
+        dataSheetId: string;
+        copyRange: {
+            row: number[];
+            column: number[];
+        }[];
+        RowlChange: boolean;
+        HasMC: boolean;
+    };
+    luckysheet_paste_iscut: boolean;
+    filterchage: boolean;
+    filterOptions?: FilterOptions;
+    luckysheet_filter_save?: {
+        row: number[];
+        column: number[];
+    } | undefined;
+    filter: Record<string, {
+        caljs: any;
+        rowhidden: Record<string, number>;
+        optionstate: boolean;
+        str: number;
+        edr: number;
+        cindex: number;
+        stc: number;
+        edc: number;
+    }>;
+    luckysheet_sheet_move_status: boolean;
+    luckysheet_sheet_move_data: any[];
+    luckysheet_scroll_status: boolean;
+    luckysheetcurrentisPivotTable: boolean;
+    luckysheet_rows_selected_status: boolean;
+    luckysheet_cols_selected_status: boolean;
+    luckysheet_rows_change_size: boolean;
+    luckysheet_rows_change_size_start: any[];
+    luckysheet_cols_change_size: boolean;
+    luckysheet_cols_change_size_start: any[];
+    luckysheet_cols_freeze_drag: boolean;
+    luckysheet_rows_freeze_drag: boolean;
+    luckysheetCellUpdate: any[];
+    luckysheet_shiftkeydown: boolean;
+    luckysheet_shiftpositon: Selection | undefined;
+    iscopyself: boolean;
+    orderbyindex: number;
+    luckysheet_model_move_state: boolean;
+    luckysheet_model_xy: number[];
+    luckysheet_model_move_obj: any;
+    luckysheet_cell_selected_move: boolean;
+    luckysheet_cell_selected_move_index: any[];
+    luckysheet_cell_selected_extend: boolean;
+    luckysheet_cell_selected_extend_index: any[];
+    lang: string | null;
+    chart_selection: any;
+    zoomRatio: number;
+    showGridLines: boolean;
+    allowEdit: boolean;
+    fontList: any[];
+    defaultFontSize: number;
+    luckysheetPaintModelOn: boolean;
+    luckysheetPaintSingle: boolean;
+    defaultCell: Cell;
+    groupValuesRefreshData: any[];
+    formulaCache: FormulaCache;
+    hooks: Hooks;
+    showSheetList?: Boolean;
+    forceFormulaRef?: Boolean;
+    getRefs: () => RefValues;
+};
+export declare function defaultContext(refs: RefValues): Context;
+export declare function getFlowdata(ctx?: Context, id?: string | null): import("./types").CellMatrix | null | undefined;
+export declare function ensureSheetIndex(data: Sheet[], generateSheetId: () => string): void;
+export declare function initSheetIndex(ctx: Context): void;
+export declare function updateContextWithSheetData(ctx: Context, data: any[][]): void;
+export declare function updateContextWithCanvas(ctx: Context, canvas: HTMLCanvasElement, placeholder: HTMLDivElement): void;
+export {};

package/dist/events/copy.d.ts

@@ -0,0 +1,2 @@
+import { Context } from "../context";
+export declare function handleCopy(ctx: Context): void;

package/dist/events/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./copy";
+export * from "./keyboard";
+export * from "./mouse";
+export * from "./paste";

package/dist/events/keyboard.d.ts

@@ -0,0 +1,6 @@
+import { Context } from "../context";
+import { GlobalCache } from "../types";
+export declare function handleGlobalEnter(ctx: Context, cellInput: HTMLDivElement, e: KeyboardEvent, canvas?: CanvasRenderingContext2D): void;
+export declare function handleWithCtrlOrMetaKey(ctx: Context, cache: GlobalCache, e: KeyboardEvent, cellInput: HTMLDivElement, fxInput: HTMLDivElement | null | undefined, handleUndo: () => void, handleRedo: () => void): void;
+export declare function handleArrowKey(ctx: Context, e: KeyboardEvent): void;
+export declare function handleGlobalKeyDown(ctx: Context, cellInput: HTMLDivElement, fxInput: HTMLDivElement | null | undefined, e: KeyboardEvent, cache: GlobalCache, handleUndo: () => void, handleRedo: () => void, canvas?: CanvasRenderingContext2D): void;

package/dist/events/mouse.d.ts

@@ -0,0 +1,22 @@
+import { Freezen } from "..";
+import { Context } from "../context";
+import { Settings } from "../settings";
+import { GlobalCache } from "../types";
+export declare function handleGlobalWheel(ctx: Context, e: WheelEvent, cache: GlobalCache, scrollbarX: HTMLDivElement, scrollbarY: HTMLDivElement): void;
+export declare function fixPositionOnFrozenCells(freeze: Freezen | undefined, x: number, y: number, mouseX: number, mouseY: number): {
+    x: number;
+    y: number;
+    inHorizontalFreeze: boolean;
+    inVerticalFreeze: boolean;
+};
+export declare function handleCellAreaMouseDown(ctx: Context, globalCache: GlobalCache, e: MouseEvent, cellInput: HTMLDivElement, container: HTMLDivElement, fxInput?: HTMLDivElement | null, canvas?: CanvasRenderingContext2D): void;
+export declare function handleCellAreaDoubleClick(ctx: Context, globalCache: GlobalCache, settings: Settings, e: MouseEvent, container: HTMLElement): void;
+export declare function handleContextMenu(ctx: Context, settings: Settings, e: MouseEvent, workbookContainer: HTMLDivElement, container: HTMLDivElement, area: "cell" | "rowHeader" | "columnHeader"): void;
+export declare function handleOverlayMouseMove(ctx: Context, globalCache: GlobalCache, e: MouseEvent, cellInput: HTMLDivElement, scrollX: HTMLDivElement, scrollY: HTMLDivElement, container: HTMLDivElement, fxInput?: HTMLDivElement | null): void;
+export declare function handleOverlayMouseUp(ctx: Context, globalCache: GlobalCache, settings: Settings, e: MouseEvent, scrollbarX: HTMLDivElement, scrollbarY: HTMLDivElement, container: HTMLDivElement, cellInput: HTMLDivElement | null, fxInput: HTMLDivElement | null): void;
+export declare function handleRowHeaderMouseDown(ctx: Context, globalCache: GlobalCache, e: MouseEvent, container: HTMLDivElement, cellInput: HTMLDivElement, fxInput: HTMLDivElement | null): void;
+export declare function handleColumnHeaderMouseDown(ctx: Context, globalCache: GlobalCache, e: MouseEvent, container: HTMLElement, cellInput: HTMLDivElement, fxInput: HTMLDivElement | null): void;
+export declare function handleColSizeHandleMouseDown(ctx: Context, globalCache: GlobalCache, e: MouseEvent, headerContainer: HTMLDivElement, workbookContainer: HTMLDivElement, cellArea: HTMLDivElement): void;
+export declare function handleRowSizeHandleMouseDown(ctx: Context, globalCache: GlobalCache, e: MouseEvent, headerContainer: HTMLDivElement, workbookContainer: HTMLDivElement, cellArea: HTMLDivElement): void;
+export declare function handleColFreezeHandleMouseDown(ctx: Context, globalCache: GlobalCache, e: MouseEvent, headerContainer: HTMLDivElement, workbookContainer: HTMLDivElement, cellArea: HTMLDivElement): void;
+export declare function handleRowFreezeHandleMouseDown(ctx: Context, globalCache: GlobalCache, e: MouseEvent, headerContainer: HTMLDivElement, workbookContainer: HTMLDivElement, cellArea: HTMLDivElement): void;

package/dist/events/paste.d.ts

@@ -0,0 +1,3 @@
+import { Context } from "../context";
+export declare function handlePaste(ctx: Context, e: ClipboardEvent): void;
+export declare function handlePasteByClick(ctx: Context, triggerType?: string): void;

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+import * as api from "./api";
+export { api };
+export * from "./canvas";
+export * from "./context";
+export * from "./settings";
+export * from "./events";
+export * from "./locale";
+export * from "./modules";
+export * from "./utils";
+export * from "./types";