@nfdi4plants/arctrl 3.0.0-alpha.4 → 3.0.0-beta.10

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

@@ -0,0 +1,429 @@
+import { FsCellsCollection } from './Cells/FsCellsCollection.fs.js';
+import { FsTable } from './Tables/FsTable.fs.js';
+import { FsRow } from './FsRow.fs.js';
+import { map, sortBy, head, last, iterate, tryFind, find, exists, filter, maxBy, empty } from '../../../node_modules/@fable-org/fable-library-js/Seq.js';
+import { FsColumn } from './FsColumn.fs.js';
+import { FsCell } from './Cells/FsCell.fs.js';
+import { comparePrimitives, numberHash, getEnumerator, disposeSafe, safeHash, equals, clear } from '../../../node_modules/@fable-org/fable-library-js/Util.js';
+import { FsAddress } from './FsAddress.fs.js';
+import { FsRangeAddress } from './Ranges/FsRangeAddress.fs.js';
+import { groupBy } from '../../../node_modules/@fable-org/fable-library-js/Seq2.js';
+import { defaultArg, value } from '../../../node_modules/@fable-org/fable-library-js/Option.js';
+import { toFail, printf, toConsole } from '../../../node_modules/@fable-org/fable-library-js/String.js';
+import { removeInPlace, addRangeInPlace } from '../../../node_modules/@fable-org/fable-library-js/Array.js';
+import { ofSeq, tryFind as tryFind$1 } from '../../../node_modules/@fable-org/fable-library-js/Map.js';
+import { iterate as iterate$1 } from '../../../node_modules/@fable-org/fable-library-js/List.js';
+import { class_type } from '../../../node_modules/@fable-org/fable-library-js/Reflection.js';
+
+class FsWorksheet {
+  constructor(name, fsRows, fsTables, fsCellsCollection) {
+    this.name = name;
+    this._name = this.name;
+    this._rows = defaultArg(fsRows, []);
+    this._tables = defaultArg(fsTables, []);
+    this._cells = defaultArg(fsCellsCollection, new FsCellsCollection());
+  }
+  static init(name) {
+    return new FsWorksheet(name, [], [], new FsCellsCollection());
+  }
+  get Name() {
+    const self = this;
+    return self._name;
+  }
+  set Name(name) {
+    const self = this;
+    self._name = name;
+  }
+  get CellCollection() {
+    const self = this;
+    return self._cells;
+  }
+  get Tables() {
+    const self = this;
+    return self._tables;
+  }
+  get Rows() {
+    const self = this;
+    return self._rows;
+  }
+  get Columns() {
+    const self = this;
+    return map((tupledArg) => {
+      let tupledArg_1, cells_1, c_2, c_3;
+      const columnIndex = tupledArg[0] | 0;
+      return new FsColumn((tupledArg_1 = (cells_1 = sortBy((c_1) => c_1.RowNumber, tupledArg[1], {
+        Compare: comparePrimitives
+      }), [new FsAddress((c_2 = head(cells_1), c_2.RowNumber), columnIndex), new FsAddress((c_3 = last(cells_1), c_3.RowNumber), columnIndex)]), new FsRangeAddress(tupledArg_1[0], tupledArg_1[1])), self.CellCollection);
+    }, groupBy((c) => c.ColumnNumber, self._cells.GetCells(), {
+      Equals: (x, y) => x === y,
+      GetHashCode: numberHash
+    }));
+  }
+  get MaxRowIndex() {
+    const this$ = this;
+    return this$.CellCollection.MaxRowNumber | 0;
+  }
+  get MaxColumnIndex() {
+    const this$ = this;
+    return this$.CellCollection.MaxColumnNumber | 0;
+  }
+  Copy() {
+    let n, n_1;
+    const self = this;
+    const fcc = self.CellCollection.Copy();
+    return new FsWorksheet(self.Name, (n = [], iterate((r) => {
+      const item = r.Copy();
+      void n.push(item);
+    }, self.Rows), n), (n_1 = [], iterate((t) => {
+      const item_1 = t.Copy();
+      void n_1.push(item_1);
+    }, self.Tables), n_1), fcc);
+  }
+  static copy(sheet) {
+    return sheet.Copy();
+  }
+  Row(rowIndex, SkipSearch) {
+    const self = this;
+    if (defaultArg(SkipSearch, false)) {
+      const row = FsRow.createAt(rowIndex, self.CellCollection);
+      void self._rows.push(row);
+      return row;
+    } else {
+      const matchValue = tryFind((row_1) => row_1.Index === rowIndex, self._rows);
+      if (matchValue == null) {
+        const row_3 = FsRow.createAt(rowIndex, self.CellCollection);
+        void self._rows.push(row_3);
+        return row_3;
+      } else {
+        return value(matchValue);
+      }
+    }
+  }
+  RowWithRange(rangeAddress, SkipSearch) {
+    const self = this;
+    const skipSearch = defaultArg(SkipSearch, false);
+    if (rangeAddress.FirstAddress.RowNumber !== rangeAddress.LastAddress.RowNumber) {
+      toFail(printf("Row may not have a range address spanning over different row indices"));
+    }
+    if (skipSearch) {
+      const row = new FsRow(rangeAddress, self.CellCollection);
+      row.RangeAddress = rangeAddress;
+      void self._rows.push(row);
+      return row;
+    } else {
+      const row_1 = self.Row(rangeAddress.FirstAddress.RowNumber);
+      row_1.RangeAddress = rangeAddress;
+      return row_1;
+    }
+  }
+  static appendRow(row, sheet) {
+    sheet.Row(row.Index);
+    return sheet;
+  }
+  static getRows(sheet) {
+    return sheet.Rows;
+  }
+  static getRowAt(rowIndex, sheet) {
+    return find((arg) => rowIndex === FsRow.getIndex(arg), FsWorksheet.getRows(sheet));
+  }
+  static tryGetRowAt(rowIndex, sheet) {
+    return tryFind((arg) => rowIndex === FsRow.getIndex(arg), sheet.Rows);
+  }
+  static tryGetRowAfter(rowIndex, sheet) {
+    return tryFind((r) => r.Index >= rowIndex, sheet.Rows);
+  }
+  InsertBefore(row, refRow) {
+    const self = this;
+    let enumerator = getEnumerator(self._rows);
+    try {
+      while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+        const row_1 = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+        if (row_1.Index >= refRow.Index) {
+          row_1.Index = row_1.Index + 1 | 0;
+        }
+      }
+    } finally {
+      disposeSafe(enumerator);
+    }
+    self.Row(row.Index);
+    return self;
+  }
+  static insertBefore(row, refRow, sheet) {
+    return sheet.InsertBefore(row, refRow);
+  }
+  ContainsRowAt(rowIndex) {
+    const self = this;
+    return exists((t) => t.Index === rowIndex, self.Rows);
+  }
+  static containsRowAt(rowIndex, sheet) {
+    return sheet.ContainsRowAt(rowIndex);
+  }
+  static countRows(sheet) {
+    return sheet.Rows.length;
+  }
+  RemoveRowAt(rowIndex) {
+    const self = this;
+    const enumerator = getEnumerator(filter((r) => r.Index === rowIndex, self._rows));
+    try {
+      while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+        removeInPlace(enumerator["System.Collections.Generic.IEnumerator`1.get_Current"](), self._rows, {
+          Equals: equals,
+          GetHashCode: safeHash
+        });
+      }
+    } finally {
+      disposeSafe(enumerator);
+    }
+  }
+  static removeRowAt(rowIndex, sheet) {
+    sheet.RemoveRowAt(rowIndex);
+    return sheet;
+  }
+  TryRemoveAt(rowIndex) {
+    const self = this;
+    if (self.ContainsRowAt(rowIndex)) {
+      self.RemoveRowAt(rowIndex);
+    }
+    return self;
+  }
+  static tryRemoveAt(rowIndex, sheet) {
+    if (FsWorksheet.containsRowAt(rowIndex, sheet)) {
+      sheet.RemoveRowAt(rowIndex);
+    }
+  }
+  SortRows() {
+    const self = this;
+    const sorted = Array.from(sortBy((r) => r.Index, self._rows, {
+      Compare: comparePrimitives
+    }));
+    clear(self._rows);
+    addRangeInPlace(sorted, self._rows);
+  }
+  MapRowsInPlace(f) {
+    const self = this;
+    for (let i = 0; i <= self._rows.length - 1; i++) {
+      const r = self._rows[i];
+      self._rows[i] = f(r);
+    }
+    return self;
+  }
+  static mapRowsInPlace(f, sheet) {
+    return sheet.MapRowsInPlace(f);
+  }
+  GetMaxRowIndex() {
+    const self = this;
+    if (self.Rows.length === 0) {
+      throw new Error("The FsWorksheet has no FsRows.");
+    }
+    return maxBy((r) => r.Index, self.Rows, {
+      Compare: comparePrimitives
+    });
+  }
+  static getMaxRowIndex(sheet) {
+    return sheet.GetMaxRowIndex();
+  }
+  GetRowValuesAt(rowIndex) {
+    const self = this;
+    return self.ContainsRowAt(rowIndex) ? map((c) => c.Value, self.Row(rowIndex).Cells) : empty();
+  }
+  static getRowValuesAt(rowIndex, sheet) {
+    return sheet.GetRowValuesAt(rowIndex);
+  }
+  TryGetRowValuesAt(rowIndex) {
+    const self = this;
+    return self.ContainsRowAt(rowIndex) ? self.GetRowValuesAt(rowIndex) : void 0;
+  }
+  static tryGetRowValuesAt(rowIndex, sheet) {
+    return sheet.TryGetRowValuesAt(rowIndex);
+  }
+  RescanRows() {
+    const self = this;
+    const rows = ofSeq(map((r) => [r.Index, r], self._rows), {
+      Compare: comparePrimitives
+    });
+    iterate((tupledArg) => {
+      const rowIndex = tupledArg[0] | 0;
+      let min = 1;
+      let max = 1;
+      iterate((c_1) => {
+        const cn = c_1.ColumnNumber | 0;
+        if (cn < min) {
+          min = cn | 0;
+        }
+        if (cn > max) {
+          max = cn | 0;
+        }
+      }, tupledArg[1]);
+      const newRange = new FsRangeAddress(new FsAddress(rowIndex, min), new FsAddress(rowIndex, max));
+      const matchValue = tryFind$1(rowIndex, rows);
+      if (matchValue == null) {
+        self.RowWithRange(newRange, true);
+      } else {
+        const row = value(matchValue);
+        row.RangeAddress = newRange;
+      }
+    }, groupBy((c) => c.RowNumber, self._cells.GetCells(), {
+      Equals: (x_1, y_1) => x_1 === y_1,
+      GetHashCode: numberHash
+    }));
+  }
+  Column(columnIndex) {
+    const self = this;
+    return FsColumn.createAt(columnIndex, self.CellCollection);
+  }
+  ColumnWithRange(rangeAddress) {
+    const self = this;
+    if (rangeAddress.FirstAddress.ColumnNumber !== rangeAddress.LastAddress.ColumnNumber) {
+      toFail(printf("Column may not have a range address spanning over different column indices"));
+    }
+    self.Column(rangeAddress.FirstAddress.ColumnNumber).RangeAddress = rangeAddress;
+  }
+  static getColumns(sheet) {
+    return sheet.Columns;
+  }
+  static getColumnAt(columnIndex, sheet) {
+    return find((arg) => columnIndex === FsColumn.getIndex(arg), FsWorksheet.getColumns(sheet));
+  }
+  static tryGetColumnAt(columnIndex, sheet) {
+    return tryFind((arg) => columnIndex === FsColumn.getIndex(arg), sheet.Columns);
+  }
+  Table(tableName, rangeAddress, showHeaderRow) {
+    const self = this;
+    const showHeaderRow_1 = defaultArg(showHeaderRow, true);
+    const matchValue = tryFind((table) => table.Name === self.name, self._tables);
+    if (matchValue == null) {
+      const table_2 = new FsTable(tableName, rangeAddress, showHeaderRow_1);
+      void self._tables.push(table_2);
+      return table_2;
+    } else {
+      return value(matchValue);
+    }
+  }
+  static tryGetTableByName(tableName, sheet) {
+    return tryFind((t) => t.Name === tableName, sheet.Tables);
+  }
+  static getTableByName(tableName, sheet) {
+    try {
+      return value(tryFind((t) => t.Name === tableName, sheet.Tables));
+    } catch (matchValue) {
+      throw new Error(`FsTable with name ${tableName} is not presen in the FsWorksheet ${sheet.Name}.`);
+    }
+  }
+  AddTable(table) {
+    const self = this;
+    if (exists((t) => t.Name === table.Name, self.Tables)) {
+      toConsole(`FsTable ${table.Name} could not be appended as an FsTable with this name is already present in the FsWorksheet ${self.Name}.`);
+    } else {
+      void self._tables.push(table);
+    }
+    return self;
+  }
+  static addTable(table, sheet) {
+    return sheet.AddTable(table);
+  }
+  AddTables(tables) {
+    const self = this;
+    iterate$1((arg) => {
+      self.AddTable(arg);
+    }, tables);
+    return self;
+  }
+  static addTables(tables, sheet) {
+    return sheet.AddTables(tables);
+  }
+  TryGetCellAt(rowIndex, colIndex) {
+    const self = this;
+    return self.CellCollection.TryGetCell(rowIndex, colIndex);
+  }
+  static tryGetCellAt(rowIndex, colIndex, sheet) {
+    return sheet.TryGetCellAt(rowIndex, colIndex);
+  }
+  GetCellAt(rowIndex, colIndex) {
+    const self = this;
+    return value(self.TryGetCellAt(rowIndex, colIndex));
+  }
+  static getCellAt(rowIndex, colIndex, sheet) {
+    return sheet.GetCellAt(rowIndex, colIndex);
+  }
+  AddCell(cell) {
+    const self = this;
+    const value = self.CellCollection.Add(cell);
+    return self;
+  }
+  AddCells(cells) {
+    const self = this;
+    const value = self.CellCollection.AddMany(cells);
+    return self;
+  }
+  InsertValueAt(value, rowIndex, colIndex) {
+    const self = this;
+    const cell = new FsCell(value);
+    self.CellCollection.Add(cell, rowIndex, colIndex);
+  }
+  static insertValueAt(value, rowIndex, colIndex, sheet) {
+    sheet.InsertValueAt(value, rowIndex, colIndex);
+  }
+  SetValueAt(value$1, rowIndex, colIndex) {
+    const self = this;
+    const matchValue = self.CellCollection.TryGetCell(rowIndex, colIndex);
+    if (matchValue == null) {
+      const value_2 = self.CellCollection.Add(value$1, rowIndex, colIndex);
+      return self;
+    } else {
+      const c = value(matchValue);
+      const value_1 = c.SetValueAs(value$1);
+      return self;
+    }
+  }
+  static setValueAt(value, rowIndex, colIndex, sheet) {
+    return sheet.SetValueAt(value, rowIndex, colIndex);
+  }
+  RemoveCellAt(rowIndex, colIndex) {
+    const self = this;
+    self.CellCollection.RemoveCellAt(rowIndex, colIndex);
+    return self;
+  }
+  static removeCellAt(rowIndex, colIndex, sheet) {
+    return sheet.RemoveCellAt(rowIndex, colIndex);
+  }
+  TryRemoveValueAt(rowIndex, colIndex) {
+    const self = this;
+    self.CellCollection.TryRemoveValueAt(rowIndex, colIndex);
+  }
+  static tryRemoveValueAt(rowIndex, colIndex, sheet) {
+    sheet.TryRemoveValueAt(rowIndex, colIndex);
+  }
+  RemoveValueAt(rowIndex, colIndex) {
+    const self = this;
+    self.CellCollection.RemoveValueAt(rowIndex, colIndex);
+  }
+  static removeValueAt(rowIndex, colIndex, sheet) {
+    sheet.RemoveValueAt(rowIndex, colIndex);
+  }
+  static addCell(cell, sheet) {
+    return sheet.AddCell(cell);
+  }
+  static addCells(cell, sheet) {
+    return sheet.AddCells(cell);
+  }
+  static validateForWrite(ws) {
+    try {
+      iterate((t) => {
+        const cellsCollection = ws.CellCollection;
+        FsTable.validateForWrite(t, cellsCollection);
+      }, ws.Tables);
+    } catch (ex) {
+      const arg = ws.Name;
+      const arg_1 = ex.message;
+      toFail(printf("FsWorksheet %s could not be validated for writing to xlsx file. %s"))(arg)(arg_1);
+    }
+  }
+}
+function FsWorksheet_$reflection() {
+  return class_type("FsSpreadsheet.FsWorksheet", void 0, FsWorksheet);
+}
+function FsWorksheet_$ctor_7FDA5F7A(name, fsRows, fsTables, fsCellsCollection) {
+  return new FsWorksheet(name, fsRows, fsTables, fsCellsCollection);
+}
+
+export { FsWorksheet, FsWorksheet_$ctor_7FDA5F7A, FsWorksheet_$reflection };

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

@@ -0,0 +1,35 @@
+import { year, month, day, hour, minute, second } from '../../../node_modules/@fable-org/fable-library-js/Date.js';
+import { identityHash, numberHash } from '../../../node_modules/@fable-org/fable-library-js/Util.js';
+import { value } from '../../../node_modules/@fable-org/fable-library-js/Option.js';
+import { fold } from '../../../node_modules/@fable-org/fable-library-js/Array.js';
+import { fold as fold$1 } from '../../../node_modules/@fable-org/fable-library-js/Seq.js';
+
+function mergeHashes(hash1, hash2) {
+  return -1640531527 + hash2 + (hash1 << 6) + (hash1 >> 2);
+}
+function hashDateTime(dt) {
+  let acc = 0;
+  acc = mergeHashes(acc, year(dt)) | 0;
+  acc = mergeHashes(acc, month(dt)) | 0;
+  acc = mergeHashes(acc, day(dt)) | 0;
+  acc = mergeHashes(acc, hour(dt)) | 0;
+  acc = mergeHashes(acc, minute(dt)) | 0;
+  acc = mergeHashes(acc, second(dt)) | 0;
+  return acc | 0;
+}
+function hash(obj) {
+  let copyOfStruct = obj;
+  return identityHash(copyOfStruct) | 0;
+}
+function boxHashOption(a) {
+  let copyOfStruct, copyOfStruct_1;
+  return a != null ? (copyOfStruct = value(a), identityHash(copyOfStruct)) : (copyOfStruct_1 = 0, numberHash(copyOfStruct_1));
+}
+function boxHashArray(a) {
+  return fold((acc, o) => mergeHashes(acc, hash(o)), 0, a);
+}
+function boxHashSeq(a) {
+  return fold$1((acc, o) => mergeHashes(acc, hash(o)), 0, a);
+}
+
+export { boxHashArray, boxHashOption, boxHashSeq, hash, hashDateTime, mergeHashes };

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

@@ -0,0 +1,65 @@
+import { encode, decode } from './Value.fs.js';
+import { map } from '../../../../node_modules/@fable-org/fable-library-js/Seq.js';
+import { DataType_Empty, FsCell } from '../Cells/FsCell.fs.js';
+import { object, int } from '../../Thoth.Json.Core.0.7.0/Decode.fs.js';
+import { defaultArg } from '../../../../node_modules/@fable-org/fable-library-js/Option.js';
+import { FsAddress } from '../FsAddress.fs.js';
+
+function encodeNoNumber(cell) {
+  const values = [["value", encode(cell.Value)]];
+  return {
+    Encode(helpers) {
+      const arg = map((tupledArg) => [tupledArg[0], tupledArg[1].Encode(helpers)], values);
+      return helpers.encodeObject(arg);
+    }
+  };
+}
+function encodeRows(cell) {
+  let value_1;
+  const values = [["column", (value_1 = cell.ColumnNumber | 0, {
+    Encode(helpers) {
+      return helpers.encodeSignedIntegralNumber(value_1);
+    }
+  })], ["value", encode(cell.Value)]];
+  return {
+    Encode(helpers_1) {
+      const arg = map((tupledArg) => [tupledArg[0], tupledArg[1].Encode(helpers_1)], values);
+      return helpers_1.encodeObject(arg);
+    }
+  };
+}
+function decodeRows(rowNumber) {
+  return object((builder) => {
+    let objectArg, objectArg_1;
+    let patternInput;
+    const value_1 = ["", DataType_Empty()];
+    patternInput = defaultArg((objectArg = builder.Optional, objectArg.Field("value", decode)), value_1);
+    const c = defaultArg((objectArg_1 = builder.Optional, objectArg_1.Field("column", int)), 0) | 0;
+    return new FsCell(patternInput[0], patternInput[1], new FsAddress(defaultArg(rowNumber, 0), c));
+  });
+}
+function encodeCols(cell) {
+  let value_1;
+  const values = [["row", (value_1 = cell.RowNumber | 0, {
+    Encode(helpers) {
+      return helpers.encodeSignedIntegralNumber(value_1);
+    }
+  })], ["value", encode(cell.Value)]];
+  return {
+    Encode(helpers_1) {
+      const arg = map((tupledArg) => [tupledArg[0], tupledArg[1].Encode(helpers_1)], values);
+      return helpers_1.encodeObject(arg);
+    }
+  };
+}
+function decodeCols(colNumber) {
+  return object((builder) => {
+    let objectArg, objectArg_1;
+    let patternInput;
+    const value_1 = ["", DataType_Empty()];
+    patternInput = defaultArg((objectArg = builder.Optional, objectArg.Field("value", decode)), value_1);
+    return new FsCell(patternInput[0], patternInput[1], new FsAddress(defaultArg((objectArg_1 = builder.Optional, objectArg_1.Field("row", int)), 0), defaultArg(colNumber, 0)));
+  });
+}
+
+export { decodeCols, decodeRows, encodeCols, encodeNoNumber, encodeRows };

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

@@ -0,0 +1,38 @@
+import { seq } from '../../Thoth.Json.Core.0.7.0/Encode.fs.js';
+import { map, empty } from '../../../../node_modules/@fable-org/fable-library-js/Seq.js';
+import { encodeCols, encodeNoNumber, decodeCols } from './Cell.fs.js';
+import { object, int, seq as seq$1 } from '../../Thoth.Json.Core.0.7.0/Decode.fs.js';
+import { defaultArg } from '../../../../node_modules/@fable-org/fable-library-js/Option.js';
+
+function encode(col) {
+  let value;
+  const values = [["number", (value = col.Index | 0, {
+    Encode(helpers) {
+      return helpers.encodeSignedIntegralNumber(value);
+    }
+  })], ["cells", seq(map(encodeCols, col.Cells))]];
+  return {
+    Encode(helpers_1) {
+      const arg = map((tupledArg) => [tupledArg[0], tupledArg[1].Encode(helpers_1)], values);
+      return helpers_1.encodeObject(arg);
+    }
+  };
+}
+function encodeNoNumbers(col) {
+  const values = [["cells", seq(map(encodeNoNumber, col))]];
+  return {
+    Encode(helpers) {
+      const arg = map((tupledArg) => [tupledArg[0], tupledArg[1].Encode(helpers)], values);
+      return helpers.encodeObject(arg);
+    }
+  };
+}
+const decode = object((builder) => {
+  let arg_3, objectArg_1;
+  let n;
+  const objectArg = builder.Optional;
+  n = objectArg.Field("number", int);
+  return [n, defaultArg((arg_3 = seq$1(decodeCols(n)), objectArg_1 = builder.Optional, objectArg_1.Field("cells", arg_3)), empty())];
+});
+
+export { decode, encode, encodeNoNumbers };

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

@@ -0,0 +1,38 @@
+import { seq } from '../../Thoth.Json.Core.0.7.0/Encode.fs.js';
+import { map, empty } from '../../../../node_modules/@fable-org/fable-library-js/Seq.js';
+import { encodeRows, encodeNoNumber, decodeRows } from './Cell.fs.js';
+import { object, int, seq as seq$1 } from '../../Thoth.Json.Core.0.7.0/Decode.fs.js';
+import { defaultArg } from '../../../../node_modules/@fable-org/fable-library-js/Option.js';
+
+function encode(row) {
+  let value;
+  const values = [["number", (value = row.Index | 0, {
+    Encode(helpers) {
+      return helpers.encodeSignedIntegralNumber(value);
+    }
+  })], ["cells", seq(map(encodeRows, row.Cells))]];
+  return {
+    Encode(helpers_1) {
+      const arg = map((tupledArg) => [tupledArg[0], tupledArg[1].Encode(helpers_1)], values);
+      return helpers_1.encodeObject(arg);
+    }
+  };
+}
+function encodeNoNumbers(row) {
+  const values = [["cells", seq(map(encodeNoNumber, row))]];
+  return {
+    Encode(helpers) {
+      const arg = map((tupledArg) => [tupledArg[0], tupledArg[1].Encode(helpers)], values);
+      return helpers.encodeObject(arg);
+    }
+  };
+}
+const decode = object((builder) => {
+  let arg_3, objectArg_1;
+  let n;
+  const objectArg = builder.Optional;
+  n = objectArg.Field("number", int);
+  return [n, defaultArg((arg_3 = seq$1(decodeRows(n)), objectArg_1 = builder.Optional, objectArg_1.Field("cells", arg_3)), empty())];
+});
+
+export { decode, encode, encodeNoNumbers };

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

@@ -0,0 +1,34 @@
+import { map } from '../../../../node_modules/@fable-org/fable-library-js/Seq.js';
+import { FsTable } from '../Tables/FsTable.fs.js';
+import { object, string } from '../../Thoth.Json.Core.0.7.0/Decode.fs.js';
+import { FsRangeAddress } from '../Ranges/FsRangeAddress.fs.js';
+
+function encode(sheet) {
+  let value, value_1;
+  const values = [["name", (value = sheet.Name, {
+    Encode(helpers) {
+      return helpers.encodeString(value);
+    }
+  })], ["range", (value_1 = sheet.RangeAddress.Range, {
+    Encode(helpers_1) {
+      return helpers_1.encodeString(value_1);
+    }
+  })]];
+  return {
+    Encode(helpers_2) {
+      const arg = map((tupledArg) => [tupledArg[0], tupledArg[1].Encode(helpers_2)], values);
+      return helpers_2.encodeObject(arg);
+    }
+  };
+}
+const decode = object((builder) => {
+  let n;
+  const objectArg = builder.Required;
+  n = objectArg.Field("name", string);
+  let r;
+  const objectArg_1 = builder.Required;
+  r = objectArg_1.Field("range", string);
+  return new FsTable(n, FsRangeAddress.fromString(r));
+});
+
+export { decode, encode };