@fileverse-dev/fortune-core 1.0.4 → 1.0.6

package/es/utils/patch.js

@@ -0,0 +1,381 @@
+var __assign = this && this.__assign || function () {
+  __assign = Object.assign || function (t) {
+    for (var s, i = 1, n = arguments.length; i < n; i++) {
+      s = arguments[i];
+      for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+    }
+    return t;
+  };
+  return __assign.apply(this, arguments);
+};
+var __spreadArray = this && this.__spreadArray || function (to, from, pack) {
+  if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+    if (ar || !(i in from)) {
+      if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+      ar[i] = from[i];
+    }
+  }
+  return to.concat(ar || Array.prototype.slice.call(from));
+};
+import _ from "lodash";
+import { getSheetIndex } from ".";
+import { getFlowdata } from "../context";
+var addtionalMergeOps = function addtionalMergeOps(ops, id) {
+  var merge_new = {};
+  ops.some(function (op) {
+    if (op.op === "replace" && op.path[0] === "config" && op.path[1] === "merge") {
+      merge_new = op.value;
+      return true;
+    }
+    return false;
+  });
+  var new_ops = [];
+  Object.entries(merge_new).forEach(function (_a) {
+    var v = _a[1];
+    var _b = v,
+      r = _b.r,
+      c = _b.c,
+      rs = _b.rs,
+      cs = _b.cs;
+    var headerOp = {
+      op: "replace",
+      path: ["data", r, c, "mc"],
+      id: id,
+      value: v
+    };
+    for (var i = r; i < r + rs; i += 1) {
+      for (var j = c; j < c + cs; j += 1) {
+        new_ops.push({
+          op: "replace",
+          path: ["data", i, j, "mc"],
+          id: id,
+          value: {
+            r: r,
+            c: c
+          }
+        });
+      }
+    }
+    new_ops.push(headerOp);
+  });
+  return new_ops;
+};
+function additionalCellOps(ctx, insertRowColOp) {
+  var id = insertRowColOp.id,
+    index = insertRowColOp.index,
+    direction = insertRowColOp.direction,
+    count = insertRowColOp.count,
+    type = insertRowColOp.type;
+  var d = getFlowdata(ctx, id);
+  var startIndex = index + (direction === "rightbottom" ? 1 : 0);
+  if (d == null) {
+    return [];
+  }
+  var cellOps = [];
+  if (type === "row") {
+    for (var i = 0; i < d[startIndex].length; i += 1) {
+      var cell = d[startIndex][i];
+      if (cell != null) {
+        for (var j = 0; j < count; j += 1) {
+          cellOps.push({
+            op: "replace",
+            id: id,
+            path: ["data", startIndex + j, i],
+            value: cell
+          });
+        }
+      }
+    }
+  } else {
+    for (var i = 0; i < d.length; i += 1) {
+      var cell = d[i][startIndex];
+      if (cell != null) {
+        for (var j = 0; j < count; j += 1) {
+          cellOps.push({
+            op: "replace",
+            id: id,
+            path: ["data", i, startIndex + j],
+            value: cell
+          });
+        }
+      }
+    }
+  }
+  return cellOps;
+}
+export function filterPatch(patches) {
+  return _.filter(patches, function (p) {
+    return p.path[0] === "luckysheetfile" && p.path[2] !== "luckysheet_select_save";
+  });
+}
+export function extractFormulaCellOps(ops) {
+  var formulaOps = [];
+  ops.forEach(function (op) {
+    var _a, _b;
+    if (op.op === "remove") return;
+    if (op.path.length === 2 && Array.isArray(op.value)) {
+      for (var i = 0; i < op.value.length; i += 1) {
+        if ((_a = op.value[i]) === null || _a === void 0 ? void 0 : _a.f) {
+          formulaOps.push({
+            op: "replace",
+            id: op.id,
+            path: __spreadArray(__spreadArray([], op.path, true), [i], false),
+            value: op.value[i]
+          });
+        }
+      }
+    } else if (op.path.length === 3 && ((_b = op.value) === null || _b === void 0 ? void 0 : _b.f)) {
+      formulaOps.push(op);
+    } else if (op.path.length === 4 && op.path[3] === "f") {
+      formulaOps.push(op);
+    }
+  });
+  return formulaOps;
+}
+export function patchToOp(ctx, patches, options, undo) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
+  if (undo === void 0) {
+    undo = false;
+  }
+  var ops = patches.map(function (p) {
+    var op = {
+      op: p.op,
+      value: p.value,
+      path: p.path
+    };
+    if (p.path[0] === "luckysheetfile" && _.isNumber(p.path[1])) {
+      var id = ctx.luckysheetfile[p.path[1]].id;
+      op.id = id;
+      op.path = p.path.slice(2);
+      if (_.isEqual(op.path, ["calcChain", "length"])) {
+        op.path = ["calcChain"];
+        op.value = ctx.luckysheetfile[p.path[1]].calcChain;
+      }
+    }
+    return op;
+  });
+  _.every(ops, function (p) {
+    var _a;
+    if (p.op === "replace" && !_.isNil((_a = p.value) === null || _a === void 0 ? void 0 : _a.hl) && p.path.length === 3 && p.path[0] === "data") {
+      var index = getSheetIndex(ctx, p.id);
+      ops.push({
+        id: p.id,
+        op: "replace",
+        path: ["hyperlink", "".concat(p.path[1], "_").concat(p.path[2])],
+        value: ctx.luckysheetfile[index].hyperlink["".concat(p.value.hl.r, "_").concat(p.value.hl.c)]
+      });
+    }
+  });
+  if (options === null || options === void 0 ? void 0 : options.insertRowColOp) {
+    var _p = _.partition(ops, function (p) {
+        return p.path[0] !== "data";
+      }),
+      nonDataOps = _p[0],
+      dataOps = _p[1];
+    var formulaOps = extractFormulaCellOps(dataOps);
+    ops = nonDataOps;
+    ops.push({
+      op: "insertRowCol",
+      id: options.insertRowColOp.id,
+      path: [],
+      value: options.insertRowColOp
+    });
+    ops = __spreadArray(__spreadArray([], ops, true), formulaOps, true);
+    var mergeOps = addtionalMergeOps(ops, ctx.currentSheetId);
+    ops = __spreadArray(__spreadArray([], ops, true), mergeOps, true);
+    if (options === null || options === void 0 ? void 0 : options.restoreDeletedCells) {
+      var restoreCellsOps = [];
+      var flowdata = getFlowdata(ctx);
+      if (flowdata) {
+        var rowlen = flowdata.length;
+        var collen = flowdata[0].length;
+        for (var i = 0; i < rowlen; i += 1) {
+          for (var j = 0; j < collen; j += 1) {
+            var cell = flowdata[i][j];
+            if (!cell) continue;
+            if (options.insertRowColOp.type === "row" && i >= options.insertRowColOp.index && i < options.insertRowColOp.index + options.insertRowColOp.count || options.insertRowColOp.type === "column" && j >= options.insertRowColOp.index && j < options.insertRowColOp.index + options.insertRowColOp.count) {
+              restoreCellsOps.push({
+                op: "replace",
+                path: ["data", i, j],
+                id: ctx.currentSheetId,
+                value: cell
+              });
+            }
+          }
+        }
+      }
+      ops = __spreadArray(__spreadArray([], ops, true), restoreCellsOps, true);
+    } else {
+      var cellOps = additionalCellOps(ctx, options.insertRowColOp);
+      ops = __spreadArray(__spreadArray([], ops, true), cellOps, true);
+    }
+  } else if (options === null || options === void 0 ? void 0 : options.deleteRowColOp) {
+    var _q = _.partition(ops, function (p) {
+        return p.path[0] !== "data";
+      }),
+      nonDataOps = _q[0],
+      dataOps = _q[1];
+    var formulaOps = extractFormulaCellOps(dataOps);
+    ops = nonDataOps;
+    ops.push({
+      op: "deleteRowCol",
+      id: options.deleteRowColOp.id,
+      path: [],
+      value: options.deleteRowColOp
+    });
+    ops = __spreadArray(__spreadArray([], ops, true), formulaOps, true);
+    var mergeOps = addtionalMergeOps(ops, ctx.currentSheetId);
+    ops = __spreadArray(__spreadArray([], ops, true), mergeOps, true);
+  } else if (options === null || options === void 0 ? void 0 : options.addSheetOp) {
+    var _r = _.partition(ops, function (op) {
+        return op.path.length === 0 && op.op === "add";
+      }),
+      addSheetOps = _r[0],
+      otherOps = _r[1];
+    options.id = options.addSheet.id;
+    if (undo) {
+      var index = getSheetIndex(ctx, options.addSheet.id);
+      var order_1 = (_b = (_a = options.addSheet) === null || _a === void 0 ? void 0 : _a.value) === null || _b === void 0 ? void 0 : _b.order;
+      ops = otherOps;
+      ops.push({
+        op: "deleteSheet",
+        id: (_c = options.addSheet) === null || _c === void 0 ? void 0 : _c.id,
+        path: [],
+        value: options.addSheet
+      });
+      if (index !== ctx.luckysheetfile.length) {
+        var sheetsRight = ctx.luckysheetfile.filter(function (sheet) {
+          return (sheet === null || sheet === void 0 ? void 0 : sheet.order) >= order_1;
+        });
+        _.forEach(sheetsRight, function (sheet) {
+          ops.push({
+            id: sheet.id,
+            op: "replace",
+            path: ["order"],
+            value: (sheet === null || sheet === void 0 ? void 0 : sheet.order) - 1
+          });
+        });
+      }
+    } else {
+      ops = otherOps;
+      ops.push({
+        op: "addSheet",
+        id: (_d = options.addSheet) === null || _d === void 0 ? void 0 : _d.id,
+        path: [],
+        value: (_e = addSheetOps[0]) === null || _e === void 0 ? void 0 : _e.value
+      });
+    }
+  } else if (options === null || options === void 0 ? void 0 : options.deleteSheetOp) {
+    options.id = options.deleteSheetOp.id;
+    if (undo) {
+      ops = [{
+        op: "addSheet",
+        id: options.deleteSheetOp.id,
+        path: [],
+        value: (_f = options.deletedSheet) === null || _f === void 0 ? void 0 : _f.value
+      }, {
+        id: options.deleteSheetOp.id,
+        op: "replace",
+        path: ["name"],
+        value: (_h = (_g = options.deletedSheet) === null || _g === void 0 ? void 0 : _g.value) === null || _h === void 0 ? void 0 : _h.name
+      }];
+      var order_2 = (_k = (_j = options.deletedSheet) === null || _j === void 0 ? void 0 : _j.value) === null || _k === void 0 ? void 0 : _k.order;
+      var sheetsRight = ctx.luckysheetfile.filter(function (sheet) {
+        var _a;
+        return (sheet === null || sheet === void 0 ? void 0 : sheet.order) >= order_2 && sheet.id !== ((_a = options.deleteSheetOp) === null || _a === void 0 ? void 0 : _a.id);
+      });
+      _.forEach(sheetsRight, function (sheet) {
+        ops.push({
+          id: sheet.id,
+          op: "replace",
+          path: ["order"],
+          value: sheet === null || sheet === void 0 ? void 0 : sheet.order
+        });
+      });
+    } else {
+      ops = [{
+        op: "deleteSheet",
+        id: options.deleteSheetOp.id,
+        path: [],
+        value: options.deletedSheet
+      }];
+      var order_3 = (_m = (_l = options.deletedSheet) === null || _l === void 0 ? void 0 : _l.value) === null || _m === void 0 ? void 0 : _m.order;
+      if (((_o = options.deletedSheet) === null || _o === void 0 ? void 0 : _o.order) !== ctx.luckysheetfile.length) {
+        var sheetsRight = ctx.luckysheetfile.filter(function (sheet) {
+          return (sheet === null || sheet === void 0 ? void 0 : sheet.order) >= order_3;
+        });
+        _.forEach(sheetsRight, function (sheet) {
+          ops.push({
+            id: sheet.id,
+            op: "replace",
+            path: ["order"],
+            value: sheet === null || sheet === void 0 ? void 0 : sheet.order
+          });
+        });
+      }
+    }
+  }
+  return ops;
+}
+export function opToPatch(ctx, ops) {
+  var _a = _.partition(ops, function (op) {
+      return op.op === "add" || op.op === "remove" || op.op === "replace";
+    }),
+    normalOps = _a[0],
+    specialOps = _a[1];
+  var additionalPatches = [];
+  var patches = normalOps.map(function (op) {
+    var patch = {
+      op: op.op,
+      value: op.value,
+      path: op.path
+    };
+    if (op.id) {
+      var i = getSheetIndex(ctx, op.id);
+      if (i != null) {
+        patch.path = __spreadArray(["luckysheetfile", i], op.path, true);
+      } else {}
+      if (op.path[0] === "images" && op.id === ctx.currentSheetId) {
+        additionalPatches.push(__assign(__assign({}, patch), {
+          path: ["insertedImgs"]
+        }));
+      }
+      if (op.path[0] === "iframes" && op.id === ctx.currentSheetId) {
+        additionalPatches.push(__assign(__assign({}, patch), {
+          path: ["insertedIframes"]
+        }));
+      }
+    }
+    return patch;
+  });
+  return [patches.concat(additionalPatches), specialOps];
+}
+export function inverseRowColOptions(options) {
+  if (!options) return options;
+  if (options.insertRowColOp) {
+    var index = options.insertRowColOp.index;
+    if (options.insertRowColOp.direction === "rightbottom") {
+      index += 1;
+    }
+    return {
+      deleteRowColOp: {
+        type: options.insertRowColOp.type,
+        id: options.insertRowColOp.id,
+        start: index,
+        end: index + options.insertRowColOp.count - 1
+      }
+    };
+  }
+  if (options.deleteRowColOp) {
+    return {
+      insertRowColOp: {
+        type: options.deleteRowColOp.type,
+        id: options.deleteRowColOp.id,
+        index: options.deleteRowColOp.start,
+        count: options.deleteRowColOp.end - options.deleteRowColOp.start + 1,
+        direction: "lefttop"
+      }
+    };
+  }
+  return options;
+}

package/lib/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/lib/api/cell.js

@@ -0,0 +1,215 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.autoFillCell = autoFillCell;
+exports.clearCell = clearCell;
+exports.getCellValue = getCellValue;
+exports.setCellFormat = setCellFormat;
+exports.setCellValue = setCellValue;
+var _lodash = _interopRequireDefault(require("lodash"));
+var _modules = require("../modules");
+var _common = require("./common");
+var _errors = require("./errors");
+var _ssf = _interopRequireDefault(require("../modules/ssf"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+var __assign = void 0 && (void 0).__assign || function () {
+  __assign = Object.assign || function (t) {
+    for (var s, i = 1, n = arguments.length; i < n; i++) {
+      s = arguments[i];
+      for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+    }
+    return t;
+  };
+  return __assign.apply(this, arguments);
+};
+function getCellValue(ctx, row, column, options) {
+  var _a;
+  if (options === void 0) {
+    options = {};
+  }
+  if (!_lodash.default.isNumber(row) || !_lodash.default.isNumber(column)) {
+    throw new Error("row or column cannot be null or undefined");
+  }
+  var sheet = (0, _common.getSheet)(ctx, options);
+  var _b = options.type,
+    type = _b === void 0 ? "v" : _b;
+  var targetSheetData = sheet.data;
+  if (!targetSheetData) {
+    throw _errors.SHEET_NOT_FOUND;
+  }
+  var cellData = targetSheetData[row][column];
+  var ret;
+  if (cellData && _lodash.default.isPlainObject(cellData)) {
+    ret = cellData[type];
+    if (type === "f" && ret != null) {
+      ret = (0, _modules.functionHTMLGenerate)(ret);
+    } else if (type === "f") {
+      ret = cellData.v;
+    } else if (cellData && cellData.ct && cellData.ct.fa === "yyyy-MM-dd") {
+      ret = cellData.m;
+    } else if (((_a = cellData.ct) === null || _a === void 0 ? void 0 : _a.t) === "inlineStr") {
+      ret = cellData.ct.s.reduce(function (prev, cur) {
+        var _a;
+        return prev + ((_a = cur.v) !== null && _a !== void 0 ? _a : "");
+      }, "");
+    }
+  }
+  if (ret === undefined) {
+    ret = null;
+  }
+  return ret;
+}
+function setCellValue(ctx, row, column, value, cellInput, options) {
+  var _a;
+  if (options === void 0) {
+    options = {};
+  }
+  if (!_lodash.default.isNumber(row) || !_lodash.default.isNumber(column)) {
+    throw new Error("row or column cannot be null or undefined");
+  }
+  var sheet = (0, _common.getSheet)(ctx, options);
+  var data = sheet.data;
+  if (!data) return;
+  var formatList = {
+    bg: 1,
+    ff: 1,
+    fc: 1,
+    bl: 1,
+    it: 1,
+    fs: 1,
+    cl: 1,
+    un: 1,
+    vt: 1,
+    ht: 1,
+    mc: 1,
+    tr: 1,
+    tb: 1,
+    rt: 1,
+    qp: 1
+  };
+  if (value == null || value.toString().length === 0) {
+    (0, _modules.delFunctionGroup)(ctx, row, column);
+    (0, _modules.setCellValue)(ctx, row, column, data, value);
+  } else if (value instanceof Object) {
+    var curv = {};
+    if (((_a = data === null || data === void 0 ? void 0 : data[row]) === null || _a === void 0 ? void 0 : _a[column]) == null) {
+      data[row][column] = {};
+    }
+    var cell_1 = data[row][column];
+    if (value.f != null && value.v == null) {
+      curv.f = value.f;
+      if (value.ct != null) {
+        curv.ct = value.ct;
+      }
+      (0, _modules.updateCell)(ctx, row, column, cellInput, curv);
+    } else {
+      if (value.ct != null) {
+        curv.ct = value.ct;
+      }
+      if (value.f != null) {
+        curv.f = value.f;
+      }
+      if (value.v != null) {
+        curv.v = value.v;
+      } else {
+        curv.v = cell_1.v;
+      }
+      if (value.m != null) {
+        curv.m = value.m;
+      }
+      (0, _modules.delFunctionGroup)(ctx, row, column);
+      (0, _modules.setCellValue)(ctx, row, column, data, curv);
+    }
+    _lodash.default.forEach(value, function (v, attr) {
+      if (attr in formatList) {
+        (0, _modules.updateFormatCell)(ctx, data, attr, v, row, row, column, column);
+      } else {
+        cell_1[attr] = v;
+      }
+    });
+    data[row][column] = cell_1;
+  } else {
+    if (value.toString().substr(0, 1) === "=" || value.toString().substr(0, 5) === "<span") {
+      (0, _modules.updateCell)(ctx, row, column, cellInput, value);
+    } else {
+      (0, _modules.delFunctionGroup)(ctx, row, column);
+      (0, _modules.setCellValue)(ctx, row, column, data, value);
+    }
+  }
+}
+function clearCell(ctx, row, column, options) {
+  var _a, _b;
+  if (options === void 0) {
+    options = {};
+  }
+  if (!_lodash.default.isNumber(row) || !_lodash.default.isNumber(column)) {
+    throw new Error("row or column cannot be null or undefined");
+  }
+  var sheet = (0, _common.getSheet)(ctx, options);
+  var cell = (_b = (_a = sheet.data) === null || _a === void 0 ? void 0 : _a[row]) === null || _b === void 0 ? void 0 : _b[column];
+  if (cell && _lodash.default.isPlainObject(cell)) {
+    delete cell.m;
+    delete cell.v;
+    if (cell.f != null) {
+      delete cell.f;
+      (0, _modules.delFunctionGroup)(ctx, row, column, sheet.id);
+      delete cell.spl;
+    }
+  }
+}
+function setCellFormat(ctx, row, column, attr, value, options) {
+  var _a;
+  if (options === void 0) {
+    options = {};
+  }
+  if (!_lodash.default.isNumber(row) || !_lodash.default.isNumber(column)) {
+    throw new Error("row or column cannot be null or undefined");
+  }
+  if (!attr) {
+    throw new Error("attr cannot be null or undefined");
+  }
+  var sheet = (0, _common.getSheet)(ctx, options);
+  var targetSheetData = sheet.data;
+  var cellData = ((_a = targetSheetData === null || targetSheetData === void 0 ? void 0 : targetSheetData[row]) === null || _a === void 0 ? void 0 : _a[column]) || {};
+  var cfg = sheet.config || {};
+  if (attr === "ct" && (!value || value.fa == null || value.t == null)) {
+    throw new Error("'fa' and 't' should be present in value when attr is 'ct'");
+  } else if (attr === "ct" && !_lodash.default.isNil(cellData.v)) {
+    cellData.m = _ssf.default.format(value.fa, cellData.v);
+  }
+  if (attr === "bd") {
+    if (cfg.borderInfo == null) {
+      cfg.borderInfo = [];
+    }
+    var borderInfo = __assign({
+      rangeType: "range",
+      borderType: "border-all",
+      color: "#000",
+      style: "1",
+      range: [{
+        column: [column, column],
+        row: [row, row]
+      }]
+    }, value);
+    cfg.borderInfo.push(borderInfo);
+  } else {
+    cellData[attr] = value;
+  }
+  targetSheetData[row][column] = cellData;
+  sheet.config = cfg;
+  ctx.config = cfg;
+}
+function autoFillCell(ctx, copyRange, applyRange, direction) {
+  _modules.dropCellCache.copyRange = copyRange;
+  _modules.dropCellCache.applyRange = applyRange;
+  _modules.dropCellCache.direction = direction;
+  var typeItemHide = (0, _modules.getTypeItemHide)(ctx);
+  if (!typeItemHide[0] && !typeItemHide[1] && !typeItemHide[2] && !typeItemHide[3] && !typeItemHide[4] && !typeItemHide[5] && !typeItemHide[6]) {
+    _modules.dropCellCache.applyType = "0";
+  } else {
+    _modules.dropCellCache.applyType = "1";
+  }
+  (0, _modules.updateDropCell)(ctx);
+}

package/lib/api/common.d.ts

@@ -0,0 +1,66 @@
+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;
+    iframes?: {
+        id: string;
+        src: string;
+        left: number;
+        top: number;
+        width: number;
+        height: number;
+    }[] | 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;
+    conditionRules?: import("../types").ConditionRulesProps | undefined;
+    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;
+};