@nfdi4plants/arctrl 3.1.1 → 3.2.0

package/dist/ts/ts/fable_modules/{FsSpreadsheet.7.0.0-alpha.1 → FsSpreadsheet.7.0.1}/Tables/FsTable.fs.js

@@ -1,42 +1,49 @@
-import { equals, defaultOf, int32ToString, comparePrimitives, getEnumerator, disposeSafe } from '../../../../node_modules/@fable-org/fable-library-js/Util.js';
+import { equals, defaultOf, Exception, int32ToString, comparePrimitives, getEnumerator, disposeSafe } from '../../../../node_modules/@fable-org/fable-library-ts/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 { length, iterateIndexed, initialize, delay, collect, singleton, reduce, map, iterate, max, find, tryFind, tryPick, choose, toList, exists } from '../../../../node_modules/@fable-org/fable-library-ts/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 { defaultArg, value, some } from '../../../../node_modules/@fable-org/fable-library-ts/Option.js';
+import { replace, toText, printf, concat } from '../../../../node_modules/@fable-org/fable-library-ts/String.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 { rangeDouble } from '../../../../node_modules/@fable-org/fable-library-ts/Range.js';
+import { ArgumentException_$ctor_Z384F8060, ArgumentOutOfRangeException_$ctor_Z384F8060, ArgumentException_$ctor_Z721C83C5 } from '../../../../node_modules/@fable-org/fable-library-ts/System.js';
+import { addToDict, addToSet, getItemFromDict } from '../../../../node_modules/@fable-org/fable-library-ts/MapUtil.js';
 import { FsRangeColumn } from '../Ranges/FsRangeColumn.fs.js';
-import { DataType_String } from '../Cells/FsCell.fs.js';
+import { DataType } 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';
+import { class_type } from '../../../../node_modules/@fable-org/fable-library-ts/Reflection.js';
 
 class FsTable extends FsRangeBase {
   constructor(name, rangeAddress, showTotalsRow, showHeaderRow, fieldNames) {
     super(rangeAddress);
-    let fns, dict;
+    let fns = void 0, dict = void 0;
     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");
+      let arg = void 0, arg_1 = void 0;
+      throw ArgumentException_$ctor_Z384F8060((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([]);
   }
+  /**
+   * The name of the FsTable.
+   */
   get Name() {
     const this$ = this;
     return this$._name;
   }
+  /**
+   * Returns all fieldnames as `fieldname*FsTableField` dictionary.
+   */
   GetFieldNames(cellsCollection) {
     const this$ = this;
     if (!equals(this$._fieldNames, defaultOf()) && !equals(this$._lastRangeAddress, defaultOf()) && equals(this$._lastRangeAddress, this$.RangeAddress)) {
@@ -46,18 +53,30 @@ class FsTable extends FsRangeBase {
       return this$._fieldNames;
     }
   }
+  /**
+   * The FsTableFields of this FsTable.
+   */
   GetFields(cellsCollection) {
     const this$ = this;
     return initialize(super.ColumnCount(), (i) => this$.GetFieldAt(i, cellsCollection));
   }
+  /**
+   * Gets or sets if the header row is shown.
+   */
   get ShowHeaderRow() {
     const this$ = this;
     return this$._showHeaderRow;
   }
+  /**
+   * Gets or sets if the header row is shown.
+   */
   set ShowHeaderRow(showHeaderRow) {
     const this$ = this;
     this$._showHeaderRow = showHeaderRow;
   }
+  /**
+   * Returns the header row as FsRangeRow. Scans for new fieldnames.
+   */
   HeadersRow() {
     const this$ = this;
     return !this$.ShowHeaderRow ? defaultOf() : new FsRange(super.RangeAddress).FirstRow();
@@ -76,46 +95,71 @@ class FsTable extends FsRangeBase {
     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\`.`);
+      throw new Exception(concat('Error. Unable to get header row for table "', this$.Name, '" as `ShowHeaderRow` is set to `false`.'));
     } else {
       return value(matchValue);
     }
   }
+  /**
+   * Returns the FsColumns from the FsTable.
+   */
   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)));
   }
+  /**
+   * Returns the FsRows from the FsTable, including HeaderRows if present. If only the body rows are needed, use GetBodyRows.
+   */
   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)));
   }
+  /**
+   * Returns the body rows from the FsTable, i.e. all rows except the header row (if shown).
+   */
   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)));
   }
+  /**
+   * Returns the FsRow at the given index from the FsTable.
+   */
   GetRowAt(index, cellsCollection) {
-    let arg;
+    let arg = void 0;
     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)));
+      throw ArgumentOutOfRangeException_$ctor_Z384F8060(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);
   }
+  /**
+   * Returns the body FsRow at the given index from the FsTable, i.e. all rows except the header row (if shown).
+   */
   GetBodyRowAt(index, cellsCollection) {
     const this$ = this;
     return this$.ShowHeaderRow ? this$.GetRowAt(index + 1, cellsCollection) : this$.GetRowAt(index, cellsCollection);
   }
+  /**
+   * Updates the FsRangeAddress of the FsTable according to the FsTableFields associated.
+   */
   RescanRange() {
     const this$ = this;
     const rangeAddress = reduce((r1, r2) => r1.Union(r2), map((v) => v.Column.RangeAddress, this$._fieldNames.values()));
     this$.RangeAddress = rangeAddress;
   }
+  /**
+   * Updates the FsRangeAddress of a given FsTable according to the FsTableFields associated.
+   */
   static rescanRange(table) {
     table.RescanRange();
     return table;
   }
+  /**
+   * Returns a unique name consisting of the original name and an initial offset that is raised
+   * if the original name with that offset is already present.
+   */
   GetUniqueName(originalName, initialOffset, enforceOffset) {
     const this$ = this;
     let name = originalName + (enforceOffset ? int32ToString(initialOffset) : "");
@@ -130,9 +174,16 @@ class FsTable extends FsRangeBase {
     addToSet(name, this$._uniqueNames);
     return name;
   }
+  /**
+   * Returns a unique name consisting of the original name and an initial offset that is raised
+   * if the original name with that offset is already present.
+   */
   static getUniqueNames(originalName, initialOffset, enforceOffset, table) {
     return table.GetUniqueName(originalName, initialOffset, enforceOffset);
   }
+  /**
+   * Creates and adds FsTableFields from a sequence of field names to the FsTable.
+   */
   InitFields(fieldNames) {
     const this$ = this;
     iterateIndexed((i, fn) => {
@@ -140,30 +191,42 @@ class FsTable extends FsRangeBase {
       addToDict(this$._fieldNames, fn, tableField);
     }, fieldNames);
   }
+  /**
+   * Creates and adds FsTableFields from a sequence of field names to a given FsTable.
+   */
   static initFields(fieldNames, table) {
     table.InitFields(fieldNames);
     return table;
   }
+  /**
+   * Adds a sequence of FsTableFields to the FsTable.
+   */
   AddFields(tableFields) {
     const this$ = this;
     iterate((tf) => {
       addToDict(this$._fieldNames, tf.Name, tf);
     }, tableFields);
   }
+  /**
+   * Adds a sequence of FsTableFields to a given FsTable.
+   */
   static addFields(tableFields, table) {
     table.AddFields(tableFields);
     return table;
   }
+  /**
+   * Returns the FsTableField with given name. If an FsTableField does not exist under this name in the FsTable, adds it.
+   */
   Field(name, cellsCollection) {
-    let s, offset;
+    let s = void 0, offset = void 0;
     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
+      const newField = new FsTableField(name, (s = map((v) => v.Index | 0, this$._fieldNames.values()), length(s) === 0 ? 0 : max(s, {
+        Compare: (x, y) => comparePrimitives(x, y) | 0
       })) + 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);
+        newField.HeaderCell(cellsCollection, true).SetValueAs(name);
       }
       addToDict(this$._fieldNames, name, newField);
       this$.RescanRange();
@@ -172,81 +235,139 @@ class FsTable extends FsRangeBase {
       return value(matchValue);
     }
   }
+  /**
+   * Takes a name of an FsTableField and an FsCellsCollection (belonging to the FsWorksheet of this
+   * FsTable) and returns the respective FsTableField.
+   */
   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 + "'.");
+      throw new Exception("The header row doesn't contain field name '" + name_1 + "'.");
     }
   }
+  /**
+   * Takes a name of an FsTableField and an FsCellsCollection (belonging to the FsWorksheet of this
+   * FsTable) and returns the respective FsTableField.
+   */
   static getField(name, cellsCollection, table) {
     return table.GetField(name, cellsCollection);
   }
+  /**
+   * Takes the index of an FsTableField and an FsCellsCollection (belonging to the FsWorksheet of
+   * this FsTable) and returns the respective FsTableField.
+   */
   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.`);
+      throw new Exception(`FsTableField with index ${index} does not exist in the FsTable.`);
     }
   }
+  /**
+   * Takes a name of an FsTableField and an FsCellsCollection (belonging to the FsWorksheet of
+   * this FsTable) and returns the index of the respective FsTableField.
+   */
   GetFieldIndex(name, cellsCollection) {
     const this$ = this;
     return this$.GetField(name, cellsCollection).Index | 0;
   }
+  /**
+   * Renames a fieldname of the FsTable if it exists. Else fails.
+   */
   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");
+      throw ArgumentException_$ctor_Z384F8060("The FsTabelField does not exist in this FsTable", "oldName");
     } else {
       const field = value(matchValue);
       this$._fieldNames.delete(oldName);
       addToDict(this$._fieldNames, newName, field);
     }
   }
+  /**
+   * Renames a fieldname of the FsTable if it exists. Else fails.
+   */
   static renameField(oldName, newName, table) {
     table.RenameField(oldName, newName);
     return table;
   }
+  /**
+   * Returns the header cell from a given FsCellsCollection with the given colum index if the cell exists. Else returns None.
+   */
   TryGetHeaderCellOfColumnAt(cellsCollection, colIndex) {
     const this$ = this;
     const fstRowIndex = this$.RangeAddress.FirstAddress.RowNumber | 0;
     return tryFind((c) => c.RowNumber === fstRowIndex, cellsCollection.GetCellsInColumn(colIndex));
   }
+  /**
+   * Returns the header cell from a given FsCellsCollection with the given column index in a given FsTable if the cell exists. Else
+   * returns None.
+   */
   static tryGetHeaderCellOfColumnIndexAt(cellsCollection, colIndex, table) {
     return table.TryGetHeaderCellOfColumnAt(cellsCollection, colIndex);
   }
+  /**
+   * Returns the header cell of a given FsRangeColumn from a given FsCellsCollection if the cell exists. Else returns None.
+   */
   TryGetHeaderCellOfColumn(cellsCollection, column) {
     const this$ = this;
     return this$.TryGetHeaderCellOfColumnAt(cellsCollection, column.Index);
   }
+  /**
+   * Returns the header cell of a given FsRangeColumn from a given FsCellsCollection in a given FsTable if the cell exists.
+   * Else returns None.
+   */
   static tryGetHeaderCellOfColumn(cellsCollection, column, table) {
     return table.TryGetHeaderCellOfColumn(cellsCollection, column);
   }
+  /**
+   * Returns the header cell from a given FsCellsCollection with the given colum index.
+   */
   GetHeaderCellOfColumnAt(cellsCollection, colIndex) {
     const this$ = this;
     return value(this$.TryGetHeaderCellOfColumnAt(cellsCollection, colIndex));
   }
+  /**
+   * Returns the header cell from a given FsCellsCollection with the given colum index in a given FsTable.
+   */
   static getHeaderCellOfColumnIndexAt(cellsCollection, colIndex, table) {
     return table.GetHeaderCellOfColumnAt(cellsCollection, colIndex);
   }
+  /**
+   * Returns the header cell of a given FsRangeColumn from a given FsCellsCollection.
+   */
   GetHeaderCellOfColumn(cellsCollection, column) {
     const this$ = this;
     return value(this$.TryGetHeaderCellOfColumn(cellsCollection, column));
   }
+  /**
+   * Returns the header cell of a given FsRangeColumn from a given FsCellsCollection in a given FsTable.
+   */
   static getHeaderCellOfColumn(cellsCollection, column, table) {
     return table.GetHeaderCellOfColumn(cellsCollection, column);
   }
+  /**
+   * Returns the header cell of a given FsTableField from a given FsCellsCollection.
+   */
   GetHeaderCellOfTableField(cellsCollection, tableField) {
     const this$ = this;
     return tableField.HeaderCell(cellsCollection, this$.ShowHeaderRow);
   }
+  /**
+   * Returns the header cell of a given FsTableField from a given FsCellsCollection in a given FsTable.
+   */
   static getHeaderCellOfTableField(cellsCollection, tableField, table) {
     return table.GetHeaderCellOfTableField(cellsCollection, tableField);
   }
+  /**
+   * Returns the header cell from an FsTableField with the given index using a given FsCellsCollection if the cell exists.
+   * Else returns None.
+   */
   TryGetHeaderCellOfTableFieldAt(cellsCollection, tableFieldIndex) {
     const this$ = this;
     return tryPick((tf) => {
@@ -257,16 +378,30 @@ class FsTable extends FsRangeBase {
       }
     }, this$._fieldNames.values());
   }
+  /**
+   * Returns the header cell from an FsTableField with the given index using a given FsCellsCollection if the cell exists
+   * in a given FsTable. Else returns None.
+   */
   static tryGetHeaderCellOfTableFieldIndexAt(cellsCollection, tableFieldIndex, table) {
     return table.TryGetHeaderCellOfTableFieldAt(cellsCollection, tableFieldIndex);
   }
+  /**
+   * Returns the header cell from an FsTableField with the given index using a given FsCellsCollection.
+   */
   GetHeaderCellOfTableFieldAt(cellsCollection, tableFieldIndex) {
     const this$ = this;
     return value(this$.TryGetHeaderCellOfTableFieldAt(cellsCollection, tableFieldIndex));
   }
+  /**
+   * Returns the header cell from an FsTableField with the given index using a given FsCellsCollection in a given FsTable.
+   */
   static getHeaderCellOfTableFieldIndexAt(cellsCollection, tableFieldIndex, table) {
     return table.GetHeaderCellOfTableFieldAt(cellsCollection, tableFieldIndex);
   }
+  /**
+   * Returns the header cell from an FsTableField with the given name using an FsCellsCollection in the FsTable if the cell exists.
+   * Else returns None.
+   */
   TryGetHeaderCellByFieldName(cellsCollection, fieldName) {
     const this$ = this;
     const matchValue = Dictionary_tryGet(fieldName, this$._fieldNames);
@@ -277,30 +412,54 @@ class FsTable extends FsRangeBase {
       return tf.HeaderCell(cellsCollection, this$.ShowHeaderRow);
     }
   }
+  /**
+   * Returns the header cell from an FsTableField with the given name using an FsCellsCollection in a given FsTable if the cell exists.
+   * Else returns None.
+   */
   static tryGetHeaderCellByFieldName(cellsCollection, fieldName, table) {
     return table.TryGetHeaderCellByFieldName(cellsCollection, fieldName);
   }
+  /**
+   * Returns the data cells from a given FsCellsCollection with the given colum index.
+   */
   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)));
   }
+  /**
+   * Returns the data cells from a given FsCellsCollection with the given colum index in a given FsTable.
+   */
   static getDataCellsOfColumnIndexAt(cellsCollection, colIndex, table) {
     return table.GetDataCellsOfColumnAt(cellsCollection, colIndex);
   }
+  /**
+   * Creates a deep copy of this FsTable.
+   */
   Copy() {
     const this$ = this;
     const ra = this$.RangeAddress.Copy();
     return new FsTable(this$.Name, ra, false, this$.ShowHeaderRow);
   }
+  /**
+   * Returns a deep copy of a given FsTable.
+   */
   static copy(table) {
     return table.Copy();
   }
+  /**
+   * Validates that the FsTable contains at least one body row.
+   */
   static validateForWrite(table, cellsCollection) {
-    let arg;
+    let arg = void 0;
     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");
+      throw ArgumentException_$ctor_Z384F8060((arg = table.Name, toText(printf("The table '%s' must contain at least one body row."))(arg)), "table");
     }
   }
+  /**
+   * Updates the TableFields according to the range of the table and the underlying cellcollection.
+   * 
+   * For this, maps over the range of the table and sets the header of the table fields to the value of the cell. If no cell value is set, the header value and the underlying cell value are set to a default value.
+   */
   RescanFieldNames(cellsCollection) {
     const this$ = this;
     if (this$.ShowHeaderRow) {
@@ -316,11 +475,11 @@ class FsTable extends FsRangeBase {
           if (matchValue == null) {
             if (name === defaultOf() !== (name === "")) {
               name = this$.GetUniqueName("Column", cellPos + 1, true);
-              const value = cell.SetValueAs(name);
-              cell.DataType = DataType_String();
+              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 + "'.");
+              throw ArgumentException_$ctor_Z721C83C5("The header row contains more than one field name '" + name + "'.");
             }
             addToDict(this$._fieldNames, name, new FsTableField(name, cellPos));
             cellPos = cellPos + 1 | 0;

package/dist/ts/ts/fable_modules/{FsSpreadsheet.7.0.0-alpha.1 → FsSpreadsheet.7.0.1}/Tables/FsTableField.fs.js

@@ -1,11 +1,11 @@
 import { FsRangeColumn } from '../Ranges/FsRangeColumn.fs.js';
-import { defaultOf, equals } from '../../../../node_modules/@fable-org/fable-library-js/Util.js';
+import { defaultOf, equals } from '../../../../node_modules/@fable-org/fable-library-ts/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';
+import { defaultArg, some } from '../../../../node_modules/@fable-org/fable-library-ts/Option.js';
+import { toFail, printf } from '../../../../node_modules/@fable-org/fable-library-ts/String.js';
+import { skip } from '../../../../node_modules/@fable-org/fable-library-ts/Seq.js';
+import { class_type } from '../../../../node_modules/@fable-org/fable-library-ts/Reflection.js';
 
 class FsTableField {
   constructor(name, index, column, totalsRowLabel, totalsRowFunction) {
@@ -16,18 +16,32 @@ class FsTableField {
     this._name = name;
     this["Column@"] = this._column;
   }
+  /**
+   * Gets or sets the FsRangeColumn of this FsTableField.
+   */
   get Column() {
     const __ = this;
     return __["Column@"];
   }
+  /**
+   * Gets or sets the FsRangeColumn of this FsTableField.
+   */
   set Column(v) {
     const __ = this;
     __["Column@"] = v;
   }
+  /**
+   * Gets or sets the 0-based index of the FsTableField inside the associated FsTable.
+   * Sets the associated FsRangeColumn's column index accordingly.
+   */
   get Index() {
     const this$ = this;
     return this$._index | 0;
   }
+  /**
+   * Gets or sets the 0-based index of the FsTableField inside the associated FsTable.
+   * Sets the associated FsRangeColumn's column index accordingly.
+   */
   set Index(index) {
     const this$ = this;
     if (index === this$._index) {
@@ -41,10 +55,17 @@ class FsTableField {
       }
     }
   }
+  /**
+   * The name of this FsTableField.
+   */
   get Name() {
     const this$ = this;
     return this$._name;
   }
+  /**
+   * Sets the name of the FsTableField. If `showHeaderRow` is true, takes the respective FsCellsCollection and renames the header cell
+   * according to the name of the FsTableField.
+   */
   SetName(name, cellsCollection, showHeaderRow) {
     const this$ = this;
     this$._name = name;
@@ -52,19 +73,32 @@ class FsTableField {
       this$.Column.FirstCell(cellsCollection).SetValueAs(name);
     }
   }
+  /**
+   * Sets the name of a given FsTableField. If `showHeaderRow` is true, takes the respective FsCellsCollection and renames the header cell
+   * according to the name of the FsTableField.
+   */
   static setName(name, cellsCollection, showHeaderRow, tableField) {
     tableField.SetName(name, cellsCollection, showHeaderRow);
     return tableField;
   }
+  /**
+   * Creates a deep copy of this FsTableField.
+   */
   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()));
   }
+  /**
+   * Returns a deep copy of a given FsTableField.
+   */
   static copy(tableField) {
     return tableField.Copy();
   }
+  /**
+   * Returns the header cell (taken from a given FsCellsCollection) for the FsTableField if `showHeaderRow` is true. Else fails.
+   */
   HeaderCell(cellsCollection, showHeaderRow) {
     const this$ = this;
     if (!showHeaderRow) {
@@ -74,13 +108,22 @@ class FsTableField {
       return this$.Column.FirstCell(cellsCollection);
     }
   }
+  /**
+   * Returns the header cell (taken from an FsCellsCollection) for a given FsTableField if `showHeaderRow` is true. Else fails.
+   */
   static getHeaderCell(cellsCollection, showHeaderRow, tableField) {
     return tableField.HeaderCell(cellsCollection, showHeaderRow);
   }
+  /**
+   * Gets the collection of data cells for this FsTableField. Excludes the header and footer cells.
+   */
   DataCells(cellsCollection) {
     const this$ = this;
     return skip(1, this$.Column.Cells(cellsCollection));
   }
+  /**
+   * Gets the collection of data cells for a given FsTableField. Excludes the header and footer cells.
+   */
   static getDataCells(cellsCollection, tableField) {
     return tableField.DataCells(cellsCollection);
   }

package/dist/ts/ts/fable_modules/FsSpreadsheet.Js.7.0.1/Cell.fs.js

@@ -0,0 +1,65 @@
+import { FsCell, DataType } from '../FsSpreadsheet.7.0.1/Cells/FsCell.fs.js';
+import { some, value } from '../../../node_modules/@fable-org/fable-library-ts/Option.js';
+import { fromDate, op_Addition, offset } from '../../../node_modules/@fable-org/fable-library-ts/DateOffset.js';
+import { FsAddress } from '../FsSpreadsheet.7.0.1/FsAddress.fs.js';
+import { toString } from '../../../node_modules/@fable-org/fable-library-ts/Types.js';
+import { parse as parse$1 } from '../../../node_modules/@fable-org/fable-library-ts/Double.js';
+import { parse } from '../../../node_modules/@fable-org/fable-library-ts/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;
+  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$1(vTemp));
+    case 3:
+      return createFscell(DataType.String$, vTemp);
+    case 4:
+      return createFscell(DataType.Date$, function(v) {
+        const d = new Date(v);
+        return new Date(d.getTime() + d.getTimezoneOffset() * 6e4);
+      }(value(jsCell.value)));
+    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 → FsSpreadsheet.Js.7.0.1}/FsExtensions.fs.js

@@ -1,6 +1,6 @@
 import { Xlsx } from './Xlsx.fs.js';
 import { Json } from './Json.fs.js';
-import { unwrap } from '../../../node_modules/@fable-org/fable-library-js/Option.js';
+import { unwrap } from '../../../node_modules/@fable-org/fable-library-ts/Option.js';
 
 function FsSpreadsheet_FsWorkbook__FsWorkbook_fromXlsxFile_Static_Z721C83C5(path) {
   return Xlsx.fromXlsxFile(path);