@fileverse-dev/fortune-core 1.0.4 → 1.0.6

package/{dist/packages/core/src → es}/api/rowcol.d.ts

@@ -1,14 +1,14 @@
-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 hideRowOrColumn(ctx: Context, rowColInfo: string[], type: "row" | "column"): void;
-export declare function showRowOrColumn(ctx: Context, rowColInfo: string[], type: "row" | "column"): 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>;
+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 hideRowOrColumn(ctx: Context, rowColInfo: string[], type: "row" | "column"): void;
+export declare function showRowOrColumn(ctx: Context, rowColInfo: string[], type: "row" | "column"): 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/es/api/rowcol.js

@@ -0,0 +1,207 @@
+import _ from "lodash";
+import { deleteRowCol, insertRowCol } from "../modules";
+import { getSheet } from "./common";
+import { INVALID_PARAMS } from "./errors";
+import { getSheetIndex } from "../utils";
+export function freeze(ctx, type, range, options) {
+  if (options === void 0) {
+    options = {};
+  }
+  var sheet = getSheet(ctx, options);
+  var typeMap = {
+    row: "rangeRow",
+    column: "rangeColumn",
+    both: "rangeBoth"
+  };
+  var innerType = typeMap[type];
+  sheet.frozen = {
+    type: innerType,
+    range: {
+      column_focus: range.column,
+      row_focus: range.row
+    }
+  };
+}
+export function insertRowOrColumn(ctx, type, index, count, direction, options) {
+  if (options === void 0) {
+    options = {};
+  }
+  if (!["row", "column"].includes(type) || !_.isNumber(index) || !_.isNumber(count) || !["lefttop", "rightbottom"].includes(direction)) {
+    throw INVALID_PARAMS;
+  }
+  var sheet = getSheet(ctx, options);
+  try {
+    insertRowCol(ctx, {
+      type: type,
+      index: index,
+      count: count,
+      direction: direction,
+      id: sheet.id
+    });
+  } catch (e) {
+    console.error(e);
+  }
+}
+export function deleteRowOrColumn(ctx, type, start, end, options) {
+  if (options === void 0) {
+    options = {};
+  }
+  if (!["row", "column"].includes(type) || !_.isNumber(start) || !_.isNumber(end)) {
+    throw INVALID_PARAMS;
+  }
+  var sheet = getSheet(ctx, options);
+  deleteRowCol(ctx, {
+    type: type,
+    start: start,
+    end: end,
+    id: sheet.id
+  });
+}
+export function hideRowOrColumn(ctx, rowColInfo, type) {
+  var _a, _b;
+  if (!["row", "column"].includes(type)) {
+    throw INVALID_PARAMS;
+  }
+  if (!ctx || !ctx.config) return;
+  var index = getSheetIndex(ctx, ctx.currentSheetId);
+  if (type === "row") {
+    var rowhidden_1 = (_a = ctx.config.rowhidden) !== null && _a !== void 0 ? _a : {};
+    rowColInfo.forEach(function (r) {
+      rowhidden_1[r] = 0;
+    });
+    ctx.config.rowhidden = rowhidden_1;
+  } else if (type === "column") {
+    var colhidden_1 = (_b = ctx.config.colhidden) !== null && _b !== void 0 ? _b : {};
+    rowColInfo.forEach(function (r) {
+      colhidden_1[r] = 0;
+    });
+    ctx.config.colhidden = colhidden_1;
+  }
+  ctx.luckysheetfile[index].config = ctx.config;
+}
+export function showRowOrColumn(ctx, rowColInfo, type) {
+  var _a, _b;
+  if (!["row", "column"].includes(type)) {
+    throw INVALID_PARAMS;
+  }
+  if (!ctx || !ctx.config) return;
+  var index = getSheetIndex(ctx, ctx.currentSheetId);
+  if (type === "row") {
+    var rowhidden_2 = (_a = ctx.config.rowhidden) !== null && _a !== void 0 ? _a : {};
+    rowColInfo.forEach(function (r) {
+      delete rowhidden_2[r];
+    });
+    ctx.config.rowhidden = rowhidden_2;
+  } else if (type === "column") {
+    var colhidden_2 = (_b = ctx.config.colhidden) !== null && _b !== void 0 ? _b : {};
+    rowColInfo.forEach(function (r) {
+      delete colhidden_2[r];
+    });
+    ctx.config.colhidden = colhidden_2;
+  }
+  ctx.luckysheetfile[index].config = ctx.config;
+}
+export function setRowHeight(ctx, rowInfo, options, custom) {
+  if (options === void 0) {
+    options = {};
+  }
+  if (custom === void 0) {
+    custom = false;
+  }
+  if (!_.isPlainObject(rowInfo)) {
+    throw INVALID_PARAMS;
+  }
+  var sheet = getSheet(ctx, options);
+  var cfg = sheet.config || {};
+  if (cfg.rowlen == null) {
+    cfg.rowlen = {};
+  }
+  _.forEach(rowInfo, function (len, r) {
+    var _a;
+    if (Number(r) >= 0) {
+      if (Number(len) >= 0) {
+        cfg.rowlen[Number(r)] = Number(len);
+        if (custom && _.isUndefined(cfg.customHeight)) {
+          cfg.customHeight = (_a = {}, _a[r] = 1, _a);
+        } else if (custom) {
+          cfg.customHeight[r] = 1;
+        }
+      }
+    }
+  });
+  sheet.config = cfg;
+  if (ctx.currentSheetId === sheet.id) {
+    ctx.config = cfg;
+  }
+}
+export function setColumnWidth(ctx, columnInfo, options, custom) {
+  if (options === void 0) {
+    options = {};
+  }
+  if (custom === void 0) {
+    custom = false;
+  }
+  if (!_.isPlainObject(columnInfo)) {
+    throw INVALID_PARAMS;
+  }
+  var sheet = getSheet(ctx, options);
+  var cfg = sheet.config || {};
+  if (cfg.columnlen == null) {
+    cfg.columnlen = {};
+  }
+  _.forEach(columnInfo, function (len, c) {
+    var _a;
+    if (Number(c) >= 0) {
+      if (Number(len) >= 0) {
+        cfg.columnlen[Number(c)] = Number(len);
+        if (custom && _.isUndefined(cfg.customWidth)) {
+          cfg.customWidth = (_a = {}, _a[c] = 1, _a);
+        } else if (custom) {
+          cfg.customWidth[c] = 1;
+        }
+      }
+    }
+  });
+  sheet.config = cfg;
+  if (ctx.currentSheetId === sheet.id) {
+    ctx.config = cfg;
+  }
+}
+export function getRowHeight(ctx, rows, options) {
+  if (options === void 0) {
+    options = {};
+  }
+  if (!_.isArray(rows) || rows.length === 0) {
+    throw INVALID_PARAMS;
+  }
+  var sheet = getSheet(ctx, options);
+  var cfg = sheet.config || {};
+  var rowlen = cfg.rowlen || {};
+  var rowlenObj = {};
+  rows.forEach(function (item) {
+    if (Number(item) >= 0) {
+      var size = rowlen[Number(item)] || ctx.defaultrowlen;
+      rowlenObj[Number(item)] = size;
+    }
+  });
+  return rowlenObj;
+}
+export function getColumnWidth(ctx, columns, options) {
+  if (options === void 0) {
+    options = {};
+  }
+  if (!_.isArray(columns) || columns.length === 0) {
+    throw INVALID_PARAMS;
+  }
+  var sheet = getSheet(ctx, options);
+  var cfg = sheet.config || {};
+  var columnlen = cfg.columnlen || {};
+  var columnlenObj = {};
+  columns.forEach(function (item) {
+    if (Number(item) >= 0) {
+      var size = columnlen[Number(item)] || ctx.defaultcollen;
+      columnlenObj[Number(item)] = size;
+    }
+  });
+  return columnlenObj;
+}

package/{dist/packages/core/src → es}/api/sheet.d.ts

@@ -1,10 +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;
+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/es/api/sheet.js

@@ -0,0 +1,128 @@
+import _ from "lodash";
+import { v4 as uuidv4 } from "uuid";
+import { dataToCelldata, getSheet } from "./common";
+import { getSheetIndex } from "../utils";
+import { api, execfunction, insertUpdateFunctionGroup, locale } from "..";
+export function getAllSheets(ctx) {
+  return ctx.luckysheetfile;
+}
+export { getSheet };
+export function initSheetData(draftCtx, index, newData) {
+  var _a, _b;
+  var celldata = newData.celldata,
+    row = newData.row,
+    column = newData.column;
+  var lastRow = _.maxBy(celldata, "r");
+  var lastCol = _.maxBy(celldata, "c");
+  var lastRowNum = ((_a = lastRow === null || lastRow === void 0 ? void 0 : lastRow.r) !== null && _a !== void 0 ? _a : 0) + 1;
+  var lastColNum = ((_b = lastCol === null || lastCol === void 0 ? void 0 : lastCol.c) !== null && _b !== void 0 ? _b : 0) + 1;
+  if (row != null && column != null && row > 0 && column > 0) {
+    lastRowNum = Math.max(lastRowNum, row);
+    lastColNum = Math.max(lastColNum, column);
+  } else {
+    lastRowNum = Math.max(lastRowNum, draftCtx.defaultrowNum);
+    lastColNum = Math.max(lastColNum, draftCtx.defaultcolumnNum);
+  }
+  if (lastRowNum && lastColNum) {
+    var expandedData_1 = _.times(lastRowNum, function () {
+      return _.times(lastColNum, function () {
+        return null;
+      });
+    });
+    celldata === null || celldata === void 0 ? void 0 : celldata.forEach(function (d) {
+      expandedData_1[d.r][d.c] = d.v;
+    });
+    if (draftCtx.luckysheetfile[index] == null) {
+      newData.data = expandedData_1;
+      delete newData.celldata;
+      draftCtx.luckysheetfile.push(newData);
+    } else {
+      draftCtx.luckysheetfile[index].data = expandedData_1;
+      delete draftCtx.luckysheetfile[index].celldata;
+    }
+    return expandedData_1;
+  }
+  return null;
+}
+export function hideSheet(ctx, sheetId) {
+  var index = getSheetIndex(ctx, sheetId);
+  ctx.luckysheetfile[index].hide = 1;
+  ctx.luckysheetfile[index].status = 0;
+  var shownSheets = ctx.luckysheetfile.filter(function (sheet) {
+    return _.isUndefined(sheet.hide) || (sheet === null || sheet === void 0 ? void 0 : sheet.hide) !== 1;
+  });
+  ctx.currentSheetId = shownSheets[0].id;
+}
+export function showSheet(ctx, sheetId) {
+  var index = getSheetIndex(ctx, sheetId);
+  ctx.luckysheetfile[index].hide = undefined;
+}
+function generateCopySheetName(ctx, sheetId) {
+  var info = locale(ctx).info;
+  var copyWord = "(".concat(info.copy);
+  var SheetIndex = getSheetIndex(ctx, sheetId);
+  var sheetName = ctx.luckysheetfile[SheetIndex].name;
+  var copy_i = sheetName.indexOf(copyWord);
+  var index = 0;
+  if (copy_i !== -1) {
+    sheetName = sheetName.toString().substring(0, copy_i);
+  }
+  var nameCopy = sheetName + copyWord;
+  var sheetNames = [];
+  for (var i = 0; i < ctx.luckysheetfile.length; i += 1) {
+    var fileName = ctx.luckysheetfile[i].name;
+    sheetNames.push(fileName);
+    var st_i = fileName.indexOf(nameCopy);
+    if (st_i === 0) {
+      index = index || 2;
+      var ed_i = fileName.indexOf(")", st_i + nameCopy.length);
+      var num = fileName.substring(st_i + nameCopy.length, ed_i);
+      if (_.isNumber(num)) {
+        if (Number.parseInt(num, 10) >= index) {
+          index = Number.parseInt(num, 10) + 1;
+        }
+      }
+    }
+  }
+  var sheetCopyName;
+  do {
+    var postfix = "".concat(copyWord + (index || ""), ")");
+    var lengthLimit = 31 - postfix.length;
+    sheetCopyName = sheetName;
+    if (sheetCopyName.length > lengthLimit) {
+      sheetCopyName = "".concat(sheetCopyName.slice(0, lengthLimit - 1), "\u2026");
+    }
+    sheetCopyName += postfix;
+    index = (index || 1) + 1;
+  } while (sheetNames.indexOf(sheetCopyName) !== -1);
+  return sheetCopyName;
+}
+export function copySheet(ctx, sheetId) {
+  var index = getSheetIndex(ctx, sheetId);
+  var order = ctx.luckysheetfile[index].order + 1;
+  var sheetName = generateCopySheetName(ctx, sheetId);
+  var sheetData = _.cloneDeep(ctx.luckysheetfile[index]);
+  delete sheetData.id;
+  delete sheetData.status;
+  sheetData.celldata = dataToCelldata(sheetData.data);
+  delete sheetData.data;
+  api.addSheet(ctx, undefined, uuidv4(), ctx.luckysheetfile[index].isPivotTable, sheetName, sheetData);
+  var sheetOrderList = {};
+  sheetOrderList[ctx.luckysheetfile[ctx.luckysheetfile.length - 1].id] = order;
+  api.setSheetOrder(ctx, sheetOrderList);
+}
+export function calculateSheetFromula(ctx, id) {
+  var _a, _b;
+  var index = getSheetIndex(ctx, id);
+  if (!ctx.luckysheetfile[index].data) return;
+  for (var r = 0; r < ctx.luckysheetfile[index].data.length; r += 1) {
+    for (var c = 0; c < ctx.luckysheetfile[index].data[r].length; c += 1) {
+      if (!((_a = ctx.luckysheetfile[index].data[r][c]) === null || _a === void 0 ? void 0 : _a.f)) {
+        continue;
+      }
+      var result = execfunction(ctx, (_b = ctx.luckysheetfile[index].data[r][c]) === null || _b === void 0 ? void 0 : _b.f, r, c, id);
+      api.setCellValue(ctx, r, c, result[1], null);
+      insertUpdateFunctionGroup(ctx, r, c, id);
+    }
+  }
+}

package/{dist/packages/core/src → es}/api/workbook.d.ts

@@ -1,15 +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;
+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/es/api/workbook.js

@@ -0,0 +1,85 @@
+import _ from "lodash";
+import { addSheet as addSheetInternal, deleteSheet as deleteSheetInternal, updateSheet as updateSheetInternal } from "../modules";
+import { getSheet } from "./common";
+import { INVALID_PARAMS } from "./errors";
+export function addSheet(ctx, settings, newSheetID, isPivotTable, sheetname, sheetData) {
+  if (isPivotTable === void 0) {
+    isPivotTable = false;
+  }
+  if (sheetname === void 0) {
+    sheetname = undefined;
+  }
+  if (sheetData === void 0) {
+    sheetData = undefined;
+  }
+  addSheetInternal(ctx, settings, newSheetID, isPivotTable, sheetname, sheetData);
+}
+export function deleteSheet(ctx, options) {
+  if (options === void 0) {
+    options = {};
+  }
+  var sheet = getSheet(ctx, options);
+  deleteSheetInternal(ctx, sheet.id);
+}
+export function updateSheet(ctx, data) {
+  updateSheetInternal(ctx, data);
+}
+export function activateSheet(ctx, options) {
+  if (options === void 0) {
+    options = {};
+  }
+  var sheet = getSheet(ctx, options);
+  ctx.currentSheetId = sheet.id;
+}
+export function setSheetName(ctx, name, options) {
+  if (options === void 0) {
+    options = {};
+  }
+  var sheet = getSheet(ctx, options);
+  sheet.name = name;
+}
+export function setSheetOrder(ctx, orderList) {
+  var _a;
+  (_a = ctx.luckysheetfile) === null || _a === void 0 ? void 0 : _a.forEach(function (sheet) {
+    if (sheet.id in orderList) {
+      sheet.order = orderList[sheet.id];
+    }
+  });
+  _.sortBy(ctx.luckysheetfile, ["order"]).forEach(function (sheet, i) {
+    sheet.order = i;
+  });
+}
+export function scroll(ctx, scrollbarX, scrollbarY, options) {
+  if (options.scrollLeft != null) {
+    if (!_.isNumber(options.scrollLeft)) {
+      throw INVALID_PARAMS;
+    }
+    if (scrollbarX) {
+      scrollbarX.scrollLeft = options.scrollLeft;
+    }
+  } else if (options.targetColumn != null) {
+    if (!_.isNumber(options.targetColumn)) {
+      throw INVALID_PARAMS;
+    }
+    var col_pre = options.targetColumn <= 0 ? 0 : ctx.visibledatacolumn[options.targetColumn - 1];
+    if (scrollbarX) {
+      scrollbarX.scrollLeft = col_pre;
+    }
+  }
+  if (options.scrollTop != null) {
+    if (!_.isNumber(options.scrollTop)) {
+      throw INVALID_PARAMS;
+    }
+    if (scrollbarY) {
+      scrollbarY.scrollTop = options.scrollTop;
+    }
+  } else if (options.targetRow != null) {
+    if (!_.isNumber(options.targetRow)) {
+      throw INVALID_PARAMS;
+    }
+    var row_pre = options.targetRow <= 0 ? 0 : ctx.visibledatarow[options.targetRow - 1];
+    if (scrollbarY) {
+      scrollbarY.scrollTop = row_pre;
+    }
+  }
+}

package/{dist/packages/core/src → es}/canvas.d.ts

@@ -1,46 +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;
-}
+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;
+}