@nfdi4plants/arctrl 3.0.0-beta.5 → 3.0.0-beta.6

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

@@ -1,13 +1,16 @@
 import { parse } from '../../../node_modules/@fable-org/fable-library-js/Int32.js';
-import { toFail, toText, printf } from '../../../node_modules/@fable-org/fable-library-js/String.js';
+import { toText, printf, toFail } from '../../../node_modules/@fable-org/fable-library-js/String.js';
 import { StringBuilder_$ctor, StringBuilder__Append_244C7CD6 } from '../../../node_modules/@fable-org/fable-library-js/System.Text.js';
 import { iterate } from '../../../node_modules/@fable-org/fable-library-js/Seq.js';
 import { isLetter, isDigit } from '../../../node_modules/@fable-org/fable-library-js/Char.js';
 import { toString } from '../../../node_modules/@fable-org/fable-library-js/Types.js';
+import { toInt64, op_Addition, fromUInt32, fromInt32, toUInt32 } from '../../../node_modules/@fable-org/fable-library-js/BigInt.js';
 import { value, unwrap } from '../../../node_modules/@fable-org/fable-library-js/Option.js';
 import { stringHash, identityHash } from '../../../node_modules/@fable-org/fable-library-js/Util.js';
 import { mergeHashes } from './HashCodes.fs.js';
+import { class_type } from '../../../node_modules/@fable-org/fable-library-js/Reflection.js';
 
+const CellReference_indexRegex = /([A-Z]*)(\d*)/gu;
 function CellReference_colAdressToIndex(columnAdress) {
   const length = columnAdress.length | 0;
   let sum = 0;
@@ -35,6 +38,7 @@ function CellReference_indexToColAdress(i) {
           acc_mut = String.fromCharCode(("A".charCodeAt(0) >>> 0) + mod26) + acc;
           continue loop;
         }
+        break;
       }
   };
   return loop(i, "");
@@ -57,6 +61,32 @@ function CellReference_toIndices(reference) {
   }, reference.split(""));
   return [CellReference_colAdressToIndex(toString(charPart)), parse(toString(numPart), 511, true, 32)];
 }
+function CellReference_toColIndex(reference) {
+  return CellReference_toIndices(reference)[0];
+}
+function CellReference_toRowIndex(reference) {
+  return CellReference_toIndices(reference)[1];
+}
+function CellReference_setColIndex(colI, reference) {
+  return CellReference_ofIndices(colI, CellReference_toIndices(reference)[1]);
+}
+function CellReference_setRowIndex(rowI, reference) {
+  return CellReference_ofIndices(CellReference_toIndices(reference)[0], rowI);
+}
+function CellReference_moveHorizontal(amount, reference) {
+  let value;
+  let tupledArg_1;
+  const tupledArg = CellReference_toIndices(reference);
+  tupledArg_1 = [(value = toInt64(op_Addition(toInt64(fromUInt32(tupledArg[0])), toInt64(fromInt32(amount)))), toUInt32(value) >>> 0), tupledArg[1]];
+  return CellReference_ofIndices(tupledArg_1[0], tupledArg_1[1]);
+}
+function CellReference_moveVertical(amount, reference) {
+  let value;
+  let tupledArg_1;
+  const tupledArg = CellReference_toIndices(reference);
+  tupledArg_1 = [tupledArg[0], (value = toInt64(op_Addition(toInt64(fromUInt32(tupledArg[1])), toInt64(fromInt32(amount)))), toUInt32(value) >>> 0)];
+  return CellReference_ofIndices(tupledArg_1[0], tupledArg_1[1]);
+}
 class FsAddress {
   constructor(rowNumber, columnNumber, fixedRow, fixedColumn) {
     this._fixedRow = fixedRow != null && value(fixedRow);
@@ -150,5 +180,11 @@ class FsAddress {
     return other instanceof FsAddress && (other_1 = other, this$.Compare(other_1));
   }
 }
+function FsAddress_$reflection() {
+  return class_type("FsSpreadsheet.FsAddress", void 0, FsAddress);
+}
+function FsAddress_$ctor_42410CA0(rowNumber, columnNumber, fixedRow, fixedColumn) {
+  return new FsAddress(rowNumber, columnNumber, fixedRow, fixedColumn);
+}
 
-export { CellReference_colAdressToIndex, CellReference_indexToColAdress, CellReference_ofIndices, CellReference_toIndices, FsAddress };
+export { CellReference_colAdressToIndex, CellReference_indexRegex, CellReference_indexToColAdress, CellReference_moveHorizontal, CellReference_moveVertical, CellReference_ofIndices, CellReference_setColIndex, CellReference_setRowIndex, CellReference_toColIndex, CellReference_toIndices, CellReference_toRowIndex, FsAddress, FsAddress_$ctor_42410CA0, FsAddress_$reflection };

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

@@ -1,9 +1,10 @@
 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 { getEnumerator, toIterator, comparePrimitives } from '../../../node_modules/@fable-org/fable-library-js/Util.js';
-import { FsRangeBase } from './Ranges/FsRangeBase.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) {
@@ -112,5 +113,11 @@ class FsColumn extends FsRangeBase {
     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 };
+export { FsColumn, FsColumn_$ctor_7678C70A, FsColumn_$reflection };

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

@@ -1,10 +1,11 @@
 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 { length, minBy, maxBy, map, exists } 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';
+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) {
@@ -92,7 +93,7 @@ class FsRow extends FsRangeBase {
     this$["cells@21"].Add(cell, this$.Index, colIndex);
   }
   static insertValueAt(colIndex, value, row) {
-    row.InsertValueAt(colIndex, value);
+    const value_1 = row.InsertValueAt(colIndex, value);
     return row;
   }
   ToDenseRow() {
@@ -122,5 +123,11 @@ class FsRow extends FsRangeBase {
     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 };
+export { FsRow, FsRow_$ctor_7678C70A, FsRow_$reflection };

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

@@ -3,7 +3,8 @@ 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';
+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() {
@@ -131,5 +132,11 @@ class FsWorkbook {
   Dispose() {
   }
 }
+function FsWorkbook_$reflection() {
+  return class_type("FsSpreadsheet.FsWorkbook", void 0, FsWorkbook);
+}
+function FsWorkbook_$ctor() {
+  return new FsWorkbook();
+}
 
-export { FsWorkbook };
+export { FsWorkbook, FsWorkbook_$ctor, FsWorkbook_$reflection };

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

@@ -4,15 +4,16 @@ 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 { comparePrimitives, numberHash, getEnumerator, disposeSafe, safeHash, equals, clear } 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 { toFail, printf, toConsole } 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';
+import { class_type } from '../../../node_modules/@fable-org/fable-library-js/Reflection.js';
 
 class FsWorksheet {
   constructor(name, fsRows, fsTables, fsCellsCollection) {
@@ -346,12 +347,12 @@ class FsWorksheet {
   }
   AddCell(cell) {
     const self = this;
-    self.CellCollection.Add(cell);
+    const value = self.CellCollection.Add(cell);
     return self;
   }
   AddCells(cells) {
     const self = this;
-    self.CellCollection.AddMany(cells);
+    const value = self.CellCollection.AddMany(cells);
     return self;
   }
   InsertValueAt(value, rowIndex, colIndex) {
@@ -366,11 +367,11 @@ class FsWorksheet {
     const self = this;
     const matchValue = self.CellCollection.TryGetCell(rowIndex, colIndex);
     if (matchValue == null) {
-      self.CellCollection.Add(value$1, rowIndex, colIndex);
+      const value_2 = self.CellCollection.Add(value$1, rowIndex, colIndex);
       return self;
     } else {
       const c = value(matchValue);
-      c.SetValueAs(value$1);
+      const value_1 = c.SetValueAs(value$1);
       return self;
     }
   }
@@ -418,5 +419,11 @@ class FsWorksheet {
     }
   }
 }
+function FsWorksheet_$reflection() {
+  return class_type("FsSpreadsheet.FsWorksheet", void 0, FsWorksheet);
+}
+function FsWorksheet_$ctor_7FDA5F7A(name, fsRows, fsTables, fsCellsCollection) {
+  return new FsWorksheet(name, fsRows, fsTables, fsCellsCollection);
+}
 
-export { FsWorksheet };
+export { FsWorksheet, FsWorksheet_$ctor_7FDA5F7A, FsWorksheet_$reflection };

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

@@ -1,5 +1,35 @@
+import { year, month, day, hour, minute, second } from '../../../node_modules/@fable-org/fable-library-js/Date.js';
+import { identityHash, numberHash } from '../../../node_modules/@fable-org/fable-library-js/Util.js';
+import { value } from '../../../node_modules/@fable-org/fable-library-js/Option.js';
+import { fold } from '../../../node_modules/@fable-org/fable-library-js/Array.js';
+import { fold as fold$1 } from '../../../node_modules/@fable-org/fable-library-js/Seq.js';
+
 function mergeHashes(hash1, hash2) {
   return -1640531527 + hash2 + (hash1 << 6) + (hash1 >> 2);
 }
+function hashDateTime(dt) {
+  let acc = 0;
+  acc = mergeHashes(acc, year(dt)) | 0;
+  acc = mergeHashes(acc, month(dt)) | 0;
+  acc = mergeHashes(acc, day(dt)) | 0;
+  acc = mergeHashes(acc, hour(dt)) | 0;
+  acc = mergeHashes(acc, minute(dt)) | 0;
+  acc = mergeHashes(acc, second(dt)) | 0;
+  return acc | 0;
+}
+function hash(obj) {
+  let copyOfStruct = obj;
+  return identityHash(copyOfStruct) | 0;
+}
+function boxHashOption(a) {
+  let copyOfStruct, copyOfStruct_1;
+  return a != null ? (copyOfStruct = value(a), identityHash(copyOfStruct)) : (copyOfStruct_1 = 0, numberHash(copyOfStruct_1));
+}
+function boxHashArray(a) {
+  return fold((acc, o) => mergeHashes(acc, hash(o)), 0, a);
+}
+function boxHashSeq(a) {
+  return fold$1((acc, o) => mergeHashes(acc, hash(o)), 0, a);
+}
 
-export { mergeHashes };
+export { boxHashArray, boxHashOption, boxHashSeq, hash, hashDateTime, mergeHashes };

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

@@ -0,0 +1,65 @@
+import { encode, decode } from './Value.fs.js';
+import { map } from '../../../../node_modules/@fable-org/fable-library-js/Seq.js';
+import { DataType_Empty, FsCell } from '../Cells/FsCell.fs.js';
+import { object, int } from '../../Thoth.Json.Core.0.7.0/Decode.fs.js';
+import { defaultArg } from '../../../../node_modules/@fable-org/fable-library-js/Option.js';
+import { FsAddress } from '../FsAddress.fs.js';
+
+function encodeNoNumber(cell) {
+  const values = [["value", encode(cell.Value)]];
+  return {
+    Encode(helpers) {
+      const arg = map((tupledArg) => [tupledArg[0], tupledArg[1].Encode(helpers)], values);
+      return helpers.encodeObject(arg);
+    }
+  };
+}
+function encodeRows(cell) {
+  let value_1;
+  const values = [["column", (value_1 = cell.ColumnNumber | 0, {
+    Encode(helpers) {
+      return helpers.encodeSignedIntegralNumber(value_1);
+    }
+  })], ["value", encode(cell.Value)]];
+  return {
+    Encode(helpers_1) {
+      const arg = map((tupledArg) => [tupledArg[0], tupledArg[1].Encode(helpers_1)], values);
+      return helpers_1.encodeObject(arg);
+    }
+  };
+}
+function decodeRows(rowNumber) {
+  return object((builder) => {
+    let objectArg, objectArg_1;
+    let patternInput;
+    const value_1 = ["", DataType_Empty()];
+    patternInput = defaultArg((objectArg = builder.Optional, objectArg.Field("value", decode)), value_1);
+    const c = defaultArg((objectArg_1 = builder.Optional, objectArg_1.Field("column", int)), 0) | 0;
+    return new FsCell(patternInput[0], patternInput[1], new FsAddress(defaultArg(rowNumber, 0), c));
+  });
+}
+function encodeCols(cell) {
+  let value_1;
+  const values = [["row", (value_1 = cell.RowNumber | 0, {
+    Encode(helpers) {
+      return helpers.encodeSignedIntegralNumber(value_1);
+    }
+  })], ["value", encode(cell.Value)]];
+  return {
+    Encode(helpers_1) {
+      const arg = map((tupledArg) => [tupledArg[0], tupledArg[1].Encode(helpers_1)], values);
+      return helpers_1.encodeObject(arg);
+    }
+  };
+}
+function decodeCols(colNumber) {
+  return object((builder) => {
+    let objectArg, objectArg_1;
+    let patternInput;
+    const value_1 = ["", DataType_Empty()];
+    patternInput = defaultArg((objectArg = builder.Optional, objectArg.Field("value", decode)), value_1);
+    return new FsCell(patternInput[0], patternInput[1], new FsAddress(defaultArg((objectArg_1 = builder.Optional, objectArg_1.Field("row", int)), 0), defaultArg(colNumber, 0)));
+  });
+}
+
+export { decodeCols, decodeRows, encodeCols, encodeNoNumber, encodeRows };

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

@@ -0,0 +1,38 @@
+import { seq } from '../../Thoth.Json.Core.0.7.0/Encode.fs.js';
+import { map, empty } from '../../../../node_modules/@fable-org/fable-library-js/Seq.js';
+import { encodeCols, encodeNoNumber, decodeCols } from './Cell.fs.js';
+import { object, int, seq as seq$1 } from '../../Thoth.Json.Core.0.7.0/Decode.fs.js';
+import { defaultArg } from '../../../../node_modules/@fable-org/fable-library-js/Option.js';
+
+function encode(col) {
+  let value;
+  const values = [["number", (value = col.Index | 0, {
+    Encode(helpers) {
+      return helpers.encodeSignedIntegralNumber(value);
+    }
+  })], ["cells", seq(map(encodeCols, col.Cells))]];
+  return {
+    Encode(helpers_1) {
+      const arg = map((tupledArg) => [tupledArg[0], tupledArg[1].Encode(helpers_1)], values);
+      return helpers_1.encodeObject(arg);
+    }
+  };
+}
+function encodeNoNumbers(col) {
+  const values = [["cells", seq(map(encodeNoNumber, col))]];
+  return {
+    Encode(helpers) {
+      const arg = map((tupledArg) => [tupledArg[0], tupledArg[1].Encode(helpers)], values);
+      return helpers.encodeObject(arg);
+    }
+  };
+}
+const decode = object((builder) => {
+  let arg_3, objectArg_1;
+  let n;
+  const objectArg = builder.Optional;
+  n = objectArg.Field("number", int);
+  return [n, defaultArg((arg_3 = seq$1(decodeCols(n)), objectArg_1 = builder.Optional, objectArg_1.Field("cells", arg_3)), empty())];
+});
+
+export { decode, encode, encodeNoNumbers };

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

@@ -0,0 +1,38 @@
+import { seq } from '../../Thoth.Json.Core.0.7.0/Encode.fs.js';
+import { map, empty } from '../../../../node_modules/@fable-org/fable-library-js/Seq.js';
+import { encodeRows, encodeNoNumber, decodeRows } from './Cell.fs.js';
+import { object, int, seq as seq$1 } from '../../Thoth.Json.Core.0.7.0/Decode.fs.js';
+import { defaultArg } from '../../../../node_modules/@fable-org/fable-library-js/Option.js';
+
+function encode(row) {
+  let value;
+  const values = [["number", (value = row.Index | 0, {
+    Encode(helpers) {
+      return helpers.encodeSignedIntegralNumber(value);
+    }
+  })], ["cells", seq(map(encodeRows, row.Cells))]];
+  return {
+    Encode(helpers_1) {
+      const arg = map((tupledArg) => [tupledArg[0], tupledArg[1].Encode(helpers_1)], values);
+      return helpers_1.encodeObject(arg);
+    }
+  };
+}
+function encodeNoNumbers(row) {
+  const values = [["cells", seq(map(encodeNoNumber, row))]];
+  return {
+    Encode(helpers) {
+      const arg = map((tupledArg) => [tupledArg[0], tupledArg[1].Encode(helpers)], values);
+      return helpers.encodeObject(arg);
+    }
+  };
+}
+const decode = object((builder) => {
+  let arg_3, objectArg_1;
+  let n;
+  const objectArg = builder.Optional;
+  n = objectArg.Field("number", int);
+  return [n, defaultArg((arg_3 = seq$1(decodeRows(n)), objectArg_1 = builder.Optional, objectArg_1.Field("cells", arg_3)), empty())];
+});
+
+export { decode, encode, encodeNoNumbers };

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

@@ -0,0 +1,34 @@
+import { map } from '../../../../node_modules/@fable-org/fable-library-js/Seq.js';
+import { FsTable } from '../Tables/FsTable.fs.js';
+import { object, string } from '../../Thoth.Json.Core.0.7.0/Decode.fs.js';
+import { FsRangeAddress } from '../Ranges/FsRangeAddress.fs.js';
+
+function encode(sheet) {
+  let value, value_1;
+  const values = [["name", (value = sheet.Name, {
+    Encode(helpers) {
+      return helpers.encodeString(value);
+    }
+  })], ["range", (value_1 = sheet.RangeAddress.Range, {
+    Encode(helpers_1) {
+      return helpers_1.encodeString(value_1);
+    }
+  })]];
+  return {
+    Encode(helpers_2) {
+      const arg = map((tupledArg) => [tupledArg[0], tupledArg[1].Encode(helpers_2)], values);
+      return helpers_2.encodeObject(arg);
+    }
+  };
+}
+const decode = object((builder) => {
+  let n;
+  const objectArg = builder.Required;
+  n = objectArg.Field("name", string);
+  let r;
+  const objectArg_1 = builder.Required;
+  r = objectArg_1.Field("range", string);
+  return new FsTable(n, FsRangeAddress.fromString(r));
+});
+
+export { decode, encode };

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

@@ -1,7 +1,8 @@
-import { minValue, tryParse } from '../../../../node_modules/@fable-org/fable-library-js/Date.js';
+import { minValue, tryParse, toString } from '../../../../node_modules/@fable-org/fable-library-js/Date.js';
 import { FSharpRef } from '../../../../node_modules/@fable-org/fable-library-js/Types.js';
 import { FSharpResult$2_Ok, FSharpResult$2_Error } from '../../../../node_modules/@fable-org/fable-library-js/Result.js';
 import { ErrorReason$1_BadPrimitive } from '../../Thoth.Json.Core.0.7.0/Types.fs.js';
+import { item } from '../../../../node_modules/@fable-org/fable-library-js/Array.js';
 import { oneOf, map, bool, int, float, string } from '../../Thoth.Json.Core.0.7.0/Decode.fs.js';
 import { DataType_Boolean, DataType_Number, DataType_Date, DataType_String } from '../Cells/FsCell.fs.js';
 import { ofArray } from '../../../../node_modules/@fable-org/fable-library-js/List.js';
@@ -20,6 +21,51 @@ const Decode_datetime = {
     }
   }
 };
-oneOf(ofArray([map((b) => [b, DataType_Boolean()], bool), map((i) => [i, DataType_Number()], int), map((f) => [f, DataType_Number()], float), map((d_3) => [d_3, DataType_Date()], Decode_datetime), map((s) => [s, DataType_String()], string)]));
+function encode(value) {
+  if (typeof value === "string") {
+    const s = value;
+    return {
+      Encode(helpers) {
+        return helpers.encodeString(s);
+      }
+    };
+  } else if (typeof value === "number") {
+    const f = value;
+    return {
+      Encode(helpers_1) {
+        return helpers_1.encodeDecimalNumber(f);
+      }
+    };
+  } else if (typeof value === "number") {
+    const i = value | 0;
+    return {
+      Encode(helpers_2) {
+        return helpers_2.encodeSignedIntegralNumber(i);
+      }
+    };
+  } else if (typeof value === "boolean") {
+    const b = value;
+    return {
+      Encode(helpers_3) {
+        return helpers_3.encodeBool(b);
+      }
+    };
+  } else if (value instanceof Date) {
+    const d = value;
+    const value_5 = item(0, toString(d, "O", {}).split("+"));
+    return {
+      Encode(helpers_4) {
+        return helpers_4.encodeString(value_5);
+      }
+    };
+  } else {
+    return {
+      Encode(helpers_5) {
+        return helpers_5.encodeNull();
+      }
+    };
+  }
+}
+const decode = oneOf(ofArray([map((b) => [b, DataType_Boolean()], bool), map((i) => [i, DataType_Number()], int), map((f) => [f, DataType_Number()], float), map((d_3) => [d_3, DataType_Date()], Decode_datetime), map((s) => [s, DataType_String()], string)]));
 
-export { Decode_datetime };
+export { Decode_datetime, decode, encode };

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

@@ -0,0 +1,44 @@
+import { seq } from '../../Thoth.Json.Core.0.7.0/Encode.fs.js';
+import { map } from '../../../../node_modules/@fable-org/fable-library-js/Seq.js';
+import { encodeRows as encodeRows$1, decodeRows as decodeRows$1, encodeColumns as encodeColumns$1, decodeColumns as decodeColumns$1 } from './Worksheet.fs.js';
+import { FsWorkbook } from '../FsWorkbook.fs.js';
+import { object, seq as seq$1 } from '../../Thoth.Json.Core.0.7.0/Decode.fs.js';
+
+function encodeRows(noNumbering, wb) {
+  const values = [["sheets", seq(map((sheet) => encodeRows$1(noNumbering, sheet), wb.GetWorksheets()))]];
+  return {
+    Encode(helpers) {
+      const arg = map((tupledArg) => [tupledArg[0], tupledArg[1].Encode(helpers)], values);
+      return helpers.encodeObject(arg);
+    }
+  };
+}
+const decodeRows = object((builder) => {
+  const wb = new FsWorkbook();
+  let ws;
+  const arg_1 = seq$1(decodeRows$1);
+  const objectArg = builder.Required;
+  ws = objectArg.Field("sheets", arg_1);
+  wb.AddWorksheets(ws);
+  return wb;
+});
+function encodeColumns(noNumbering, wb) {
+  const values = [["sheets", seq(map((sheet) => encodeColumns$1(noNumbering, sheet), wb.GetWorksheets()))]];
+  return {
+    Encode(helpers) {
+      const arg = map((tupledArg) => [tupledArg[0], tupledArg[1].Encode(helpers)], values);
+      return helpers.encodeObject(arg);
+    }
+  };
+}
+const decodeColumns = object((builder) => {
+  const wb = new FsWorkbook();
+  let ws;
+  const arg_1 = seq$1(decodeColumns$1);
+  const objectArg = builder.Required;
+  ws = objectArg.Field("sheets", arg_1);
+  wb.AddWorksheets(ws);
+  return wb;
+});
+
+export { decodeColumns, decodeRows, encodeColumns, encodeRows };