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

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

@@ -0,0 +1,355 @@
+import { equals, defaultOf, int32ToString, comparePrimitives, getEnumerator, disposeSafe } from '../../../../node_modules/@fable-org/fable-library-js/Util.js';
+import { Dictionary_tryGet } from '../Cells/FsCellsCollection.fs.js';
+import { FsTableField } from './FsTableField.fs.js';
+import { length, iterateIndexed, initialize, delay, collect, singleton, reduce, map, iterate, max, find, tryFind, tryPick, choose, toList, exists } from '../../../../node_modules/@fable-org/fable-library-js/Seq.js';
+import { FsRange } from '../Ranges/FsRange.fs.js';
+import { FsRow } from '../FsRow.fs.js';
+import { FsRangeAddress } from '../Ranges/FsRangeAddress.fs.js';
+import { FsAddress } from '../FsAddress.fs.js';
+import { defaultArg, value, some } from '../../../../node_modules/@fable-org/fable-library-js/Option.js';
+import { FsColumn } from '../FsColumn.fs.js';
+import { rangeDouble } from '../../../../node_modules/@fable-org/fable-library-js/Range.js';
+import { replace, toText, printf } from '../../../../node_modules/@fable-org/fable-library-js/String.js';
+import { addToDict, addToSet, getItemFromDict } from '../../../../node_modules/@fable-org/fable-library-js/MapUtil.js';
+import { FsRangeColumn } from '../Ranges/FsRangeColumn.fs.js';
+import { DataType_String } from '../Cells/FsCell.fs.js';
+import { FsRangeBase, FsRangeBase_$reflection } from '../Ranges/FsRangeBase.fs.js';
+import { class_type } from '../../../../node_modules/@fable-org/fable-library-js/Reflection.js';
+
+class FsTable extends FsRangeBase {
+  constructor(name, rangeAddress, showTotalsRow, showHeaderRow, fieldNames) {
+    super(rangeAddress);
+    let fns, dict;
+    this._name = replace(name.trim(), " ", "_");
+    this._lastRangeAddress = rangeAddress;
+    this._showTotalsRow = defaultArg(showTotalsRow, false);
+    this._showHeaderRow = defaultArg(showHeaderRow, true);
+    this._fieldNames = fieldNames == null ? /* @__PURE__ */ new Map([]) : (fns = value(fieldNames), length(fns) !== super.ColumnCount() ? (() => {
+      let arg, arg_1;
+      throw new Error((arg = length(fns) | 0, arg_1 = super.ColumnCount() | 0, toText(printf("The number of field names (%i) must match the number of columns (%i) in the range."))(arg)(arg_1)), "fieldNames");
+    })() : void 0, dict = /* @__PURE__ */ new Map([]), iterateIndexed((i, fn) => {
+      const colI = rangeAddress.FirstAddress.ColumnNumber + i | 0;
+      addToDict(dict, fn, new FsTableField(fn, i, new FsRangeColumn(new FsRangeAddress(new FsAddress(rangeAddress.FirstAddress.RowNumber, colI), new FsAddress(rangeAddress.LastAddress.RowNumber, colI)))));
+    }, fns), dict);
+    this._uniqueNames = /* @__PURE__ */ new Set([]);
+  }
+  get Name() {
+    const this$ = this;
+    return this$._name;
+  }
+  GetFieldNames(cellsCollection) {
+    const this$ = this;
+    if (!equals(this$._fieldNames, defaultOf()) && !equals(this$._lastRangeAddress, defaultOf()) && equals(this$._lastRangeAddress, this$.RangeAddress)) {
+      return this$._fieldNames;
+    } else {
+      this$._lastRangeAddress = this$.RangeAddress;
+      return this$._fieldNames;
+    }
+  }
+  GetFields(cellsCollection) {
+    const this$ = this;
+    return initialize(super.ColumnCount(), (i) => this$.GetFieldAt(i, cellsCollection));
+  }
+  get ShowHeaderRow() {
+    const this$ = this;
+    return this$._showHeaderRow;
+  }
+  set ShowHeaderRow(showHeaderRow) {
+    const this$ = this;
+    this$._showHeaderRow = showHeaderRow;
+  }
+  HeadersRow() {
+    const this$ = this;
+    return !this$.ShowHeaderRow ? defaultOf() : new FsRange(super.RangeAddress).FirstRow();
+  }
+  TryGetHeaderRow(cellsCollection) {
+    const this$ = this;
+    const matchValue = this$.ShowHeaderRow;
+    if (matchValue) {
+      const rowIndex = this$.RangeAddress.FirstAddress.RowNumber | 0;
+      return new FsRow(new FsRangeAddress(new FsAddress(rowIndex, this$.RangeAddress.FirstAddress.ColumnNumber), new FsAddress(rowIndex, this$.RangeAddress.LastAddress.ColumnNumber)), cellsCollection);
+    } else {
+      return void 0;
+    }
+  }
+  GetHeaderRow(cellsCollection) {
+    const this$ = this;
+    const matchValue = this$.TryGetHeaderRow(cellsCollection);
+    if (matchValue == null) {
+      throw new Error(`Error. Unable to get header row for table "${this$.Name}" as \`ShowHeaderRow\` is set to \`false\`.`);
+    } else {
+      return value(matchValue);
+    }
+  }
+  GetColumns(cellsCollection) {
+    const this$ = this;
+    return delay(() => collect((i) => singleton(new FsColumn(new FsRangeAddress(new FsAddress(this$.RangeAddress.FirstAddress.RowNumber, i), new FsAddress(this$.RangeAddress.LastAddress.RowNumber, i)), cellsCollection)), rangeDouble(this$.RangeAddress.FirstAddress.ColumnNumber, 1, this$.RangeAddress.LastAddress.ColumnNumber)));
+  }
+  GetRows(cellsCollection) {
+    const this$ = this;
+    return delay(() => collect((i) => singleton(new FsRow(new FsRangeAddress(new FsAddress(i, this$.RangeAddress.FirstAddress.ColumnNumber), new FsAddress(i, this$.RangeAddress.LastAddress.ColumnNumber)), cellsCollection)), rangeDouble(this$.RangeAddress.FirstAddress.RowNumber, 1, this$.RangeAddress.LastAddress.RowNumber)));
+  }
+  GetBodyRows(cellsCollection) {
+    const this$ = this;
+    const firstRowIndex = (this$.ShowHeaderRow ? this$.RangeAddress.FirstAddress.RowNumber + 1 : this$.RangeAddress.FirstAddress.RowNumber) | 0;
+    return delay(() => collect((i) => singleton(new FsRow(new FsRangeAddress(new FsAddress(i, this$.RangeAddress.FirstAddress.ColumnNumber), new FsAddress(i, this$.RangeAddress.LastAddress.ColumnNumber)), cellsCollection)), rangeDouble(firstRowIndex, 1, this$.RangeAddress.LastAddress.RowNumber)));
+  }
+  GetRowAt(index, cellsCollection) {
+    let arg;
+    const this$ = this;
+    if (index <= 0 ? true : index > super.RowCount()) {
+      throw new Error(int32ToString(index), (arg = super.RowCount() | 0, toText(printf("Row index must be between 1 and %i"))(arg)));
+    }
+    const rowI = this$.RangeAddress.FirstAddress.RowNumber + index - 1 | 0;
+    return new FsRow(new FsRangeAddress(new FsAddress(rowI, this$.RangeAddress.FirstAddress.ColumnNumber), new FsAddress(rowI, this$.RangeAddress.LastAddress.ColumnNumber)), cellsCollection);
+  }
+  GetBodyRowAt(index, cellsCollection) {
+    const this$ = this;
+    return this$.ShowHeaderRow ? this$.GetRowAt(index + 1, cellsCollection) : this$.GetRowAt(index, cellsCollection);
+  }
+  RescanRange() {
+    const this$ = this;
+    const rangeAddress = reduce((r1, r2) => r1.Union(r2), map((v) => v.Column.RangeAddress, this$._fieldNames.values()));
+    this$.RangeAddress = rangeAddress;
+  }
+  static rescanRange(table) {
+    table.RescanRange();
+    return table;
+  }
+  GetUniqueName(originalName, initialOffset, enforceOffset) {
+    const this$ = this;
+    let name = originalName + (enforceOffset ? int32ToString(initialOffset) : "");
+    if (this$._uniqueNames.has(name)) {
+      let i = initialOffset;
+      name = originalName + int32ToString(i);
+      while (this$._uniqueNames.has(name)) {
+        i = i + 1 | 0;
+        name = originalName + int32ToString(i);
+      }
+    }
+    addToSet(name, this$._uniqueNames);
+    return name;
+  }
+  static getUniqueNames(originalName, initialOffset, enforceOffset, table) {
+    return table.GetUniqueName(originalName, initialOffset, enforceOffset);
+  }
+  InitFields(fieldNames) {
+    const this$ = this;
+    iterateIndexed((i, fn) => {
+      const tableField = new FsTableField(fn, i, FsRangeColumn.fromIndex(i));
+      addToDict(this$._fieldNames, fn, tableField);
+    }, fieldNames);
+  }
+  static initFields(fieldNames, table) {
+    table.InitFields(fieldNames);
+    return table;
+  }
+  AddFields(tableFields) {
+    const this$ = this;
+    iterate((tf) => {
+      addToDict(this$._fieldNames, tf.Name, tf);
+    }, tableFields);
+  }
+  static addFields(tableFields, table) {
+    table.AddFields(tableFields);
+    return table;
+  }
+  Field(name, cellsCollection) {
+    let s, offset;
+    const this$ = this;
+    const matchValue = Dictionary_tryGet(name, this$._fieldNames);
+    if (matchValue == null) {
+      const newField = new FsTableField(name, (s = map((v) => v.Index, this$._fieldNames.values()), length(s) === 0 ? 0 : max(s, {
+        Compare: comparePrimitives
+      })) + 1, new FsRangeColumn((offset = this$._fieldNames.size | 0, new FsRangeAddress(new FsAddress(this$.RangeAddress.FirstAddress.RowNumber, this$.RangeAddress.FirstAddress.ColumnNumber + offset), new FsAddress(this$.RangeAddress.LastAddress.RowNumber, this$.RangeAddress.FirstAddress.ColumnNumber + offset)))), some(defaultOf()), some(defaultOf()));
+      if (this$.ShowHeaderRow) {
+        const value = newField.HeaderCell(cellsCollection, true).SetValueAs(name);
+      }
+      addToDict(this$._fieldNames, name, newField);
+      this$.RescanRange();
+      return newField;
+    } else {
+      return value(matchValue);
+    }
+  }
+  GetField(name, cellsCollection) {
+    const this$ = this;
+    const name_1 = replace(name, "\r\n", "\n");
+    try {
+      return getItemFromDict(this$.GetFieldNames(cellsCollection), name_1);
+    } catch (matchValue) {
+      throw new Error("The header row doesn't contain field name '" + name_1 + "'.");
+    }
+  }
+  static getField(name, cellsCollection, table) {
+    return table.GetField(name, cellsCollection);
+  }
+  GetFieldAt(index, cellsCollection) {
+    const this$ = this;
+    try {
+      return find((ftf) => ftf.Index === index, this$.GetFieldNames(cellsCollection).values());
+    } catch (matchValue) {
+      throw new Error(`FsTableField with index ${index} does not exist in the FsTable.`);
+    }
+  }
+  GetFieldIndex(name, cellsCollection) {
+    const this$ = this;
+    return this$.GetField(name, cellsCollection).Index | 0;
+  }
+  RenameField(oldName, newName) {
+    const this$ = this;
+    const matchValue = Dictionary_tryGet(oldName, this$._fieldNames);
+    if (matchValue == null) {
+      throw new Error("The FsTabelField does not exist in this FsTable", "oldName");
+    } else {
+      const field = value(matchValue);
+      this$._fieldNames.delete(oldName);
+      addToDict(this$._fieldNames, newName, field);
+    }
+  }
+  static renameField(oldName, newName, table) {
+    table.RenameField(oldName, newName);
+    return table;
+  }
+  TryGetHeaderCellOfColumnAt(cellsCollection, colIndex) {
+    const this$ = this;
+    const fstRowIndex = this$.RangeAddress.FirstAddress.RowNumber | 0;
+    return tryFind((c) => c.RowNumber === fstRowIndex, cellsCollection.GetCellsInColumn(colIndex));
+  }
+  static tryGetHeaderCellOfColumnIndexAt(cellsCollection, colIndex, table) {
+    return table.TryGetHeaderCellOfColumnAt(cellsCollection, colIndex);
+  }
+  TryGetHeaderCellOfColumn(cellsCollection, column) {
+    const this$ = this;
+    return this$.TryGetHeaderCellOfColumnAt(cellsCollection, column.Index);
+  }
+  static tryGetHeaderCellOfColumn(cellsCollection, column, table) {
+    return table.TryGetHeaderCellOfColumn(cellsCollection, column);
+  }
+  GetHeaderCellOfColumnAt(cellsCollection, colIndex) {
+    const this$ = this;
+    return value(this$.TryGetHeaderCellOfColumnAt(cellsCollection, colIndex));
+  }
+  static getHeaderCellOfColumnIndexAt(cellsCollection, colIndex, table) {
+    return table.GetHeaderCellOfColumnAt(cellsCollection, colIndex);
+  }
+  GetHeaderCellOfColumn(cellsCollection, column) {
+    const this$ = this;
+    return value(this$.TryGetHeaderCellOfColumn(cellsCollection, column));
+  }
+  static getHeaderCellOfColumn(cellsCollection, column, table) {
+    return table.GetHeaderCellOfColumn(cellsCollection, column);
+  }
+  GetHeaderCellOfTableField(cellsCollection, tableField) {
+    const this$ = this;
+    return tableField.HeaderCell(cellsCollection, this$.ShowHeaderRow);
+  }
+  static getHeaderCellOfTableField(cellsCollection, tableField, table) {
+    return table.GetHeaderCellOfTableField(cellsCollection, tableField);
+  }
+  TryGetHeaderCellOfTableFieldAt(cellsCollection, tableFieldIndex) {
+    const this$ = this;
+    return tryPick((tf) => {
+      if (tf.Index === tableFieldIndex) {
+        return tf.HeaderCell(cellsCollection, this$.ShowHeaderRow);
+      } else {
+        return void 0;
+      }
+    }, this$._fieldNames.values());
+  }
+  static tryGetHeaderCellOfTableFieldIndexAt(cellsCollection, tableFieldIndex, table) {
+    return table.TryGetHeaderCellOfTableFieldAt(cellsCollection, tableFieldIndex);
+  }
+  GetHeaderCellOfTableFieldAt(cellsCollection, tableFieldIndex) {
+    const this$ = this;
+    return value(this$.TryGetHeaderCellOfTableFieldAt(cellsCollection, tableFieldIndex));
+  }
+  static getHeaderCellOfTableFieldIndexAt(cellsCollection, tableFieldIndex, table) {
+    return table.GetHeaderCellOfTableFieldAt(cellsCollection, tableFieldIndex);
+  }
+  TryGetHeaderCellByFieldName(cellsCollection, fieldName) {
+    const this$ = this;
+    const matchValue = Dictionary_tryGet(fieldName, this$._fieldNames);
+    if (matchValue == null) {
+      return void 0;
+    } else {
+      const tf = value(matchValue);
+      return tf.HeaderCell(cellsCollection, this$.ShowHeaderRow);
+    }
+  }
+  static tryGetHeaderCellByFieldName(cellsCollection, fieldName, table) {
+    return table.TryGetHeaderCellByFieldName(cellsCollection, fieldName);
+  }
+  GetDataCellsOfColumnAt(cellsCollection, colIndex) {
+    const this$ = this;
+    return choose((ri) => cellsCollection.TryGetCell(ri, colIndex), toList(rangeDouble(this$.RangeAddress.FirstAddress.RowNumber + 1, 1, this$.RangeAddress.LastAddress.RowNumber)));
+  }
+  static getDataCellsOfColumnIndexAt(cellsCollection, colIndex, table) {
+    return table.GetDataCellsOfColumnAt(cellsCollection, colIndex);
+  }
+  Copy() {
+    const this$ = this;
+    const ra = this$.RangeAddress.Copy();
+    return new FsTable(this$.Name, ra, false, this$.ShowHeaderRow);
+  }
+  static copy(table) {
+    return table.Copy();
+  }
+  static validateForWrite(table, cellsCollection) {
+    let arg;
+    if (length(table.GetBodyRows(cellsCollection)) === 0) {
+      throw new Error((arg = table.Name, toText(printf("The table '%s' must contain at least one body row."))(arg)), "table");
+    }
+  }
+  RescanFieldNames(cellsCollection) {
+    const this$ = this;
+    if (this$.ShowHeaderRow) {
+      const oldFieldNames = this$._fieldNames;
+      this$._fieldNames = /* @__PURE__ */ new Map([]);
+      let cellPos = 0;
+      const enumerator = getEnumerator(this$.GetHeaderRow(cellsCollection));
+      try {
+        while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+          const cell = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+          let name = cell.ValueAsString();
+          const matchValue = Dictionary_tryGet(name, oldFieldNames);
+          if (matchValue == null) {
+            if (name === defaultOf() !== (name === "")) {
+              name = this$.GetUniqueName("Column", cellPos + 1, true);
+              const value = cell.SetValueAs(name);
+              cell.DataType = DataType_String();
+            }
+            if (this$._fieldNames.has(name)) {
+              throw new Error("The header row contains more than one field name '" + name + "'.");
+            }
+            addToDict(this$._fieldNames, name, new FsTableField(name, cellPos));
+            cellPos = cellPos + 1 | 0;
+          } else {
+            const tableField = value(matchValue);
+            tableField.Index = cellPos | 0;
+            addToDict(this$._fieldNames, name, tableField);
+            cellPos = cellPos + 1 | 0;
+          }
+        }
+      } finally {
+        disposeSafe(enumerator);
+      }
+    } else {
+      const colCount = super.ColumnCount() | 0;
+      for (let i = 1; i <= colCount; i++) {
+        if (!exists((v) => v.Index === i - 1, this$._fieldNames.values())) {
+          const name_1 = "Column" + int32ToString(i);
+          addToDict(this$._fieldNames, name_1, new FsTableField(name_1, i - 1));
+        }
+      }
+    }
+  }
+}
+function FsTable_$reflection() {
+  return class_type("FsSpreadsheet.FsTable", void 0, FsTable, FsRangeBase_$reflection());
+}
+function FsTable_$ctor_3B894C50(name, rangeAddress, showTotalsRow, showHeaderRow, fieldNames) {
+  return new FsTable(name, rangeAddress, showTotalsRow, showHeaderRow, fieldNames);
+}
+
+export { FsTable, FsTable_$ctor_3B894C50, FsTable_$reflection };

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

@@ -0,0 +1,95 @@
+import { FsRangeColumn } from '../Ranges/FsRangeColumn.fs.js';
+import { defaultOf, equals } from '../../../../node_modules/@fable-org/fable-library-js/Util.js';
+import { FsRangeAddress } from '../Ranges/FsRangeAddress.fs.js';
+import { FsAddress } from '../FsAddress.fs.js';
+import { defaultArg, some } from '../../../../node_modules/@fable-org/fable-library-js/Option.js';
+import { toFail, printf } from '../../../../node_modules/@fable-org/fable-library-js/String.js';
+import { skip } from '../../../../node_modules/@fable-org/fable-library-js/Seq.js';
+import { class_type } from '../../../../node_modules/@fable-org/fable-library-js/Reflection.js';
+
+class FsTableField {
+  constructor(name, index, column, totalsRowLabel, totalsRowFunction) {
+    this._totalsRowsFunction = defaultArg(totalsRowFunction, defaultOf());
+    this._totalsRowLabel = defaultArg(totalsRowLabel, defaultOf());
+    this._column = defaultArg(column, defaultOf());
+    this._index = defaultArg(index, 0) | 0;
+    this._name = name;
+    this["Column@"] = this._column;
+  }
+  get Column() {
+    const __ = this;
+    return __["Column@"];
+  }
+  set Column(v) {
+    const __ = this;
+    __["Column@"] = v;
+  }
+  get Index() {
+    const this$ = this;
+    return this$._index | 0;
+  }
+  set Index(index) {
+    const this$ = this;
+    if (index === this$._index) {
+    } else {
+      this$._index = index | 0;
+      if (equals(this$._column, defaultOf())) {
+      } else {
+        const indDiff = index - this$._index | 0;
+        const newCol = new FsRangeColumn(new FsRangeAddress(new FsAddress(this$.Column.RangeAddress.FirstAddress.RowNumber, this$._index + indDiff), new FsAddress(this$.Column.RangeAddress.LastAddress.RowNumber, this$._index + indDiff)));
+        this$.Column = newCol;
+      }
+    }
+  }
+  get Name() {
+    const this$ = this;
+    return this$._name;
+  }
+  SetName(name, cellsCollection, showHeaderRow) {
+    const this$ = this;
+    this$._name = name;
+    if (showHeaderRow) {
+      this$.Column.FirstCell(cellsCollection).SetValueAs(name);
+    }
+  }
+  static setName(name, cellsCollection, showHeaderRow, tableField) {
+    tableField.SetName(name, cellsCollection, showHeaderRow);
+    return tableField;
+  }
+  Copy() {
+    const this$ = this;
+    const col = this$.Column.Copy();
+    const ind = this$.Index | 0;
+    return new FsTableField(this$.Name, ind, col, some(defaultOf()), some(defaultOf()));
+  }
+  static copy(tableField) {
+    return tableField.Copy();
+  }
+  HeaderCell(cellsCollection, showHeaderRow) {
+    const this$ = this;
+    if (!showHeaderRow) {
+      const arg = this$._name;
+      return toFail(printf('tried to get header cell of table field "%s" even though showHeaderRow is set to zero'))(arg);
+    } else {
+      return this$.Column.FirstCell(cellsCollection);
+    }
+  }
+  static getHeaderCell(cellsCollection, showHeaderRow, tableField) {
+    return tableField.HeaderCell(cellsCollection, showHeaderRow);
+  }
+  DataCells(cellsCollection) {
+    const this$ = this;
+    return skip(1, this$.Column.Cells(cellsCollection));
+  }
+  static getDataCells(cellsCollection, tableField) {
+    return tableField.DataCells(cellsCollection);
+  }
+}
+function FsTableField_$reflection() {
+  return class_type("FsSpreadsheet.FsTableField", void 0, FsTableField);
+}
+function FsTableField_$ctor_E675DBB(name, index, column, totalsRowLabel, totalsRowFunction) {
+  return new FsTableField(name, index, column, totalsRowLabel, totalsRowFunction);
+}
+
+export { FsTableField, FsTableField_$ctor_E675DBB, FsTableField_$reflection };

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

@@ -0,0 +1,68 @@
+import { FsCell, DataType_String, DataType_Boolean, DataType_Date, DataType_Number } from '../FsSpreadsheet.7.0.0-alpha.1/Cells/FsCell.fs.js';
+import { some, value } from '../../../node_modules/@fable-org/fable-library-js/Option.js';
+import { fromDate, op_Addition, offset } from '../../../node_modules/@fable-org/fable-library-js/DateOffset.js';
+import { FsAddress } from '../FsSpreadsheet.7.0.0-alpha.1/FsAddress.fs.js';
+import { toString } from '../../../node_modules/@fable-org/fable-library-js/Types.js';
+import { parse as parse$2 } from '../../../node_modules/@fable-org/fable-library-js/Double.js';
+import { parse as parse$1, toUniversalTime, create, year, month, day, hour, minute, second } from '../../../node_modules/@fable-org/fable-library-js/Date.js';
+import { parse } from '../../../node_modules/@fable-org/fable-library-js/Boolean.js';
+
+function writeFromFsCell(fsCell) {
+  const matchValue = fsCell.DataType;
+  switch (matchValue.tag) {
+    case /* Number */
+    2:
+      return some(fsCell.ValueAsFloat());
+    case /* Date */
+    3: {
+      const dt = fromDate(fsCell.ValueAsDateTime());
+      return some(op_Addition(dt, offset(dt)));
+    }
+    case /* String */
+    0:
+      return some(fsCell.Value);
+    case /* Empty */
+    4:
+      return some(fsCell.Value);
+    default:
+      return some(fsCell.ValueAsBool());
+  }
+}
+function readToFsCell(worksheetName, rowIndex, columnIndex, jsCell) {
+  const t = jsCell.type | 0;
+  const fsadress = FsAddress.fromString(jsCell.address);
+  const createFscell = (dt, v) => new FsCell(v, dt, fsadress);
+  const vTemp = toString(value(jsCell.value));
+  switch (t) {
+    case 2:
+      return createFscell(DataType_Number(), parse$2(vTemp));
+    case 3:
+      return createFscell(DataType_String(), vTemp);
+    case 4: {
+      let dt_1;
+      let copyOfStruct = parse$1(vTemp);
+      dt_1 = toUniversalTime(copyOfStruct);
+      const dt_2 = create(year(dt_1), month(dt_1), day(dt_1), hour(dt_1), minute(dt_1), second(dt_1));
+      return createFscell(DataType_Date(), dt_2);
+    }
+    case 5:
+      return createFscell(DataType_String(), value(jsCell.value).hyperlink);
+    case 6: {
+      const matchValue = jsCell.formula;
+      switch (matchValue) {
+        case "TRUE()":
+          return createFscell(DataType_Boolean(), true);
+        case "FALSE()":
+          return createFscell(DataType_Boolean(), false);
+        default:
+          return createFscell(DataType_String(), matchValue);
+      }
+    }
+    case 9:
+      return createFscell(DataType_Boolean(), parse(vTemp));
+    default:
+      return createFscell(DataType_String(), vTemp);
+  }
+}
+
+export { readToFsCell, writeFromFsCell };

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

@@ -0,0 +1,51 @@
+import { Xlsx } from './Xlsx.fs.js';
+import { Json } from './Json.fs.js';
+import { unwrap } from '../../../node_modules/@fable-org/fable-library-js/Option.js';
+
+function FsSpreadsheet_FsWorkbook__FsWorkbook_fromXlsxFile_Static_Z721C83C5(path) {
+  return Xlsx.fromXlsxFile(path);
+}
+function FsSpreadsheet_FsWorkbook__FsWorkbook_fromXlsxStream_Static_4D976C1A(stream) {
+  return Xlsx.fromXlsxStream(stream);
+}
+function FsSpreadsheet_FsWorkbook__FsWorkbook_fromXlsxBytes_Static_Z3F6BC7B1(bytes) {
+  return Xlsx.fromXlsxBytes(bytes);
+}
+function FsSpreadsheet_FsWorkbook__FsWorkbook_toXlsxFile_Static(path, wb) {
+  return Xlsx.toXlsxFile(path, wb);
+}
+function FsSpreadsheet_FsWorkbook__FsWorkbook_toXlsxStream_Static(stream, wb) {
+  return Xlsx.toXlsxStream(stream, wb);
+}
+function FsSpreadsheet_FsWorkbook__FsWorkbook_toXlsxBytes_Static_32154C9D(wb) {
+  return Xlsx.toXlsxBytes(wb);
+}
+function FsSpreadsheet_FsWorkbook__FsWorkbook_ToXlsxFile_Z721C83C5(this$, path) {
+  return FsSpreadsheet_FsWorkbook__FsWorkbook_toXlsxFile_Static(path, this$);
+}
+function FsSpreadsheet_FsWorkbook__FsWorkbook_ToXlsxStream_4D976C1A(this$, stream) {
+  return FsSpreadsheet_FsWorkbook__FsWorkbook_toXlsxStream_Static(stream, this$);
+}
+function FsSpreadsheet_FsWorkbook__FsWorkbook_ToXlsxBytes(this$) {
+  return FsSpreadsheet_FsWorkbook__FsWorkbook_toXlsxBytes_Static_32154C9D(this$);
+}
+function FsSpreadsheet_FsWorkbook__FsWorkbook_fromRowsJsonString_Static_Z721C83C5(json) {
+  return Json.fromRowsJsonString(json);
+}
+function FsSpreadsheet_FsWorkbook__FsWorkbook_toRowsJsonString_Static_Z2B6E0EF5(wb, spaces, noNumbering) {
+  return Json.toRowsJsonString(wb, unwrap(spaces), unwrap(noNumbering));
+}
+function FsSpreadsheet_FsWorkbook__FsWorkbook_ToRowsJsonString_Z3B036AA(this$, spaces, noNumbering) {
+  return FsSpreadsheet_FsWorkbook__FsWorkbook_toRowsJsonString_Static_Z2B6E0EF5(this$, unwrap(spaces), unwrap(noNumbering));
+}
+function FsSpreadsheet_FsWorkbook__FsWorkbook_fromColumnsJsonString_Static_Z721C83C5(json) {
+  return Json.fromColumnsJsonString(json);
+}
+function FsSpreadsheet_FsWorkbook__FsWorkbook_toColumnsJsonString_Static_Z2B6E0EF5(wb, spaces, noNumbering) {
+  return Json.toColumnsJsonString(wb, unwrap(spaces), unwrap(noNumbering));
+}
+function FsSpreadsheet_FsWorkbook__FsWorkbook_ToColumnsJsonString_Z3B036AA(this$, spaces, noNumbering) {
+  return FsSpreadsheet_FsWorkbook__FsWorkbook_toColumnsJsonString_Static_Z2B6E0EF5(this$, unwrap(spaces), unwrap(noNumbering));
+}
+
+export { FsSpreadsheet_FsWorkbook__FsWorkbook_ToColumnsJsonString_Z3B036AA, FsSpreadsheet_FsWorkbook__FsWorkbook_ToRowsJsonString_Z3B036AA, FsSpreadsheet_FsWorkbook__FsWorkbook_ToXlsxBytes, FsSpreadsheet_FsWorkbook__FsWorkbook_ToXlsxFile_Z721C83C5, FsSpreadsheet_FsWorkbook__FsWorkbook_ToXlsxStream_4D976C1A, FsSpreadsheet_FsWorkbook__FsWorkbook_fromColumnsJsonString_Static_Z721C83C5, FsSpreadsheet_FsWorkbook__FsWorkbook_fromRowsJsonString_Static_Z721C83C5, FsSpreadsheet_FsWorkbook__FsWorkbook_fromXlsxBytes_Static_Z3F6BC7B1, FsSpreadsheet_FsWorkbook__FsWorkbook_fromXlsxFile_Static_Z721C83C5, FsSpreadsheet_FsWorkbook__FsWorkbook_fromXlsxStream_Static_4D976C1A, FsSpreadsheet_FsWorkbook__FsWorkbook_toColumnsJsonString_Static_Z2B6E0EF5, FsSpreadsheet_FsWorkbook__FsWorkbook_toRowsJsonString_Static_Z2B6E0EF5, FsSpreadsheet_FsWorkbook__FsWorkbook_toXlsxBytes_Static_32154C9D, FsSpreadsheet_FsWorkbook__FsWorkbook_toXlsxFile_Static, FsSpreadsheet_FsWorkbook__FsWorkbook_toXlsxStream_Static };

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

@@ -0,0 +1,53 @@
+import { fromString } from '../Thoth.Json.JavaScript.0.4.1/Decode.fs.js';
+import { decodeRows, encodeRows, decodeColumns, encodeColumns } from '../FsSpreadsheet.7.0.0-alpha.1/Json/Workbook.fs.js';
+import { FSharpResult$2_Error, FSharpResult$2_Ok } from '../../../node_modules/@fable-org/fable-library-js/Result.js';
+import { toFail, printf } from '../../../node_modules/@fable-org/fable-library-js/String.js';
+import { toString } from '../Thoth.Json.JavaScript.0.4.1/Encode.fs.js';
+import { defaultArg } from '../../../node_modules/@fable-org/fable-library-js/Option.js';
+import { class_type } from '../../../node_modules/@fable-org/fable-library-js/Reflection.js';
+
+class Json {
+  constructor() {
+  }
+  static tryFromRowsJsonString(json) {
+    const matchValue = fromString(decodeRows, json);
+    return matchValue.tag === /* Error */
+    1 ? FSharpResult$2_Error(matchValue.fields[0]) : FSharpResult$2_Ok(matchValue.fields[0]);
+  }
+  static fromRowsJsonString(json) {
+    const matchValue = Json.tryFromRowsJsonString(json);
+    if (matchValue.tag === /* Error */
+    1) {
+      const e = matchValue.fields[0];
+      return toFail(printf("Could not deserialize json Workbook: \n%s"))(e);
+    } else {
+      return matchValue.fields[0];
+    }
+  }
+  static toRowsJsonString(wb, spaces, noNumbering) {
+    return toString(defaultArg(spaces, 2), encodeRows(defaultArg(noNumbering, false), wb));
+  }
+  static tryFromColumnsJsonString(json) {
+    const matchValue = fromString(decodeColumns, json);
+    return matchValue.tag === /* Error */
+    1 ? FSharpResult$2_Error(matchValue.fields[0]) : FSharpResult$2_Ok(matchValue.fields[0]);
+  }
+  static fromColumnsJsonString(json) {
+    const matchValue = Json.tryFromColumnsJsonString(json);
+    if (matchValue.tag === /* Error */
+    1) {
+      const e = matchValue.fields[0];
+      return toFail(printf("Could not deserialize json Workbook: \n%s"))(e);
+    } else {
+      return matchValue.fields[0];
+    }
+  }
+  static toColumnsJsonString(wb, spaces, noNumbering) {
+    return toString(defaultArg(spaces, 2), encodeColumns(defaultArg(noNumbering, false), wb));
+  }
+}
+function Json_$reflection() {
+  return class_type("FsSpreadsheet.Js.Json", void 0, Json);
+}
+
+export { Json, Json_$reflection };

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

@@ -0,0 +1,54 @@
+import { toArray, delay, map, length, collect, tail } from '../../../node_modules/@fable-org/fable-library-js/Seq.js';
+import { int32ToString, comparePrimitives, numberHash } from '../../../node_modules/@fable-org/fable-library-js/Util.js';
+import { rangeDouble } from '../../../node_modules/@fable-org/fable-library-js/Range.js';
+import { map as map$1, sortBy } from '../../../node_modules/@fable-org/fable-library-js/Array.js';
+import { ofSeq, FSharpMap__TryFind } from '../../../node_modules/@fable-org/fable-library-js/Map.js';
+import { Array_groupBy } from '../../../node_modules/@fable-org/fable-library-js/Seq2.js';
+import { value } from '../../../node_modules/@fable-org/fable-library-js/Option.js';
+import { writeFromFsCell } from './Cell.fs.js';
+import { FsTable } from '../FsSpreadsheet.7.0.0-alpha.1/Tables/FsTable.fs.js';
+import { FsRangeAddress } from '../FsSpreadsheet.7.0.0-alpha.1/Ranges/FsRangeAddress.fs.js';
+
+function writeFromFsTable(fscellcollection, fsTable) {
+  const fsColumns = fsTable.GetColumns(fscellcollection);
+  const columns = fsTable.ShowHeaderRow ? toArray(delay(() => map((headerCell) => ({
+    name: headerCell.ValueAsString()
+  }), fsTable.GetHeaderRow(fscellcollection)))) : toArray(delay(() => map((i) => ({
+    name: int32ToString(i)
+  }), rangeDouble(1, 1, length(fsColumns)))));
+  const rows = map$1((tupledArg) => {
+    const m = ofSeq(map$1((tuple_2) => tuple_2[1], tupledArg[1]), {
+      Compare: comparePrimitives
+    });
+    return map$1((i_1) => FSharpMap__TryFind(m, i_1), toArray(rangeDouble(fsTable.RangeAddress.FirstAddress.ColumnNumber, 1, fsTable.RangeAddress.FirstAddress.ColumnNumber + (columns.length - 1))));
+  }, sortBy((tuple_1) => tuple_1[0], Array_groupBy((tuple) => tuple[0], toArray(delay(() => collect((col) => map((c) => {
+    const rowValue = value(writeFromFsCell(c));
+    return [c.Address.RowNumber, [c.Address.ColumnNumber, rowValue]];
+  }, fsTable.ShowHeaderRow ? tail(col.Cells) : col.Cells), fsColumns))), {
+    Equals: (x, y) => x === y,
+    GetHashCode: numberHash
+  }), {
+    Compare: comparePrimitives
+  }));
+  const defaultStyle = {
+    showRowStripes: true
+  };
+  return {
+    name: fsTable.Name,
+    ref: fsTable.RangeAddress.Range,
+    columns,
+    rows,
+    displayName: fsTable.Name,
+    headerRow: fsTable.ShowHeaderRow,
+    style: defaultStyle
+  };
+}
+function readToFsTable(table) {
+  const table_1 = value(table.table);
+  let tableRef;
+  const rangeAddress = table_1.tableRef;
+  tableRef = FsRangeAddress.fromString(rangeAddress);
+  return new FsTable(table_1.displayName == null ? table_1.name : table_1.displayName, tableRef, table_1.totalsRow, table_1.headerRow);
+}
+
+export { readToFsTable, writeFromFsTable };