@fileverse-dev/fortune-core 1.0.5 → 1.0.7

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

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

@@ -0,0 +1,204 @@
+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);
+};
+import _ from "lodash";
+import { delFunctionGroup, dropCellCache, functionHTMLGenerate, getTypeItemHide, setCellValue as setCellValueInternal, updateCell, updateDropCell, updateFormatCell } from "../modules";
+import { getSheet } from "./common";
+import { SHEET_NOT_FOUND } from "./errors";
+import SSF from "../modules/ssf";
+export function getCellValue(ctx, row, column, options) {
+  var _a;
+  if (options === void 0) {
+    options = {};
+  }
+  if (!_.isNumber(row) || !_.isNumber(column)) {
+    throw new Error("row or column cannot be null or undefined");
+  }
+  var sheet = getSheet(ctx, options);
+  var _b = options.type,
+    type = _b === void 0 ? "v" : _b;
+  var targetSheetData = sheet.data;
+  if (!targetSheetData) {
+    throw SHEET_NOT_FOUND;
+  }
+  var cellData = targetSheetData[row][column];
+  var ret;
+  if (cellData && _.isPlainObject(cellData)) {
+    ret = cellData[type];
+    if (type === "f" && ret != null) {
+      ret = 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;
+}
+export function setCellValue(ctx, row, column, value, cellInput, options) {
+  var _a;
+  if (options === void 0) {
+    options = {};
+  }
+  if (!_.isNumber(row) || !_.isNumber(column)) {
+    throw new Error("row or column cannot be null or undefined");
+  }
+  var sheet = 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) {
+    delFunctionGroup(ctx, row, column);
+    setCellValueInternal(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;
+      }
+      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;
+      }
+      delFunctionGroup(ctx, row, column);
+      setCellValueInternal(ctx, row, column, data, curv);
+    }
+    _.forEach(value, function (v, attr) {
+      if (attr in formatList) {
+        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") {
+      updateCell(ctx, row, column, cellInput, value);
+    } else {
+      delFunctionGroup(ctx, row, column);
+      setCellValueInternal(ctx, row, column, data, value);
+    }
+  }
+}
+export function clearCell(ctx, row, column, options) {
+  var _a, _b;
+  if (options === void 0) {
+    options = {};
+  }
+  if (!_.isNumber(row) || !_.isNumber(column)) {
+    throw new Error("row or column cannot be null or undefined");
+  }
+  var sheet = 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 && _.isPlainObject(cell)) {
+    delete cell.m;
+    delete cell.v;
+    if (cell.f != null) {
+      delete cell.f;
+      delFunctionGroup(ctx, row, column, sheet.id);
+      delete cell.spl;
+    }
+  }
+}
+export function setCellFormat(ctx, row, column, attr, value, options) {
+  var _a;
+  if (options === void 0) {
+    options = {};
+  }
+  if (!_.isNumber(row) || !_.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 = 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" && !_.isNil(cellData.v)) {
+    cellData.m = SSF.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;
+}
+export function autoFillCell(ctx, copyRange, applyRange, direction) {
+  dropCellCache.copyRange = copyRange;
+  dropCellCache.applyRange = applyRange;
+  dropCellCache.direction = direction;
+  var typeItemHide = getTypeItemHide(ctx);
+  if (!typeItemHide[0] && !typeItemHide[1] && !typeItemHide[2] && !typeItemHide[3] && !typeItemHide[4] && !typeItemHide[5] && !typeItemHide[6]) {
+    dropCellCache.applyType = "0";
+  } else {
+    dropCellCache.applyType = "1";
+  }
+  updateDropCell(ctx);
+}

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

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

package/es/api/common.js

@@ -0,0 +1,79 @@
+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);
+};
+import _ from "lodash";
+import { getSheetIndex } from "../utils";
+import { SHEET_NOT_FOUND } from "./errors";
+export var dataToCelldata = function dataToCelldata(data) {
+  var celldata = [];
+  if (data == null) {
+    return celldata;
+  }
+  for (var r = 0; r < data.length; r += 1) {
+    for (var c = 0; c < data[r].length; c += 1) {
+      var v = data[r][c];
+      if (v != null) {
+        celldata.push({
+          r: r,
+          c: c,
+          v: v
+        });
+      }
+    }
+  }
+  return celldata;
+};
+export var celldataToData = function celldataToData(celldata, rowCount, colCount) {
+  var _a, _b;
+  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 (rowCount != null && colCount != null && rowCount > 0 && colCount > 0) {
+    lastRowNum = Math.max(lastRowNum, rowCount);
+    lastColNum = Math.max(lastColNum, colCount);
+  }
+  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;
+    });
+    return expandedData_1;
+  }
+  return null;
+};
+export function getSheet(ctx, options) {
+  if (options === void 0) {
+    options = {};
+  }
+  var _a = options.index,
+    index = _a === void 0 ? getSheetIndex(ctx, options.id || ctx.currentSheetId) : _a;
+  if (index == null) {
+    throw SHEET_NOT_FOUND;
+  }
+  var sheet = ctx.luckysheetfile[index];
+  if (sheet == null) {
+    throw SHEET_NOT_FOUND;
+  }
+  return sheet;
+}
+export function getSheetWithLatestCelldata(ctx, options) {
+  if (options === void 0) {
+    options = {};
+  }
+  var sheet = getSheet(ctx, options);
+  return __assign(__assign({}, sheet), {
+    celldata: dataToCelldata(sheet.data)
+  });
+}

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

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

package/es/api/errors.js

@@ -0,0 +1,2 @@
+export var INVALID_PARAMS = new Error("invalid params");
+export var SHEET_NOT_FOUND = new Error("sheet not found");

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

@@ -1,9 +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";
+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/es/api/index.js

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

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

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

@@ -0,0 +1,15 @@
+import { getSheet } from "./common";
+import { mergeCells as mergeCellsInternal } from "../modules";
+export function mergeCells(ctx, ranges, type, options) {
+  if (options === void 0) {
+    options = {};
+  }
+  var sheet = getSheet(ctx, options);
+  mergeCellsInternal(ctx, sheet.id, ranges, type);
+}
+export function cancelMerge(ctx, ranges, options) {
+  if (options === void 0) {
+    options = {};
+  }
+  mergeCells(ctx, ranges, "merge-cancel", options);
+}

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

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

@@ -0,0 +1,123 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+import _ from "lodash";
+import { getdatabyselection, getFlowdata, getRangetxt } from "..";
+import { normalizeSelection, rangeValueToHtml } from "../modules";
+import { setCellFormat, setCellValue } from "./cell";
+import { getSheet } from "./common";
+import { INVALID_PARAMS } from "./errors";
+export function getSelection(ctx) {
+  var _a;
+  return (_a = ctx.luckysheet_select_save) === null || _a === void 0 ? void 0 : _a.map(function (selection) {
+    return {
+      row: selection.row,
+      column: selection.column
+    };
+  });
+}
+export function getFlattenRange(ctx, range) {
+  range = range || getSelection(ctx);
+  var result = [];
+  range === null || range === void 0 ? void 0 : range.forEach(function (ele) {
+    var rs = ele.row;
+    var cs = ele.column;
+    for (var r = rs[0]; r <= rs[1]; r += 1) {
+      for (var c = cs[0]; c <= cs[1]; c += 1) {
+        result.push({
+          r: r,
+          c: c
+        });
+      }
+    }
+  });
+  return result;
+}
+export function getCellsByFlattenRange(ctx, range) {
+  range = range || getFlattenRange(ctx);
+  var flowdata = getFlowdata(ctx);
+  if (!flowdata) return [];
+  return range.map(function (item) {
+    var _a;
+    return (_a = flowdata[item.r]) === null || _a === void 0 ? void 0 : _a[item.c];
+  });
+}
+export function getSelectionCoordinates(ctx) {
+  var result = [];
+  var rangeArr = _.cloneDeep(ctx.luckysheet_select_save);
+  var sheetId = ctx.currentSheetId;
+  rangeArr === null || rangeArr === void 0 ? void 0 : rangeArr.forEach(function (ele) {
+    var rangeText = getRangetxt(ctx, sheetId, {
+      column: ele.column,
+      row: ele.row
+    });
+    result.push(rangeText);
+  });
+  return result;
+}
+export function getCellsByRange(ctx, range, options) {
+  if (options === void 0) {
+    options = {};
+  }
+  var sheet = getSheet(ctx, options);
+  if (!range || _typeof(range) === "object") {
+    return getdatabyselection(ctx, range, sheet.id);
+  }
+  throw INVALID_PARAMS;
+}
+export function getHtmlByRange(ctx, range, options) {
+  if (options === void 0) {
+    options = {};
+  }
+  var sheet = getSheet(ctx, options);
+  return rangeValueToHtml(ctx, sheet.id, range);
+}
+export function setSelection(ctx, range, options) {
+  var sheet = getSheet(ctx, options);
+  sheet.luckysheet_select_save = normalizeSelection(ctx, range);
+  if (ctx.currentSheetId === sheet.id) {
+    ctx.luckysheet_select_save = sheet.luckysheet_select_save;
+  }
+}
+export function setCellValuesByRange(ctx, data, range, cellInput, options) {
+  if (options === void 0) {
+    options = {};
+  }
+  if (data == null) {
+    throw INVALID_PARAMS;
+  }
+  if (range instanceof Array) {
+    throw new Error("setCellValuesByRange does not support multiple ranges");
+  }
+  if (!_.isPlainObject(range)) {
+    throw INVALID_PARAMS;
+  }
+  var rowCount = range.row[1] - range.row[0] + 1;
+  var columnCount = range.column[1] - range.column[0] + 1;
+  if (data.length !== rowCount || data[0].length !== columnCount) {
+    throw new Error("data size does not match range");
+  }
+  for (var i = 0; i < rowCount; i += 1) {
+    for (var j = 0; j < columnCount; j += 1) {
+      var row = range.row[0] + i;
+      var column = range.column[0] + j;
+      setCellValue(ctx, row, column, data[i][j], cellInput, options);
+    }
+  }
+}
+export function setCellFormatByRange(ctx, attr, value, range, options) {
+  if (options === void 0) {
+    options = {};
+  }
+  if (_.isPlainObject(range)) {
+    range = [range];
+  }
+  if (!_.isArray(range)) {
+    throw INVALID_PARAMS;
+  }
+  range.forEach(function (singleRange) {
+    for (var r = singleRange.row[0]; r <= singleRange.row[1]; r += 1) {
+      for (var c = singleRange.column[0]; c <= singleRange.column[1]; c += 1) {
+        setCellFormat(ctx, r, c, attr, value, options);
+      }
+    }
+  });
+}