@nfdi4plants/arctrl 3.0.0-beta.1 → 3.0.0-beta.11

package/dist/ts/ts/fable_modules/FsSpreadsheet.7.0.0-alpha.1/Json/Value.fs.js

@@ -0,0 +1,71 @@
+import { minValue, tryParse, toString } from '../../../../node_modules/@fable-org/fable-library-js/Date.js';
+import { FSharpRef } from '../../../../node_modules/@fable-org/fable-library-js/Types.js';
+import { FSharpResult$2_Ok, FSharpResult$2_Error } from '../../../../node_modules/@fable-org/fable-library-js/Result.js';
+import { ErrorReason$1_BadPrimitive } from '../../Thoth.Json.Core.0.7.0/Types.fs.js';
+import { item } from '../../../../node_modules/@fable-org/fable-library-js/Array.js';
+import { oneOf, map, bool, int, float, string } from '../../Thoth.Json.Core.0.7.0/Decode.fs.js';
+import { DataType_Boolean, DataType_Number, DataType_Date, DataType_String } from '../Cells/FsCell.fs.js';
+import { ofArray } from '../../../../node_modules/@fable-org/fable-library-js/List.js';
+
+const Decode_datetime = {
+  Decode(helpers, value) {
+    if (helpers.isString(value)) {
+      let matchValue;
+      let outArg = minValue();
+      matchValue = [tryParse(helpers.asString(value), new FSharpRef(() => outArg, (v) => {
+        outArg = v;
+      })), outArg];
+      return matchValue[0] ? FSharpResult$2_Ok(matchValue[1]) : FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("a datetime", value)]);
+    } else {
+      return FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("a datetime", value)]);
+    }
+  }
+};
+function encode(value) {
+  if (typeof value === "string") {
+    const s = value;
+    return {
+      Encode(helpers) {
+        return helpers.encodeString(s);
+      }
+    };
+  } else if (typeof value === "number") {
+    const f = value;
+    return {
+      Encode(helpers_1) {
+        return helpers_1.encodeDecimalNumber(f);
+      }
+    };
+  } else if (typeof value === "number") {
+    const i = value | 0;
+    return {
+      Encode(helpers_2) {
+        return helpers_2.encodeSignedIntegralNumber(i);
+      }
+    };
+  } else if (typeof value === "boolean") {
+    const b = value;
+    return {
+      Encode(helpers_3) {
+        return helpers_3.encodeBool(b);
+      }
+    };
+  } else if (value instanceof Date) {
+    const d = value;
+    const value_5 = item(0, toString(d, "O", {}).split("+"));
+    return {
+      Encode(helpers_4) {
+        return helpers_4.encodeString(value_5);
+      }
+    };
+  } else {
+    return {
+      Encode(helpers_5) {
+        return helpers_5.encodeNull();
+      }
+    };
+  }
+}
+const decode = oneOf(ofArray([map((b) => [b, DataType_Boolean()], bool), map((i) => [i, DataType_Number()], int), map((f) => [f, DataType_Number()], float), map((d_3) => [d_3, DataType_Date()], Decode_datetime), map((s) => [s, DataType_String()], string)]));
+
+export { Decode_datetime, decode, encode };

package/dist/ts/ts/fable_modules/FsSpreadsheet.7.0.0-alpha.1/Json/Workbook.fs.js

@@ -0,0 +1,44 @@
+import { seq } from '../../Thoth.Json.Core.0.7.0/Encode.fs.js';
+import { map } from '../../../../node_modules/@fable-org/fable-library-js/Seq.js';
+import { encodeRows as encodeRows$1, decodeRows as decodeRows$1, encodeColumns as encodeColumns$1, decodeColumns as decodeColumns$1 } from './Worksheet.fs.js';
+import { FsWorkbook } from '../FsWorkbook.fs.js';
+import { object, seq as seq$1 } from '../../Thoth.Json.Core.0.7.0/Decode.fs.js';
+
+function encodeRows(noNumbering, wb) {
+  const values = [["sheets", seq(map((sheet) => encodeRows$1(noNumbering, sheet), wb.GetWorksheets()))]];
+  return {
+    Encode(helpers) {
+      const arg = map((tupledArg) => [tupledArg[0], tupledArg[1].Encode(helpers)], values);
+      return helpers.encodeObject(arg);
+    }
+  };
+}
+const decodeRows = object((builder) => {
+  const wb = new FsWorkbook();
+  let ws;
+  const arg_1 = seq$1(decodeRows$1);
+  const objectArg = builder.Required;
+  ws = objectArg.Field("sheets", arg_1);
+  wb.AddWorksheets(ws);
+  return wb;
+});
+function encodeColumns(noNumbering, wb) {
+  const values = [["sheets", seq(map((sheet) => encodeColumns$1(noNumbering, sheet), wb.GetWorksheets()))]];
+  return {
+    Encode(helpers) {
+      const arg = map((tupledArg) => [tupledArg[0], tupledArg[1].Encode(helpers)], values);
+      return helpers.encodeObject(arg);
+    }
+  };
+}
+const decodeColumns = object((builder) => {
+  const wb = new FsWorkbook();
+  let ws;
+  const arg_1 = seq$1(decodeColumns$1);
+  const objectArg = builder.Required;
+  ws = objectArg.Field("sheets", arg_1);
+  wb.AddWorksheets(ws);
+  return wb;
+});
+
+export { decodeColumns, decodeRows, encodeColumns, encodeRows };

package/dist/ts/ts/fable_modules/FsSpreadsheet.7.0.0-alpha.1/Json/Worksheet.fs.js

@@ -0,0 +1,129 @@
+import { seq } from '../../Thoth.Json.Core.0.7.0/Encode.fs.js';
+import { toList, delay, map, collect, singleton, append, isEmpty, empty, iterate } from '../../../../node_modules/@fable-org/fable-library-js/Seq.js';
+import { encodeNoNumbers, encode, decode as decode$1 } from './Row.fs.js';
+import { value, defaultArg } from '../../../../node_modules/@fable-org/fable-library-js/Option.js';
+import { FsCell } from '../Cells/FsCell.fs.js';
+import { rangeDouble } from '../../../../node_modules/@fable-org/fable-library-js/Range.js';
+import { encode as encode$1, decode } from './Table.fs.js';
+import { FsWorksheet } from '../FsWorksheet.fs.js';
+import { object, string, seq as seq$1 } from '../../Thoth.Json.Core.0.7.0/Decode.fs.js';
+import { encodeNoNumbers as encodeNoNumbers$1, encode as encode$2, decode as decode$2 } from './Column.fs.js';
+
+function encodeRows(noNumbering, sheet) {
+  sheet.RescanRows();
+  const jRows = noNumbering ? seq(toList(delay(() => map((r) => encodeNoNumbers(toList(delay(() => collect((c) => {
+    const matchValue = sheet.CellCollection.TryGetCell(r, c);
+    return matchValue == null ? singleton(new FsCell("")) : singleton(value(matchValue));
+  }, rangeDouble(1, 1, sheet.MaxColumnIndex))))), rangeDouble(1, 1, sheet.MaxRowIndex))))) : seq(map(encode, sheet.Rows));
+  const values_1 = toList(delay(() => {
+    let value;
+    return append(singleton(["name", (value = sheet.Name, {
+      Encode(helpers) {
+        return helpers.encodeString(value);
+      }
+    })]), delay(() => append(!isEmpty(sheet.Tables) ? singleton(["tables", seq(map(encode$1, sheet.Tables))]) : empty(), delay(() => singleton(["rows", jRows])))));
+  }));
+  return {
+    Encode(helpers_1) {
+      const arg = map((tupledArg) => [tupledArg[0], tupledArg[1].Encode(helpers_1)], values_1);
+      return helpers_1.encodeObject(arg);
+    }
+  };
+}
+const decodeRows = object((builder) => {
+  let arg_5, objectArg_2;
+  let rowIndex = 0;
+  let n;
+  const objectArg = builder.Required;
+  n = objectArg.Field("name", string);
+  let ts;
+  const arg_3 = seq$1(decode);
+  const objectArg_1 = builder.Optional;
+  ts = objectArg_1.Field("tables", arg_3);
+  const rs = defaultArg((arg_5 = seq$1(decode$1), objectArg_2 = builder.Optional, objectArg_2.Field("rows", arg_5)), empty());
+  const sheet = new FsWorksheet(n);
+  iterate((tupledArg) => {
+    const rowI = tupledArg[0];
+    let colIndex = 0;
+    const rowI_1 = (rowI == null ? rowIndex + 1 : value(rowI)) | 0;
+    rowIndex = rowI_1 | 0;
+    const r = sheet.Row(rowI_1);
+    iterate((cell) => {
+      let colI;
+      const matchValue = cell.ColumnNumber | 0;
+      colI = matchValue === 0 ? colIndex + 1 : matchValue;
+      colIndex = colI | 0;
+      const c = r.Item(colI);
+      c.Value = cell.Value;
+      c.DataType = cell.DataType;
+    }, tupledArg[1]);
+  }, rs);
+  if (ts == null) {
+  } else {
+    iterate((t) => {
+      sheet.AddTable(t);
+    }, value(ts));
+  }
+  return sheet;
+});
+function encodeColumns(noNumbering, sheet) {
+  sheet.RescanRows();
+  const jColumns = noNumbering ? seq(toList(delay(() => map((c) => encodeNoNumbers$1(toList(delay(() => collect((r) => {
+    const matchValue = sheet.CellCollection.TryGetCell(r, c);
+    return matchValue == null ? singleton(new FsCell("")) : singleton(value(matchValue));
+  }, rangeDouble(1, 1, sheet.MaxRowIndex))))), rangeDouble(1, 1, sheet.MaxColumnIndex))))) : seq(map(encode$2, sheet.Columns));
+  const values_1 = toList(delay(() => {
+    let value;
+    return append(singleton(["name", (value = sheet.Name, {
+      Encode(helpers) {
+        return helpers.encodeString(value);
+      }
+    })]), delay(() => append(!isEmpty(sheet.Tables) ? singleton(["tables", seq(map(encode$1, sheet.Tables))]) : empty(), delay(() => singleton(["columns", jColumns])))));
+  }));
+  return {
+    Encode(helpers_1) {
+      const arg = map((tupledArg) => [tupledArg[0], tupledArg[1].Encode(helpers_1)], values_1);
+      return helpers_1.encodeObject(arg);
+    }
+  };
+}
+const decodeColumns = object((builder) => {
+  let colIndex = 0;
+  let n;
+  const objectArg = builder.Required;
+  n = objectArg.Field("name", string);
+  let ts;
+  const arg_3 = seq$1(decode);
+  const objectArg_1 = builder.Optional;
+  ts = objectArg_1.Field("tables", arg_3);
+  let cs;
+  const arg_5 = seq$1(decode$2);
+  const objectArg_2 = builder.Required;
+  cs = objectArg_2.Field("columns", arg_5);
+  const sheet = new FsWorksheet(n);
+  iterate((tupledArg) => {
+    const colI = tupledArg[0];
+    let rowIndex = 0;
+    const colI_1 = (colI == null ? colIndex + 1 : value(colI)) | 0;
+    colIndex = colI_1 | 0;
+    const col = sheet.Column(colI_1);
+    iterate((cell) => {
+      let rowI;
+      const matchValue = cell.RowNumber | 0;
+      rowI = matchValue === 0 ? rowIndex + 1 : matchValue;
+      rowIndex = rowI | 0;
+      const c = col.Item(rowIndex);
+      c.Value = cell.Value;
+      c.DataType = cell.DataType;
+    }, tupledArg[1]);
+  }, cs);
+  if (ts == null) {
+  } else {
+    iterate((t) => {
+      sheet.AddTable(t);
+    }, value(ts));
+  }
+  return sheet;
+});
+
+export { decodeColumns, decodeRows, encodeColumns, encodeRows };

package/dist/ts/ts/fable_modules/FsSpreadsheet.7.0.0-alpha.1/Ranges/FsRange.fs.js

@@ -0,0 +1,35 @@
+import { defaultOf, int32ToString } from '../../../../node_modules/@fable-org/fable-library-js/Util.js';
+import { some } from '../../../../node_modules/@fable-org/fable-library-js/Option.js';
+import { FsRangeBase, FsRangeBase_$reflection } from './FsRangeBase.fs.js';
+import { toText, printf } from '../../../../node_modules/@fable-org/fable-library-js/String.js';
+import { FsRangeRow } from './FsRangeRow.fs.js';
+import { FsRangeAddress } from './FsRangeAddress.fs.js';
+import { FsAddress } from '../FsAddress.fs.js';
+import { class_type } from '../../../../node_modules/@fable-org/fable-library-js/Reflection.js';
+
+class FsRange extends FsRangeBase {
+  constructor(rangeAddress, styleValue) {
+    super(rangeAddress);
+  }
+  static fromRangeBase(rangeBase) {
+    return new FsRange(rangeBase.RangeAddress, some(defaultOf()));
+  }
+  Row(row) {
+    if (row <= 0 ? true : row + super.RangeAddress.FirstAddress.RowNumber - 1 > 1048576) {
+      throw new Error(int32ToString(row), toText(printf("Row number must be between 1 and %i"))(1048576));
+    }
+    return new FsRangeRow(new FsRangeAddress(new FsAddress(super.RangeAddress.FirstAddress.RowNumber + row - 1, super.RangeAddress.FirstAddress.ColumnNumber), new FsAddress(super.RangeAddress.FirstAddress.RowNumber + row - 1, super.RangeAddress.LastAddress.ColumnNumber)));
+  }
+  FirstRow() {
+    const self = this;
+    return self.Row(1);
+  }
+}
+function FsRange_$reflection() {
+  return class_type("FsSpreadsheet.FsRange", void 0, FsRange, FsRangeBase_$reflection());
+}
+function FsRange_$ctor_Z15E90CDC(rangeAddress, styleValue) {
+  return new FsRange(rangeAddress, styleValue);
+}
+
+export { FsRange, FsRange_$ctor_Z15E90CDC, FsRange_$reflection };

package/dist/ts/ts/fable_modules/FsSpreadsheet.7.0.0-alpha.1/Ranges/FsRangeAddress.fs.js

@@ -0,0 +1,161 @@
+import { FsAddress, CellReference_toIndices, CellReference_moveHorizontal } from '../FsAddress.fs.js';
+import { class_type } from '../../../../node_modules/@fable-org/fable-library-js/Reflection.js';
+import { toText, printf, toConsole } from '../../../../node_modules/@fable-org/fable-library-js/String.js';
+import { item } from '../../../../node_modules/@fable-org/fable-library-js/Array.js';
+
+class FsRangeAddress {
+  constructor(firstAddress, lastAddress) {
+    this.firstAddress = firstAddress;
+    this.lastAddress = lastAddress;
+    this._firstAddress = this.firstAddress;
+    this._lastAddress = this.lastAddress;
+  }
+  static fromString(rangeAddress) {
+    const patternInput = Range_toBoundaries(rangeAddress);
+    return new FsRangeAddress(FsAddress.fromString(patternInput[0]), FsAddress.fromString(patternInput[1]));
+  }
+  Copy() {
+    const self = this;
+    return FsRangeAddress.fromString(self.Range);
+  }
+  static copy(rangeAddress) {
+    return rangeAddress.Copy();
+  }
+  Extend(address) {
+    const self = this;
+    if (address.RowNumber < self._firstAddress.RowNumber) {
+      self._firstAddress.RowNumber = address.RowNumber | 0;
+    }
+    if (address.RowNumber > self._lastAddress.RowNumber) {
+      self._lastAddress.RowNumber = address.RowNumber | 0;
+    }
+    if (address.ColumnNumber < self._firstAddress.ColumnNumber) {
+      self._firstAddress.ColumnNumber = address.ColumnNumber | 0;
+    }
+    if (address.ColumnNumber > self._lastAddress.ColumnNumber) {
+      self._lastAddress.ColumnNumber = address.ColumnNumber | 0;
+    }
+  }
+  Normalize() {
+    const self = this;
+    const patternInput = self.firstAddress.RowNumber < self.lastAddress.RowNumber ? [self.firstAddress.RowNumber, self.lastAddress.RowNumber] : [self.lastAddress.RowNumber, self.firstAddress.RowNumber];
+    const patternInput_1 = self.firstAddress.RowNumber < self.lastAddress.RowNumber ? [self.firstAddress.RowNumber, self.lastAddress.RowNumber] : [self.lastAddress.RowNumber, self.firstAddress.RowNumber];
+    self._firstAddress = new FsAddress(patternInput[0], patternInput_1[0]);
+    self._lastAddress = new FsAddress(patternInput[1], patternInput_1[1]);
+  }
+  get Range() {
+    const self = this;
+    return Range_ofBoundaries(self._firstAddress.Address, self._lastAddress.Address);
+  }
+  set Range(address) {
+    const self = this;
+    const patternInput = Range_toBoundaries(address);
+    self._firstAddress = FsAddress.fromString(patternInput[0]);
+    self._lastAddress = FsAddress.fromString(patternInput[1]);
+  }
+  toString() {
+    const self = this;
+    return self.Range;
+  }
+  get FirstAddress() {
+    const self = this;
+    return self._firstAddress;
+  }
+  get LastAddress() {
+    const self = this;
+    return self._lastAddress;
+  }
+  Union(rangeAddress) {
+    const self = this;
+    self.Extend(rangeAddress.FirstAddress);
+    self.Extend(rangeAddress.LastAddress);
+    return self;
+  }
+}
+function FsRangeAddress_$reflection() {
+  return class_type("FsSpreadsheet.FsRangeAddress", void 0, FsRangeAddress);
+}
+function FsRangeAddress_$ctor_7E77A4A0(firstAddress, lastAddress) {
+  return new FsRangeAddress(firstAddress, lastAddress);
+}
+function Range_ofBoundaries(fromCellReference, toCellReference) {
+  return toText(printf("%s:%s"))(fromCellReference)(toCellReference);
+}
+function Range_toBoundaries(area) {
+  const a = area.split(":");
+  return [item(0, a), item(1, a)];
+}
+function Range_rightBoundary(area) {
+  return CellReference_toIndices(Range_toBoundaries(area)[1])[0];
+}
+function Range_leftBoundary(area) {
+  return CellReference_toIndices(Range_toBoundaries(area)[0])[0];
+}
+function Range_upperBoundary(area) {
+  return CellReference_toIndices(Range_toBoundaries(area)[0])[1];
+}
+function Range_lowerBoundary(area) {
+  return CellReference_toIndices(Range_toBoundaries(area)[1])[1];
+}
+function Range_moveHorizontal(amount, area) {
+  let tupledArg_1;
+  const tupledArg = Range_toBoundaries(area);
+  tupledArg_1 = [CellReference_moveHorizontal(amount, tupledArg[0]), CellReference_moveHorizontal(amount, tupledArg[1])];
+  return Range_ofBoundaries(tupledArg_1[0], tupledArg_1[1]);
+}
+function Range_moveVertical(amount, area) {
+  let tupledArg_1;
+  const tupledArg = Range_toBoundaries(area);
+  tupledArg_1 = [CellReference_moveHorizontal(amount, tupledArg[0]), CellReference_moveHorizontal(amount, tupledArg[1])];
+  return Range_ofBoundaries(tupledArg_1[0], tupledArg_1[1]);
+}
+function Range_extendRight(amount, area) {
+  let tupledArg_1;
+  const tupledArg = Range_toBoundaries(area);
+  tupledArg_1 = [tupledArg[0], CellReference_moveHorizontal(amount, tupledArg[1])];
+  return Range_ofBoundaries(tupledArg_1[0], tupledArg_1[1]);
+}
+function Range_extendLeft(amount, area) {
+  let tupledArg_1;
+  const tupledArg = Range_toBoundaries(area);
+  tupledArg_1 = [CellReference_moveHorizontal(amount, tupledArg[0]), tupledArg[1]];
+  return Range_ofBoundaries(tupledArg_1[0], tupledArg_1[1]);
+}
+function Range_referenceExceedsAreaRight(reference, area) {
+  return CellReference_toIndices(reference)[0] > Range_rightBoundary(area);
+}
+function Range_referenceExceedsAreaLeft(reference, area) {
+  return CellReference_toIndices(reference)[0] < Range_leftBoundary(area);
+}
+function Range_referenceExceedsAreaAbove(reference, area) {
+  return CellReference_toIndices(reference)[1] > Range_upperBoundary(area);
+}
+function Range_referenceExceedsAreaBelow(reference, area) {
+  return CellReference_toIndices(reference)[1] < Range_lowerBoundary(area);
+}
+function Range_referenceExceedsArea(reference, area) {
+  if ((Range_referenceExceedsAreaRight(reference, area) ? true : Range_referenceExceedsAreaLeft(reference, area)) ? true : Range_referenceExceedsAreaAbove(reference, area)) {
+    return true;
+  } else {
+    return Range_referenceExceedsAreaBelow(reference, area);
+  }
+}
+function Range_isCorrect(area) {
+  try {
+    const hor = Range_leftBoundary(area) <= Range_rightBoundary(area);
+    const ver = Range_upperBoundary(area) <= Range_lowerBoundary(area);
+    if (!hor) {
+      toConsole(printf("Right area boundary must be higher or equal to left area boundary."));
+    }
+    if (!ver) {
+      toConsole(printf("Lower area boundary must be higher or equal to upper area boundary."));
+    }
+    return hor && ver;
+  } catch (err) {
+    const arg_1 = err.message;
+    toConsole(printf('Area "%s" could not be parsed: %s'))(area)(arg_1);
+    return false;
+  }
+}
+
+export { FsRangeAddress, FsRangeAddress_$ctor_7E77A4A0, FsRangeAddress_$reflection, Range_extendLeft, Range_extendRight, Range_isCorrect, Range_leftBoundary, Range_lowerBoundary, Range_moveHorizontal, Range_moveVertical, Range_ofBoundaries, Range_referenceExceedsArea, Range_referenceExceedsAreaAbove, Range_referenceExceedsAreaBelow, Range_referenceExceedsAreaLeft, Range_referenceExceedsAreaRight, Range_rightBoundary, Range_toBoundaries, Range_upperBoundary };

package/dist/ts/ts/fable_modules/FsSpreadsheet.7.0.0-alpha.1/Ranges/FsRangeBase.fs.js

@@ -0,0 +1,78 @@
+import { FsAddress } from '../FsAddress.fs.js';
+import { defaultOf, equals } from '../../../../node_modules/@fable-org/fable-library-js/Util.js';
+import { toFail, printf } from '../../../../node_modules/@fable-org/fable-library-js/String.js';
+import { value } from '../../../../node_modules/@fable-org/fable-library-js/Option.js';
+import { FsCell } from '../Cells/FsCell.fs.js';
+import { class_type } from '../../../../node_modules/@fable-org/fable-library-js/Reflection.js';
+
+class FsRangeBase {
+  constructor(rangeAddress) {
+    this._sortRows = defaultOf();
+    this._sortColumns = defaultOf();
+    this._rangeAddress = rangeAddress;
+    let _id;
+    FsRangeBase.IdCounter = FsRangeBase.IdCounter + 1 | 0;
+    _id = FsRangeBase.IdCounter;
+  }
+  Extend(address) {
+    const this$ = this;
+    this$._rangeAddress.Extend(address);
+  }
+  get RangeAddress() {
+    const this$ = this;
+    return this$._rangeAddress;
+  }
+  set RangeAddress(rangeAdress) {
+    const this$ = this;
+    if (!equals(rangeAdress, this$._rangeAddress)) {
+      const oldAddress = this$._rangeAddress;
+      this$._rangeAddress = rangeAdress;
+    }
+  }
+  Cell(cellAddressInRange, cells) {
+    const this$ = this;
+    const absRow = cellAddressInRange.RowNumber + this$.RangeAddress.FirstAddress.RowNumber - 1 | 0;
+    const absColumn = cellAddressInRange.ColumnNumber + this$.RangeAddress.FirstAddress.ColumnNumber - 1 | 0;
+    if (absRow <= 0 ? true : absRow > 1048576) {
+      const arg = cells.MaxRowNumber | 0;
+      toFail(printf("Row number must be between 1 and %i"))(arg);
+    }
+    if (absColumn <= 0 ? true : absColumn > 16384) {
+      const arg_1 = cells.MaxColumnNumber | 0;
+      toFail(printf("Column number must be between 1 and %i"))(arg_1);
+    }
+    const cell = cells.TryGetCell(absRow, absColumn);
+    if (cell == null) {
+      const absoluteAddress = new FsAddress(absRow, absColumn, cellAddressInRange.FixedRow, cellAddressInRange.FixedColumn);
+      const newCell = FsCell.createEmptyWithAdress(absoluteAddress);
+      this$.Extend(absoluteAddress);
+      const value = cells.Add(newCell, absRow, absColumn);
+      return newCell;
+    } else {
+      return value(cell);
+    }
+  }
+  Cells(cells) {
+    const this$ = this;
+    return cells.GetCellsInStringRange(this$.RangeAddress.FirstAddress, this$.RangeAddress.LastAddress);
+  }
+  ColumnCount() {
+    const this$ = this;
+    return this$._rangeAddress.LastAddress.ColumnNumber - this$._rangeAddress.FirstAddress.ColumnNumber + 1 | 0;
+  }
+  RowCount() {
+    const this$ = this;
+    return this$._rangeAddress.LastAddress.RowNumber - this$._rangeAddress.FirstAddress.RowNumber + 1 | 0;
+  }
+}
+function FsRangeBase_$reflection() {
+  return class_type("FsSpreadsheet.FsRangeBase", void 0, FsRangeBase);
+}
+function FsRangeBase_$ctor_6A2513BC(rangeAddress) {
+  return new FsRangeBase(rangeAddress);
+}
+(() => {
+  FsRangeBase.IdCounter = 0;
+})();
+
+export { FsRangeBase, FsRangeBase_$ctor_6A2513BC, FsRangeBase_$reflection };

package/dist/ts/ts/fable_modules/FsSpreadsheet.7.0.0-alpha.1/Ranges/FsRangeColumn.fs.js

@@ -0,0 +1,57 @@
+import { FsRangeAddress } from './FsRangeAddress.fs.js';
+import { FsAddress } from '../FsAddress.fs.js';
+import { FsRangeBase, FsRangeBase_$reflection } from './FsRangeBase.fs.js';
+import { class_type } from '../../../../node_modules/@fable-org/fable-library-js/Reflection.js';
+import { toList, map } from '../../../../node_modules/@fable-org/fable-library-js/Seq.js';
+import { rangeDouble } from '../../../../node_modules/@fable-org/fable-library-js/Range.js';
+
+class FsRangeColumn extends FsRangeBase {
+  constructor(rangeAddress) {
+    super(rangeAddress);
+  }
+  static fromIndex(index) {
+    return new FsRangeColumn(new FsRangeAddress(new FsAddress(0, index), new FsAddress(0, index)));
+  }
+  get Index() {
+    const self = this;
+    return self.RangeAddress.FirstAddress.ColumnNumber | 0;
+  }
+  set Index(i) {
+    const self = this;
+    self.RangeAddress.FirstAddress.ColumnNumber = i | 0;
+    self.RangeAddress.LastAddress.ColumnNumber = i | 0;
+  }
+  Cell(rowIndex, cellsCollection) {
+    return super.Cell(new FsAddress(rowIndex - super.RangeAddress.FirstAddress.RowNumber + 1, 1), cellsCollection);
+  }
+  FirstCell(cells) {
+    return super.Cell(new FsAddress(1, 1), cells);
+  }
+  Cells(cellsCollection) {
+    return super.Cells(cellsCollection);
+  }
+  static fromRangeAddress(rangeAddress) {
+    return new FsRangeColumn(rangeAddress);
+  }
+  Copy() {
+    const self = this;
+    return new FsRangeColumn(self.RangeAddress.Copy());
+  }
+  static copy(rangeColumn) {
+    return rangeColumn.Copy();
+  }
+}
+function FsRangeColumn_$reflection() {
+  return class_type("FsSpreadsheet.FsRangeColumn", void 0, FsRangeColumn, FsRangeBase_$reflection());
+}
+function FsRangeColumn_$ctor_6A2513BC(rangeAddress) {
+  return new FsRangeColumn(rangeAddress);
+}
+function FsSpreadsheet_FsRangeAddress__FsRangeAddress_toRangeColumns_Static_6A2513BC(rangeAddress) {
+  const columns = toList(rangeDouble(rangeAddress.FirstAddress.ColumnNumber, 1, rangeAddress.LastAddress.ColumnNumber));
+  const fstRow = rangeAddress.FirstAddress.RowNumber | 0;
+  const lstRow = rangeAddress.LastAddress.RowNumber | 0;
+  return map((c) => new FsRangeColumn(new FsRangeAddress(new FsAddress(fstRow, c), new FsAddress(lstRow, c))), columns);
+}
+
+export { FsRangeColumn, FsRangeColumn_$ctor_6A2513BC, FsRangeColumn_$reflection, FsSpreadsheet_FsRangeAddress__FsRangeAddress_toRangeColumns_Static_6A2513BC };

package/dist/ts/ts/fable_modules/FsSpreadsheet.7.0.0-alpha.1/Ranges/FsRangeRow.fs.js

@@ -0,0 +1,36 @@
+import { FsRangeAddress } from './FsRangeAddress.fs.js';
+import { FsAddress } from '../FsAddress.fs.js';
+import { FsRangeBase, FsRangeBase_$reflection } from './FsRangeBase.fs.js';
+import { class_type } from '../../../../node_modules/@fable-org/fable-library-js/Reflection.js';
+
+class FsRangeRow extends FsRangeBase {
+  constructor(rangeAddress) {
+    super(rangeAddress);
+  }
+  static fromIndex(index) {
+    return new FsRangeRow(new FsRangeAddress(new FsAddress(index, 0), new FsAddress(index, 0)));
+  }
+  get Index() {
+    const self = this;
+    return self.RangeAddress.FirstAddress.RowNumber | 0;
+  }
+  set Index(i) {
+    const self = this;
+    self.RangeAddress.FirstAddress.RowNumber = i | 0;
+    self.RangeAddress.LastAddress.RowNumber = i | 0;
+  }
+  Cell(columnIndex, cells) {
+    return super.Cell(new FsAddress(1, columnIndex - super.RangeAddress.FirstAddress.ColumnNumber + 1), cells);
+  }
+  Cells(cells) {
+    return super.Cells(cells);
+  }
+}
+function FsRangeRow_$reflection() {
+  return class_type("FsSpreadsheet.FsRangeRow", void 0, FsRangeRow, FsRangeBase_$reflection());
+}
+function FsRangeRow_$ctor_6A2513BC(rangeAddress) {
+  return new FsRangeRow(rangeAddress);
+}
+
+export { FsRangeRow, FsRangeRow_$ctor_6A2513BC, FsRangeRow_$reflection };