@nfdi4plants/arctrl 3.1.1 → 3.2.0

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

@@ -1,56 +1,80 @@
 import { FsRangeAddress } from './Ranges/FsRangeAddress.fs.js';
 import { FsAddress } from './FsAddress.fs.js';
 import { FsCellsCollection } from './Cells/FsCellsCollection.fs.js';
-import { length, minBy, maxBy, map, exists } from '../../../node_modules/@fable-org/fable-library-js/Seq.js';
-import { comparePrimitives, getEnumerator, toIterator } from '../../../node_modules/@fable-org/fable-library-js/Util.js';
+import { length, minBy, maxBy, map, exists } from '../../../node_modules/@fable-org/fable-library-ts/Seq.js';
+import { comparePrimitives, getEnumerator, toIterator } from '../../../node_modules/@fable-org/fable-library-ts/Util.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 FsColumn extends FsRangeBase {
   constructor(rangeAddress, cells) {
     super(rangeAddress);
     this["cells@18"] = cells;
   }
+  /**
+   * Creates an empty FsColumn, ranging from row 0, column 0 to row 0, column (1-based).
+   */
   static empty() {
     return new FsColumn(new FsRangeAddress(new FsAddress(0, 0), new FsAddress(0, 0)), new FsCellsCollection());
   }
+  /**
+   * Create an FsColumn from a given FsCellsCollection and an columnColumn.
+   */
   static createAt(index, cells) {
     const getIndexBy = (f) => {
       if (length(cells.GetCellsInColumn(index)) === 0) {
         return 1;
       } else {
-        return f((c) => c.Address.RowNumber)(cells.GetCellsInColumn(index)).Address.RowNumber | 0;
+        return f((c) => c.Address.RowNumber | 0)(cells.GetCellsInColumn(index)).Address.RowNumber | 0;
       }
     };
     const minRowIndex = getIndexBy((projection) => (source_1) => minBy(projection, source_1, {
-      Compare: comparePrimitives
+      Compare: (x, y) => comparePrimitives(x, y) | 0
     })) | 0;
     const maxRowIndex = getIndexBy((projection_1) => (source_2) => maxBy(projection_1, source_2, {
-      Compare: comparePrimitives
+      Compare: (x_1, y_1) => comparePrimitives(x_1, y_1) | 0
     })) | 0;
     return new FsColumn(new FsRangeAddress(new FsAddress(minRowIndex, index), new FsAddress(maxRowIndex, index)), cells);
   }
+  /**
+   * The associated FsCells.
+   */
   get Cells() {
     const this$ = this;
     return super.Cells(this$["cells@18"]);
   }
+  /**
+   * The index of the FsColumn.
+   */
   get Index() {
     const this$ = this;
     return this$.RangeAddress.FirstAddress.ColumnNumber | 0;
   }
+  /**
+   * The index of the FsColumn.
+   */
   set Index(i) {
     const this$ = this;
     this$.RangeAddress.FirstAddress.ColumnNumber = i | 0;
     this$.RangeAddress.LastAddress.ColumnNumber = i | 0;
   }
+  /**
+   * The number of the lowest row index of the FsColumn where an FsCell exists.
+   */
   get MinRowIndex() {
     const this$ = this;
     return this$.RangeAddress.FirstAddress.RowNumber | 0;
   }
+  /**
+   * The number of the highest row index of the FsColumn where an FsCell exists.
+   */
   get MaxRowIndex() {
     const this$ = this;
     return this$.RangeAddress.LastAddress.RowNumber | 0;
   }
+  /**
+   * Creates a deep copy of this FsColumn.
+   */
   Copy() {
     const this$ = this;
     const ra = this$.RangeAddress.Copy();
@@ -59,43 +83,82 @@ class FsColumn extends FsRangeBase {
     fcc.AddMany(cells);
     return new FsColumn(ra, fcc);
   }
+  /**
+   * Returns a deep copy of a given FsColumn.
+   */
   static copy(column) {
     return column.Copy();
   }
+  /**
+   * Returns the index of the given FsColumn.
+   */
   static getIndex(column) {
-    return column.Index;
+    return column.Index | 0;
   }
+  /**
+   * Checks if there is an FsCell at given row index.
+   */
   HasCellAt(rowIndex) {
     const this$ = this;
     return exists((c) => c.RowNumber === rowIndex, this$.Cells);
   }
+  /**
+   * Checks if there is an FsCell at given row index of a given FsColumn.
+   */
   static hasCellAt(rowIndex, column) {
     return column.HasCellAt(rowIndex);
   }
+  /**
+   * Returns the FsCell at rowIndex.
+   */
   Item(rowIndex) {
     const this$ = this;
     return super.Cell(new FsAddress(rowIndex, 1), this$["cells@18"]);
   }
+  /**
+   * Returns the FsCell at the given rowIndex from an FsColumn.
+   */
   static item(rowIndex, column) {
     return column.Item(rowIndex);
   }
+  /**
+   * Returns the FsCell at the given rowIndex if it exists. Else returns None.
+   */
   TryItem(rowIndex) {
     const this$ = this;
     return this$.HasCellAt(rowIndex) ? this$.Item(rowIndex) : void 0;
   }
+  /**
+   * Returns the FsCell at the given rowIndex if it exists in the given FsColumn. Else returns None.
+   */
   static tryItem(rowIndex, column) {
     return column.TryItem(rowIndex);
   }
+  /**
+   * Transforms the FsColumn into a dense FsColumn.
+   * 
+   * FsColumns are sparse by default. This means there are no FsCells present between positions with that are filled with FsCells. In dense FsColumns, such "empty positions" are then filled with empty FsCells.
+   */
   ToDenseColumn() {
     const this$ = this;
     for (let i = this$.MinRowIndex; i <= this$.MaxRowIndex; i++) {
       this$.Item(i);
     }
   }
+  /**
+   * Transforms the given FsColumn into a dense FsColumn.
+   * 
+   * FsColumns are sparse by default. This means there are no FsCells present between positions with that are filled with FsCells. In dense FsColumns, such "empty positions" are then filled with empty FsCells.
+   */
   static toDenseColumn(column) {
     column.ToDenseColumn();
     return column;
   }
+  /**
+   * Takes a given FsColumn and returns a new dense FsColumn from it.
+   * 
+   * FsColumns are sparse by default. This means there are no FsCells present between positions with that are filled with FsCells. In dense FsColumns, such "empty positions" are then filled with empty FsCells.
+   */
   static createDenseColumnOf(column) {
     const newColumn = column.Copy();
     newColumn.ToDenseColumn();

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

@@ -1,11 +1,11 @@
 import { FsRangeAddress } from './Ranges/FsRangeAddress.fs.js';
 import { FsAddress } from './FsAddress.fs.js';
 import { FsCellsCollection } from './Cells/FsCellsCollection.fs.js';
-import { length, minBy, maxBy, map, exists } from '../../../node_modules/@fable-org/fable-library-js/Seq.js';
+import { length, minBy, maxBy, map, exists } from '../../../node_modules/@fable-org/fable-library-ts/Seq.js';
 import { FsCell } from './Cells/FsCell.fs.js';
-import { comparePrimitives, getEnumerator, toIterator } from '../../../node_modules/@fable-org/fable-library-js/Util.js';
+import { comparePrimitives, getEnumerator, toIterator } from '../../../node_modules/@fable-org/fable-library-ts/Util.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 FsRow extends FsRangeBase {
   constructor(rangeAddress, cells) {
@@ -15,43 +15,64 @@ class FsRow extends FsRangeBase {
   static empty() {
     return new FsRow(new FsRangeAddress(new FsAddress(0, 0), new FsAddress(0, 0)), new FsCellsCollection());
   }
+  /**
+   * Creates an FsRow from a given FsCellsCollection and an rowIndex.
+   */
   static createAt(index, cells) {
     const getIndexBy = (f) => {
       if (length(cells.GetCellsInRow(index)) === 0) {
         return 1;
       } else {
-        return f((c) => c.Address.ColumnNumber)(cells.GetCellsInRow(index)).Address.ColumnNumber | 0;
+        return f((c) => c.Address.ColumnNumber | 0)(cells.GetCellsInRow(index)).Address.ColumnNumber | 0;
       }
     };
     const minColIndex = getIndexBy((projection) => (source_1) => minBy(projection, source_1, {
-      Compare: comparePrimitives
+      Compare: (x, y) => comparePrimitives(x, y) | 0
     })) | 0;
     const maxColIndex = getIndexBy((projection_1) => (source_2) => maxBy(projection_1, source_2, {
-      Compare: comparePrimitives
+      Compare: (x_1, y_1) => comparePrimitives(x_1, y_1) | 0
     })) | 0;
     return new FsRow(new FsRangeAddress(new FsAddress(index, minColIndex), new FsAddress(index, maxColIndex)), cells);
   }
+  /**
+   * The associated FsCells.
+   */
   get Cells() {
     const this$ = this;
     return super.Cells(this$["cells@21"]);
   }
+  /**
+   * The index of the FsRow.
+   */
   get Index() {
     const this$ = this;
     return this$.RangeAddress.FirstAddress.RowNumber | 0;
   }
+  /**
+   * The index of the FsRow.
+   */
   set Index(i) {
     const this$ = this;
     this$.RangeAddress.FirstAddress.RowNumber = i | 0;
     this$.RangeAddress.LastAddress.RowNumber = i | 0;
   }
+  /**
+   * The number of the lowest column index of the FsRow where an FsCell exists.
+   */
   get MinColIndex() {
     const this$ = this;
     return this$.RangeAddress.FirstAddress.ColumnNumber | 0;
   }
+  /**
+   * The number of the highest column index of the FsRow where an FsCell exists.
+   */
   get MaxColIndex() {
     const this$ = this;
     return this$.RangeAddress.LastAddress.ColumnNumber | 0;
   }
+  /**
+   * Creates a deep copy of this FsRow.
+   */
   Copy() {
     const this$ = this;
     const ra = this$.RangeAddress.Copy();
@@ -60,52 +81,99 @@ class FsRow extends FsRangeBase {
     fcc.AddMany(cells);
     return new FsRow(ra, fcc);
   }
+  /**
+   * Returns a deep copy of a given FsRow.
+   */
   static copy(row) {
     return row.Copy();
   }
+  /**
+   * Returns the index of the given FsRow.
+   */
   static getIndex(row) {
-    return row.Index;
+    return row.Index | 0;
   }
+  /**
+   * Checks if there is an FsCell at given column index.
+   */
   HasCellAt(colIndex) {
     const this$ = this;
     return exists((c) => c.ColumnNumber === colIndex, this$.Cells);
   }
+  /**
+   * Checks if there is an FsCell at given column index of a given FsRow.
+   */
   static hasCellAt(colIndex, row) {
     return row.HasCellAt(colIndex);
   }
+  /**
+   * Returns the FsCell at columnIndex if it exists. Else creates an empty FsCell at that position.
+   */
   Item(columnIndex) {
     const this$ = this;
     return super.Cell(new FsAddress(1, columnIndex), this$["cells@21"]);
   }
+  /**
+   * Returns the FsCell at the given columnIndex from an FsRow if it exists. Else creates an ampty FsCell at that position.
+   */
   static item(colIndex, row) {
     return row.Item(colIndex);
   }
+  /**
+   * Returns the FsCell at the given columnIndex if it exists. Else returns None.
+   */
   TryItem(colIndex) {
     const this$ = this;
     return this$.HasCellAt(colIndex) ? this$.Item(colIndex) : void 0;
   }
+  /**
+   * Returns the FsCell at the given columnIndex if it exists in the given FsRow. Else returns None.
+   */
   static tryItem(colIndex, row) {
     return row.TryItem(colIndex);
   }
+  /**
+   * Inserts the value at columnIndex as an FsCell. If there is an FsCell at the position, this FsCells and all the ones right to it are shifted to the right.
+   */
   InsertValueAt(colIndex, value) {
     const this$ = this;
     const cell = new FsCell(value);
     this$["cells@21"].Add(cell, this$.Index, colIndex);
   }
+  /**
+   * Adds a value at the given row- and columnIndex to FsRow using.
+   * 
+   * If a cell exists in the given position, shoves it to the right.
+   */
   static insertValueAt(colIndex, value, row) {
-    const value_1 = row.InsertValueAt(colIndex, value);
+    row.InsertValueAt(colIndex, value);
     return row;
   }
+  /**
+   * Transforms the FsRow into a dense FsRow.
+   * 
+   * FsRows are sparse by default. This means there are no FsCells present between positions with that are filled with FsCells. In dense FsRows, such "empty positions" are then filled with empty FsCells.
+   */
   ToDenseRow() {
     const this$ = this;
     for (let i = this$.MinColIndex; i <= this$.MaxColIndex; i++) {
       this$.Item(i);
     }
   }
+  /**
+   * Transforms the given FsRow into a dense FsRow.
+   * 
+   * FsRows are sparse by default. This means there are no FsCells present between positions with that are filled with FsCells. In dense FsRows, such "empty positions" are then filled with empty FsCells.
+   */
   static toDenseRow(row) {
     row.ToDenseRow();
     return row;
   }
+  /**
+   * Takes a given FsRow and returns a new dense FsRow from it.
+   * 
+   * FsRows are sparse by default. This means there are no FsCells present between positions with that are filled with FsCells. In dense FsRows, such "empty positions" are then filled with empty FsCells.
+   */
   static createDenseRowOf(row) {
     const newRow = row.Copy();
     newRow.ToDenseRow();

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

@@ -1,15 +1,18 @@
-import { map, removeInPlace, tryFind as tryFind$1, collect } from '../../../node_modules/@fable-org/fable-library-js/Array.js';
+import { map, removeInPlace, tryFind as tryFind$1, collect } from '../../../node_modules/@fable-org/fable-library-ts/Array.js';
 import { FsWorksheet } from './FsWorksheet.fs.js';
-import { exists, iterate, tryItem, tryFind } from '../../../node_modules/@fable-org/fable-library-js/Seq.js';
-import { toFail, printf } from '../../../node_modules/@fable-org/fable-library-js/String.js';
-import { value, defaultArg } from '../../../node_modules/@fable-org/fable-library-js/Option.js';
-import { defaultOf, safeHash, equals } from '../../../node_modules/@fable-org/fable-library-js/Util.js';
-import { class_type } from '../../../node_modules/@fable-org/fable-library-js/Reflection.js';
+import { Exception, defaultOf, safeHash, equals } from '../../../node_modules/@fable-org/fable-library-ts/Util.js';
+import { exists, iterate, tryItem, tryFind } from '../../../node_modules/@fable-org/fable-library-ts/Seq.js';
+import { toFail, printf, concat } from '../../../node_modules/@fable-org/fable-library-ts/String.js';
+import { value, defaultArg } from '../../../node_modules/@fable-org/fable-library-ts/Option.js';
+import { class_type } from '../../../node_modules/@fable-org/fable-library-ts/Reflection.js';
 
 class FsWorkbook {
   constructor() {
     this._worksheets = [];
   }
+  /**
+   * Creates a deep copy of this FsWorkbook.
+   */
   Copy() {
     const self = this;
     const shts = map((s) => s.Copy(), self.GetWorksheets().slice());
@@ -17,18 +20,30 @@ class FsWorkbook {
     wb.AddWorksheets(shts);
     return wb;
   }
+  /**
+   * Returns a deep copy of a given FsWorkbook.
+   */
   static copy(workbook) {
     return workbook.Copy();
   }
+  /**
+   * Creates an empty FsWorksheet with given name and adds it to the FsWorkbook.
+   */
   InitWorksheet(name) {
     const self = this;
     const sheet = new FsWorksheet(name);
     void self._worksheets.push(sheet);
     return sheet;
   }
+  /**
+   * Creates an empty FsWorksheet with given name and adds it to the FsWorkbook.
+   */
   static initWorksheet(name, workbook) {
     return workbook.InitWorksheet(name);
   }
+  /**
+   * Adds a given FsWorksheet to the FsWorkbook.
+   */
   AddWorksheet(sheet) {
     const self = this;
     if (exists((ws) => ws.Name === sheet.Name, self._worksheets)) {
@@ -38,85 +53,136 @@ class FsWorkbook {
       void self._worksheets.push(sheet);
     }
   }
+  /**
+   * Adds an FsWorksheet to an FsWorkbook.
+   */
   static addWorksheet(sheet, workbook) {
     workbook.AddWorksheet(sheet);
     return workbook;
   }
+  /**
+   * Adds a collection of FsWorksheets to the FsWorkbook.
+   */
   AddWorksheets(sheets) {
     const self = this;
     iterate((sheet) => {
       self.AddWorksheet(sheet);
     }, sheets);
   }
+  /**
+   * Adds a collection of FsWorksheets to an FsWorkbook.
+   */
   static addWorksheets(sheets, workbook) {
     workbook.AddWorksheets(sheets);
     return workbook;
   }
+  /**
+   * Returns all FsWorksheets.
+   */
   GetWorksheets() {
     const self = this;
     return self._worksheets;
   }
+  /**
+   * Returns all FsWorksheets.
+   */
   static getWorksheets(workbook) {
     return workbook.GetWorksheets();
   }
+  /**
+   * Returns the FsWorksheet with the given 1 based index if it exists. Else returns None.
+   */
   TryGetWorksheetAt(index) {
     const self = this;
     return tryItem(index - 1, self._worksheets);
   }
+  /**
+   * Returns the FsWorksheet with the given 1 based index if it exists in a given FsWorkbook. Else returns None.
+   */
   static tryGetWorksheetAt(index, workbook) {
     return workbook.TryGetWorksheetAt(index);
   }
+  /**
+   * Returns the FsWorksheet with the given 1 based index.
+   */
   GetWorksheetAt(index) {
     const self = this;
     const matchValue = self.TryGetWorksheetAt(index);
     if (matchValue == null) {
-      throw new Error(`FsWorksheet at position ${index} is not present in the FsWorkbook.`);
+      throw new Exception(`FsWorksheet at position ${index} is not present in the FsWorkbook.`);
     } else {
       return value(matchValue);
     }
   }
+  /**
+   * Returns the FsWorksheet with the given the given 1 based indexk.
+   */
   static getWorksheetAt(index, workbook) {
     return workbook.GetWorksheetAt(index);
   }
+  /**
+   * Returns the FsWorksheet with the given name if it exists in the FsWorkbook. Else returns None.
+   */
   TryGetWorksheetByName(sheetName) {
     const self = this;
     return tryFind((w) => w.Name === sheetName, self._worksheets);
   }
+  /**
+   * Returns the FsWorksheet with the given name if it exists in a given FsWorkbook. Else returns None.
+   */
   static tryGetWorksheetByName(sheetName, workbook) {
     return workbook.TryGetWorksheetByName(sheetName);
   }
+  /**
+   * Returns the FsWorksheet with the given name.
+   */
   GetWorksheetByName(sheetName) {
     const self = this;
     try {
       return value(self.TryGetWorksheetByName(sheetName));
     } catch (matchValue) {
-      throw new Error(`FsWorksheet with name ${sheetName} is not present in the FsWorkbook.`);
+      throw new Exception(concat("FsWorksheet with name ", sheetName, " is not present in the FsWorkbook."));
     }
   }
+  /**
+   * Returns the FsWorksheet with the given name from an FsWorkbook.
+   */
   static getWorksheetByName(sheetName, workbook) {
     return workbook.GetWorksheetByName(sheetName);
   }
+  /**
+   * Removes an FsWorksheet with given name.
+   */
   RemoveWorksheet(name) {
     const self = this;
     removeInPlace((() => {
       try {
         return defaultArg(tryFind$1((ws) => ws.Name === name, self._worksheets), defaultOf());
       } catch (matchValue) {
-        throw new Error(`FsWorksheet with name ${name} was not found in FsWorkbook.`);
+        throw new Exception(concat("FsWorksheet with name ", name, " was not found in FsWorkbook."));
       }
     })(), self._worksheets, {
       Equals: equals,
-      GetHashCode: safeHash
+      GetHashCode: (x) => safeHash(x) | 0
     });
   }
+  /**
+   * Removes an FsWorksheet with given name from an FsWorkbook.
+   */
   static removeWorksheet(name, workbook) {
     workbook.RemoveWorksheet(name);
     return workbook;
   }
+  /**
+   * Returns all FsTables from the FsWorkbook.
+   */
   GetTables() {
     const self = this;
     return collect((s) => Array.from(s.Tables), self.GetWorksheets().slice());
   }
+  /**
+   * Returns all FsTables from an FsWorkbook.
+   */
   static getTables(workbook) {
     return workbook.GetTables();
   }
@@ -126,7 +192,7 @@ class FsWorkbook {
         FsWorksheet.validateForWrite(ws);
       }, workbook.GetWorksheets());
     } catch (ex) {
-      throw new Error(`FsWorkbook could not be validated for write: ${ex.message}`);
+      throw new Exception(concat("FsWorkbook could not be validated for write: ", ex.message));
     }
   }
   Dispose() {