@nfdi4plants/arctrl 3.0.0-beta.2 → 3.0.0-beta.4

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

@@ -0,0 +1,126 @@
+import { FsRangeAddress } from './Ranges/FsRangeAddress.fs.js';
+import { FsAddress } from './FsAddress.fs.js';
+import { FsCellsCollection } from './Cells/FsCellsCollection.fs.js';
+import { map, exists, length, minBy, maxBy } from '../../../node_modules/@fable-org/fable-library-js/Seq.js';
+import { FsCell } from './Cells/FsCell.fs.js';
+import { getEnumerator, toIterator, comparePrimitives } from '../../../node_modules/@fable-org/fable-library-js/Util.js';
+import { FsRangeBase } from './Ranges/FsRangeBase.fs.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) {
+    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$);
+  }
+}
+
+export { FsRow };

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

@@ -0,0 +1,135 @@
+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 { safeHash, equals, defaultOf } from '../../../node_modules/@fable-org/fable-library-js/Util.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() {
+  }
+}
+
+export { FsWorkbook };

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

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

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

@@ -0,0 +1,5 @@
+function mergeHashes(hash1, hash2) {
+  return -1640531527 + hash2 + (hash1 << 6) + (hash1 >> 2);
+}
+
+export { mergeHashes };