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

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

@@ -0,0 +1,123 @@
+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 { FsRangeBase, FsRangeBase_$reflection } from './Ranges/FsRangeBase.fs.js';
+import { class_type } from '../../../node_modules/@fable-org/fable-library-js/Reflection.js';
+
+class FsColumn extends FsRangeBase {
+  constructor(rangeAddress, cells) {
+    super(rangeAddress);
+    this["cells@18"] = cells;
+  }
+  static empty() {
+    return new FsColumn(new FsRangeAddress(new FsAddress(0, 0), new FsAddress(0, 0)), new FsCellsCollection());
+  }
+  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;
+      }
+    };
+    const minRowIndex = getIndexBy((projection) => (source_1) => minBy(projection, source_1, {
+      Compare: comparePrimitives
+    })) | 0;
+    const maxRowIndex = getIndexBy((projection_1) => (source_2) => maxBy(projection_1, source_2, {
+      Compare: comparePrimitives
+    })) | 0;
+    return new FsColumn(new FsRangeAddress(new FsAddress(minRowIndex, index), new FsAddress(maxRowIndex, index)), cells);
+  }
+  get Cells() {
+    const this$ = this;
+    return super.Cells(this$["cells@18"]);
+  }
+  get Index() {
+    const this$ = this;
+    return this$.RangeAddress.FirstAddress.ColumnNumber | 0;
+  }
+  set Index(i) {
+    const this$ = this;
+    this$.RangeAddress.FirstAddress.ColumnNumber = i | 0;
+    this$.RangeAddress.LastAddress.ColumnNumber = i | 0;
+  }
+  get MinRowIndex() {
+    const this$ = this;
+    return this$.RangeAddress.FirstAddress.RowNumber | 0;
+  }
+  get MaxRowIndex() {
+    const this$ = this;
+    return this$.RangeAddress.LastAddress.RowNumber | 0;
+  }
+  Copy() {
+    const this$ = this;
+    const ra = this$.RangeAddress.Copy();
+    const cells = map((c) => c.Copy(), this$.Cells);
+    const fcc = new FsCellsCollection();
+    fcc.AddMany(cells);
+    return new FsColumn(ra, fcc);
+  }
+  static copy(column) {
+    return column.Copy();
+  }
+  static getIndex(column) {
+    return column.Index;
+  }
+  HasCellAt(rowIndex) {
+    const this$ = this;
+    return exists((c) => c.RowNumber === rowIndex, this$.Cells);
+  }
+  static hasCellAt(rowIndex, column) {
+    return column.HasCellAt(rowIndex);
+  }
+  Item(rowIndex) {
+    const this$ = this;
+    return super.Cell(new FsAddress(rowIndex, 1), this$["cells@18"]);
+  }
+  static item(rowIndex, column) {
+    return column.Item(rowIndex);
+  }
+  TryItem(rowIndex) {
+    const this$ = this;
+    return this$.HasCellAt(rowIndex) ? this$.Item(rowIndex) : void 0;
+  }
+  static tryItem(rowIndex, column) {
+    return column.TryItem(rowIndex);
+  }
+  ToDenseColumn() {
+    const this$ = this;
+    for (let i = this$.MinRowIndex; i <= this$.MaxRowIndex; i++) {
+      this$.Item(i);
+    }
+  }
+  static toDenseColumn(column) {
+    column.ToDenseColumn();
+    return column;
+  }
+  static createDenseColumnOf(column) {
+    const newColumn = column.Copy();
+    newColumn.ToDenseColumn();
+    return newColumn;
+  }
+  GetEnumerator() {
+    const this$ = this;
+    return getEnumerator(this$.Cells);
+  }
+  [Symbol.iterator]() {
+    return toIterator(getEnumerator(this));
+  }
+  "System.Collections.IEnumerable.GetEnumerator"() {
+    const this$ = this;
+    return getEnumerator(this$);
+  }
+}
+function FsColumn_$reflection() {
+  return class_type("FsSpreadsheet.FsColumn", void 0, FsColumn, FsRangeBase_$reflection());
+}
+function FsColumn_$ctor_7678C70A(rangeAddress, cells) {
+  return new FsColumn(rangeAddress, cells);
+}
+
+export { FsColumn, FsColumn_$ctor_7678C70A, FsColumn_$reflection };

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

@@ -0,0 +1,133 @@
+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 { FsCell } from './Cells/FsCell.fs.js';
+import { comparePrimitives, getEnumerator, toIterator } from '../../../node_modules/@fable-org/fable-library-js/Util.js';
+import { FsRangeBase, FsRangeBase_$reflection } from './Ranges/FsRangeBase.fs.js';
+import { class_type } from '../../../node_modules/@fable-org/fable-library-js/Reflection.js';
+
+class FsRow extends FsRangeBase {
+  constructor(rangeAddress, cells) {
+    super(rangeAddress);
+    this["cells@21"] = cells;
+  }
+  static empty() {
+    return new FsRow(new FsRangeAddress(new FsAddress(0, 0), new FsAddress(0, 0)), new FsCellsCollection());
+  }
+  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;
+      }
+    };
+    const minColIndex = getIndexBy((projection) => (source_1) => minBy(projection, source_1, {
+      Compare: comparePrimitives
+    })) | 0;
+    const maxColIndex = getIndexBy((projection_1) => (source_2) => maxBy(projection_1, source_2, {
+      Compare: comparePrimitives
+    })) | 0;
+    return new FsRow(new FsRangeAddress(new FsAddress(index, minColIndex), new FsAddress(index, maxColIndex)), cells);
+  }
+  get Cells() {
+    const this$ = this;
+    return super.Cells(this$["cells@21"]);
+  }
+  get Index() {
+    const this$ = this;
+    return this$.RangeAddress.FirstAddress.RowNumber | 0;
+  }
+  set Index(i) {
+    const this$ = this;
+    this$.RangeAddress.FirstAddress.RowNumber = i | 0;
+    this$.RangeAddress.LastAddress.RowNumber = i | 0;
+  }
+  get MinColIndex() {
+    const this$ = this;
+    return this$.RangeAddress.FirstAddress.ColumnNumber | 0;
+  }
+  get MaxColIndex() {
+    const this$ = this;
+    return this$.RangeAddress.LastAddress.ColumnNumber | 0;
+  }
+  Copy() {
+    const this$ = this;
+    const ra = this$.RangeAddress.Copy();
+    const cells = map((c) => c.Copy(), this$.Cells);
+    const fcc = new FsCellsCollection();
+    fcc.AddMany(cells);
+    return new FsRow(ra, fcc);
+  }
+  static copy(row) {
+    return row.Copy();
+  }
+  static getIndex(row) {
+    return row.Index;
+  }
+  HasCellAt(colIndex) {
+    const this$ = this;
+    return exists((c) => c.ColumnNumber === colIndex, this$.Cells);
+  }
+  static hasCellAt(colIndex, row) {
+    return row.HasCellAt(colIndex);
+  }
+  Item(columnIndex) {
+    const this$ = this;
+    return super.Cell(new FsAddress(1, columnIndex), this$["cells@21"]);
+  }
+  static item(colIndex, row) {
+    return row.Item(colIndex);
+  }
+  TryItem(colIndex) {
+    const this$ = this;
+    return this$.HasCellAt(colIndex) ? this$.Item(colIndex) : void 0;
+  }
+  static tryItem(colIndex, row) {
+    return row.TryItem(colIndex);
+  }
+  InsertValueAt(colIndex, value) {
+    const this$ = this;
+    const cell = new FsCell(value);
+    this$["cells@21"].Add(cell, this$.Index, colIndex);
+  }
+  static insertValueAt(colIndex, value, row) {
+    const value_1 = row.InsertValueAt(colIndex, value);
+    return row;
+  }
+  ToDenseRow() {
+    const this$ = this;
+    for (let i = this$.MinColIndex; i <= this$.MaxColIndex; i++) {
+      this$.Item(i);
+    }
+  }
+  static toDenseRow(row) {
+    row.ToDenseRow();
+    return row;
+  }
+  static createDenseRowOf(row) {
+    const newRow = row.Copy();
+    newRow.ToDenseRow();
+    return newRow;
+  }
+  GetEnumerator() {
+    const this$ = this;
+    return getEnumerator(this$.Cells);
+  }
+  [Symbol.iterator]() {
+    return toIterator(getEnumerator(this));
+  }
+  "System.Collections.IEnumerable.GetEnumerator"() {
+    const this$ = this;
+    return getEnumerator(this$);
+  }
+}
+function FsRow_$reflection() {
+  return class_type("FsSpreadsheet.FsRow", void 0, FsRow, FsRangeBase_$reflection());
+}
+function FsRow_$ctor_7678C70A(rangeAddress, cells) {
+  return new FsRow(rangeAddress, cells);
+}
+
+export { FsRow, FsRow_$ctor_7678C70A, FsRow_$reflection };

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

@@ -0,0 +1,142 @@
+import { map, removeInPlace, tryFind as tryFind$1, collect } from '../../../node_modules/@fable-org/fable-library-js/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';
+
+class FsWorkbook {
+  constructor() {
+    this._worksheets = [];
+  }
+  Copy() {
+    const self = this;
+    const shts = map((s) => s.Copy(), self.GetWorksheets().slice());
+    const wb = new FsWorkbook();
+    wb.AddWorksheets(shts);
+    return wb;
+  }
+  static copy(workbook) {
+    return workbook.Copy();
+  }
+  InitWorksheet(name) {
+    const self = this;
+    const sheet = new FsWorksheet(name);
+    void self._worksheets.push(sheet);
+    return sheet;
+  }
+  static initWorksheet(name, workbook) {
+    return workbook.InitWorksheet(name);
+  }
+  AddWorksheet(sheet) {
+    const self = this;
+    if (exists((ws) => ws.Name === sheet.Name, self._worksheets)) {
+      const arg = sheet.Name;
+      toFail(printf('Could not add worksheet with name "%s" to workbook as it already contains a worksheet with the same name'))(arg);
+    } else {
+      void self._worksheets.push(sheet);
+    }
+  }
+  static addWorksheet(sheet, workbook) {
+    workbook.AddWorksheet(sheet);
+    return workbook;
+  }
+  AddWorksheets(sheets) {
+    const self = this;
+    iterate((sheet) => {
+      self.AddWorksheet(sheet);
+    }, sheets);
+  }
+  static addWorksheets(sheets, workbook) {
+    workbook.AddWorksheets(sheets);
+    return workbook;
+  }
+  GetWorksheets() {
+    const self = this;
+    return self._worksheets;
+  }
+  static getWorksheets(workbook) {
+    return workbook.GetWorksheets();
+  }
+  TryGetWorksheetAt(index) {
+    const self = this;
+    return tryItem(index - 1, self._worksheets);
+  }
+  static tryGetWorksheetAt(index, workbook) {
+    return workbook.TryGetWorksheetAt(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.`);
+    } else {
+      return value(matchValue);
+    }
+  }
+  static getWorksheetAt(index, workbook) {
+    return workbook.GetWorksheetAt(index);
+  }
+  TryGetWorksheetByName(sheetName) {
+    const self = this;
+    return tryFind((w) => w.Name === sheetName, self._worksheets);
+  }
+  static tryGetWorksheetByName(sheetName, workbook) {
+    return workbook.TryGetWorksheetByName(sheetName);
+  }
+  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.`);
+    }
+  }
+  static getWorksheetByName(sheetName, workbook) {
+    return workbook.GetWorksheetByName(sheetName);
+  }
+  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.`);
+      }
+    })(), self._worksheets, {
+      Equals: equals,
+      GetHashCode: safeHash
+    });
+  }
+  static removeWorksheet(name, workbook) {
+    workbook.RemoveWorksheet(name);
+    return workbook;
+  }
+  GetTables() {
+    const self = this;
+    return collect((s) => Array.from(s.Tables), self.GetWorksheets().slice());
+  }
+  static getTables(workbook) {
+    return workbook.GetTables();
+  }
+  static validateForWrite(workbook) {
+    try {
+      iterate((ws) => {
+        FsWorksheet.validateForWrite(ws);
+      }, workbook.GetWorksheets());
+    } catch (ex) {
+      throw new Error(`FsWorkbook could not be validated for write: ${ex.message}`);
+    }
+  }
+  Dispose() {
+  }
+}
+function FsWorkbook_$reflection() {
+  return class_type("FsSpreadsheet.FsWorkbook", void 0, FsWorkbook);
+}
+function FsWorkbook_$ctor() {
+  return new FsWorkbook();
+}
+
+export { FsWorkbook, FsWorkbook_$ctor, FsWorkbook_$reflection };