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

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 };

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

@@ -0,0 +1,129 @@
+import { seq } from '../../Thoth.Json.Core.0.7.0/Encode.fs.js';
+import { toList, delay, map, collect, singleton, append, isEmpty, empty, iterate } from '../../../../node_modules/@fable-org/fable-library-js/Seq.js';
+import { encodeNoNumbers, encode, decode as decode$1 } from './Row.fs.js';
+import { value, defaultArg } from '../../../../node_modules/@fable-org/fable-library-js/Option.js';
+import { FsCell } from '../Cells/FsCell.fs.js';
+import { rangeDouble } from '../../../../node_modules/@fable-org/fable-library-js/Range.js';
+import { encode as encode$1, decode } from './Table.fs.js';
+import { FsWorksheet } from '../FsWorksheet.fs.js';
+import { object, string, seq as seq$1 } from '../../Thoth.Json.Core.0.7.0/Decode.fs.js';
+import { encodeNoNumbers as encodeNoNumbers$1, encode as encode$2, decode as decode$2 } from './Column.fs.js';
+
+function encodeRows(noNumbering, sheet) {
+  sheet.RescanRows();
+  const jRows = noNumbering ? seq(toList(delay(() => map((r) => encodeNoNumbers(toList(delay(() => collect((c) => {
+    const matchValue = sheet.CellCollection.TryGetCell(r, c);
+    return matchValue == null ? singleton(new FsCell("")) : singleton(value(matchValue));
+  }, rangeDouble(1, 1, sheet.MaxColumnIndex))))), rangeDouble(1, 1, sheet.MaxRowIndex))))) : seq(map(encode, sheet.Rows));
+  const values_1 = toList(delay(() => {
+    let value;
+    return append(singleton(["name", (value = sheet.Name, {
+      Encode(helpers) {
+        return helpers.encodeString(value);
+      }
+    })]), delay(() => append(!isEmpty(sheet.Tables) ? singleton(["tables", seq(map(encode$1, sheet.Tables))]) : empty(), delay(() => singleton(["rows", jRows])))));
+  }));
+  return {
+    Encode(helpers_1) {
+      const arg = map((tupledArg) => [tupledArg[0], tupledArg[1].Encode(helpers_1)], values_1);
+      return helpers_1.encodeObject(arg);
+    }
+  };
+}
+const decodeRows = object((builder) => {
+  let arg_5, objectArg_2;
+  let rowIndex = 0;
+  let n;
+  const objectArg = builder.Required;
+  n = objectArg.Field("name", string);
+  let ts;
+  const arg_3 = seq$1(decode);
+  const objectArg_1 = builder.Optional;
+  ts = objectArg_1.Field("tables", arg_3);
+  const rs = defaultArg((arg_5 = seq$1(decode$1), objectArg_2 = builder.Optional, objectArg_2.Field("rows", arg_5)), empty());
+  const sheet = new FsWorksheet(n);
+  iterate((tupledArg) => {
+    const rowI = tupledArg[0];
+    let colIndex = 0;
+    const rowI_1 = (rowI == null ? rowIndex + 1 : value(rowI)) | 0;
+    rowIndex = rowI_1 | 0;
+    const r = sheet.Row(rowI_1);
+    iterate((cell) => {
+      let colI;
+      const matchValue = cell.ColumnNumber | 0;
+      colI = matchValue === 0 ? colIndex + 1 : matchValue;
+      colIndex = colI | 0;
+      const c = r.Item(colI);
+      c.Value = cell.Value;
+      c.DataType = cell.DataType;
+    }, tupledArg[1]);
+  }, rs);
+  if (ts == null) {
+  } else {
+    iterate((t) => {
+      sheet.AddTable(t);
+    }, value(ts));
+  }
+  return sheet;
+});
+function encodeColumns(noNumbering, sheet) {
+  sheet.RescanRows();
+  const jColumns = noNumbering ? seq(toList(delay(() => map((c) => encodeNoNumbers$1(toList(delay(() => collect((r) => {
+    const matchValue = sheet.CellCollection.TryGetCell(r, c);
+    return matchValue == null ? singleton(new FsCell("")) : singleton(value(matchValue));
+  }, rangeDouble(1, 1, sheet.MaxRowIndex))))), rangeDouble(1, 1, sheet.MaxColumnIndex))))) : seq(map(encode$2, sheet.Columns));
+  const values_1 = toList(delay(() => {
+    let value;
+    return append(singleton(["name", (value = sheet.Name, {
+      Encode(helpers) {
+        return helpers.encodeString(value);
+      }
+    })]), delay(() => append(!isEmpty(sheet.Tables) ? singleton(["tables", seq(map(encode$1, sheet.Tables))]) : empty(), delay(() => singleton(["columns", jColumns])))));
+  }));
+  return {
+    Encode(helpers_1) {
+      const arg = map((tupledArg) => [tupledArg[0], tupledArg[1].Encode(helpers_1)], values_1);
+      return helpers_1.encodeObject(arg);
+    }
+  };
+}
+const decodeColumns = object((builder) => {
+  let colIndex = 0;
+  let n;
+  const objectArg = builder.Required;
+  n = objectArg.Field("name", string);
+  let ts;
+  const arg_3 = seq$1(decode);
+  const objectArg_1 = builder.Optional;
+  ts = objectArg_1.Field("tables", arg_3);
+  let cs;
+  const arg_5 = seq$1(decode$2);
+  const objectArg_2 = builder.Required;
+  cs = objectArg_2.Field("columns", arg_5);
+  const sheet = new FsWorksheet(n);
+  iterate((tupledArg) => {
+    const colI = tupledArg[0];
+    let rowIndex = 0;
+    const colI_1 = (colI == null ? colIndex + 1 : value(colI)) | 0;
+    colIndex = colI_1 | 0;
+    const col = sheet.Column(colI_1);
+    iterate((cell) => {
+      let rowI;
+      const matchValue = cell.RowNumber | 0;
+      rowI = matchValue === 0 ? rowIndex + 1 : matchValue;
+      rowIndex = rowI | 0;
+      const c = col.Item(rowIndex);
+      c.Value = cell.Value;
+      c.DataType = cell.DataType;
+    }, tupledArg[1]);
+  }, cs);
+  if (ts == null) {
+  } else {
+    iterate((t) => {
+      sheet.AddTable(t);
+    }, value(ts));
+  }
+  return sheet;
+});
+
+export { decodeColumns, decodeRows, encodeColumns, encodeRows };

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

@@ -1,10 +1,11 @@
 import { defaultOf, int32ToString } from '../../../../node_modules/@fable-org/fable-library-js/Util.js';
 import { some } from '../../../../node_modules/@fable-org/fable-library-js/Option.js';
-import { FsRangeBase } from './FsRangeBase.fs.js';
+import { FsRangeBase, FsRangeBase_$reflection } from './FsRangeBase.fs.js';
 import { toText, printf } from '../../../../node_modules/@fable-org/fable-library-js/String.js';
 import { FsRangeRow } from './FsRangeRow.fs.js';
 import { FsRangeAddress } from './FsRangeAddress.fs.js';
 import { FsAddress } from '../FsAddress.fs.js';
+import { class_type } from '../../../../node_modules/@fable-org/fable-library-js/Reflection.js';
 
 class FsRange extends FsRangeBase {
   constructor(rangeAddress, styleValue) {
@@ -24,5 +25,11 @@ class FsRange extends FsRangeBase {
     return self.Row(1);
   }
 }
+function FsRange_$reflection() {
+  return class_type("FsSpreadsheet.FsRange", void 0, FsRange, FsRangeBase_$reflection());
+}
+function FsRange_$ctor_Z15E90CDC(rangeAddress, styleValue) {
+  return new FsRange(rangeAddress, styleValue);
+}
 
-export { FsRange };
+export { FsRange, FsRange_$ctor_Z15E90CDC, FsRange_$reflection };

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

@@ -1,5 +1,6 @@
-import { FsAddress } from '../FsAddress.fs.js';
-import { toText, printf } from '../../../../node_modules/@fable-org/fable-library-js/String.js';
+import { FsAddress, CellReference_toIndices, CellReference_moveHorizontal } from '../FsAddress.fs.js';
+import { class_type } from '../../../../node_modules/@fable-org/fable-library-js/Reflection.js';
+import { toText, printf, toConsole } from '../../../../node_modules/@fable-org/fable-library-js/String.js';
 import { item } from '../../../../node_modules/@fable-org/fable-library-js/Array.js';
 
 class FsRangeAddress {
@@ -71,6 +72,12 @@ class FsRangeAddress {
     return self;
   }
 }
+function FsRangeAddress_$reflection() {
+  return class_type("FsSpreadsheet.FsRangeAddress", void 0, FsRangeAddress);
+}
+function FsRangeAddress_$ctor_7E77A4A0(firstAddress, lastAddress) {
+  return new FsRangeAddress(firstAddress, lastAddress);
+}
 function Range_ofBoundaries(fromCellReference, toCellReference) {
   return toText(printf("%s:%s"))(fromCellReference)(toCellReference);
 }
@@ -78,5 +85,77 @@ function Range_toBoundaries(area) {
   const a = area.split(":");
   return [item(0, a), item(1, a)];
 }
+function Range_rightBoundary(area) {
+  return CellReference_toIndices(Range_toBoundaries(area)[1])[0];
+}
+function Range_leftBoundary(area) {
+  return CellReference_toIndices(Range_toBoundaries(area)[0])[0];
+}
+function Range_upperBoundary(area) {
+  return CellReference_toIndices(Range_toBoundaries(area)[0])[1];
+}
+function Range_lowerBoundary(area) {
+  return CellReference_toIndices(Range_toBoundaries(area)[1])[1];
+}
+function Range_moveHorizontal(amount, area) {
+  let tupledArg_1;
+  const tupledArg = Range_toBoundaries(area);
+  tupledArg_1 = [CellReference_moveHorizontal(amount, tupledArg[0]), CellReference_moveHorizontal(amount, tupledArg[1])];
+  return Range_ofBoundaries(tupledArg_1[0], tupledArg_1[1]);
+}
+function Range_moveVertical(amount, area) {
+  let tupledArg_1;
+  const tupledArg = Range_toBoundaries(area);
+  tupledArg_1 = [CellReference_moveHorizontal(amount, tupledArg[0]), CellReference_moveHorizontal(amount, tupledArg[1])];
+  return Range_ofBoundaries(tupledArg_1[0], tupledArg_1[1]);
+}
+function Range_extendRight(amount, area) {
+  let tupledArg_1;
+  const tupledArg = Range_toBoundaries(area);
+  tupledArg_1 = [tupledArg[0], CellReference_moveHorizontal(amount, tupledArg[1])];
+  return Range_ofBoundaries(tupledArg_1[0], tupledArg_1[1]);
+}
+function Range_extendLeft(amount, area) {
+  let tupledArg_1;
+  const tupledArg = Range_toBoundaries(area);
+  tupledArg_1 = [CellReference_moveHorizontal(amount, tupledArg[0]), tupledArg[1]];
+  return Range_ofBoundaries(tupledArg_1[0], tupledArg_1[1]);
+}
+function Range_referenceExceedsAreaRight(reference, area) {
+  return CellReference_toIndices(reference)[0] > Range_rightBoundary(area);
+}
+function Range_referenceExceedsAreaLeft(reference, area) {
+  return CellReference_toIndices(reference)[0] < Range_leftBoundary(area);
+}
+function Range_referenceExceedsAreaAbove(reference, area) {
+  return CellReference_toIndices(reference)[1] > Range_upperBoundary(area);
+}
+function Range_referenceExceedsAreaBelow(reference, area) {
+  return CellReference_toIndices(reference)[1] < Range_lowerBoundary(area);
+}
+function Range_referenceExceedsArea(reference, area) {
+  if ((Range_referenceExceedsAreaRight(reference, area) ? true : Range_referenceExceedsAreaLeft(reference, area)) ? true : Range_referenceExceedsAreaAbove(reference, area)) {
+    return true;
+  } else {
+    return Range_referenceExceedsAreaBelow(reference, area);
+  }
+}
+function Range_isCorrect(area) {
+  try {
+    const hor = Range_leftBoundary(area) <= Range_rightBoundary(area);
+    const ver = Range_upperBoundary(area) <= Range_lowerBoundary(area);
+    if (!hor) {
+      toConsole(printf("Right area boundary must be higher or equal to left area boundary."));
+    }
+    if (!ver) {
+      toConsole(printf("Lower area boundary must be higher or equal to upper area boundary."));
+    }
+    return hor && ver;
+  } catch (err) {
+    const arg_1 = err.message;
+    toConsole(printf('Area "%s" could not be parsed: %s'))(area)(arg_1);
+    return false;
+  }
+}
 
-export { FsRangeAddress, Range_ofBoundaries, Range_toBoundaries };
+export { FsRangeAddress, FsRangeAddress_$ctor_7E77A4A0, FsRangeAddress_$reflection, Range_extendLeft, Range_extendRight, Range_isCorrect, Range_leftBoundary, Range_lowerBoundary, Range_moveHorizontal, Range_moveVertical, Range_ofBoundaries, Range_referenceExceedsArea, Range_referenceExceedsAreaAbove, Range_referenceExceedsAreaBelow, Range_referenceExceedsAreaLeft, Range_referenceExceedsAreaRight, Range_rightBoundary, Range_toBoundaries, Range_upperBoundary };

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

@@ -3,13 +3,16 @@ import { defaultOf, equals } from '../../../../node_modules/@fable-org/fable-lib
 import { toFail, printf } from '../../../../node_modules/@fable-org/fable-library-js/String.js';
 import { value } from '../../../../node_modules/@fable-org/fable-library-js/Option.js';
 import { FsCell } from '../Cells/FsCell.fs.js';
+import { class_type } from '../../../../node_modules/@fable-org/fable-library-js/Reflection.js';
 
 class FsRangeBase {
   constructor(rangeAddress) {
     this._sortRows = defaultOf();
     this._sortColumns = defaultOf();
     this._rangeAddress = rangeAddress;
+    let _id;
     FsRangeBase.IdCounter = FsRangeBase.IdCounter + 1 | 0;
+    _id = FsRangeBase.IdCounter;
   }
   Extend(address) {
     const this$ = this;
@@ -22,7 +25,7 @@ class FsRangeBase {
   set RangeAddress(rangeAdress) {
     const this$ = this;
     if (!equals(rangeAdress, this$._rangeAddress)) {
-      this$._rangeAddress;
+      const oldAddress = this$._rangeAddress;
       this$._rangeAddress = rangeAdress;
     }
   }
@@ -43,7 +46,7 @@ class FsRangeBase {
       const absoluteAddress = new FsAddress(absRow, absColumn, cellAddressInRange.FixedRow, cellAddressInRange.FixedColumn);
       const newCell = FsCell.createEmptyWithAdress(absoluteAddress);
       this$.Extend(absoluteAddress);
-      cells.Add(newCell, absRow, absColumn);
+      const value = cells.Add(newCell, absRow, absColumn);
       return newCell;
     } else {
       return value(cell);
@@ -62,8 +65,14 @@ class FsRangeBase {
     return this$._rangeAddress.LastAddress.RowNumber - this$._rangeAddress.FirstAddress.RowNumber + 1 | 0;
   }
 }
+function FsRangeBase_$reflection() {
+  return class_type("FsSpreadsheet.FsRangeBase", void 0, FsRangeBase);
+}
+function FsRangeBase_$ctor_6A2513BC(rangeAddress) {
+  return new FsRangeBase(rangeAddress);
+}
 (() => {
   FsRangeBase.IdCounter = 0;
 })();
 
-export { FsRangeBase };
+export { FsRangeBase, FsRangeBase_$ctor_6A2513BC, FsRangeBase_$reflection };

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

@@ -1,6 +1,9 @@
 import { FsRangeAddress } from './FsRangeAddress.fs.js';
 import { FsAddress } from '../FsAddress.fs.js';
-import { FsRangeBase } from './FsRangeBase.fs.js';
+import { FsRangeBase, FsRangeBase_$reflection } from './FsRangeBase.fs.js';
+import { class_type } from '../../../../node_modules/@fable-org/fable-library-js/Reflection.js';
+import { toList, map } from '../../../../node_modules/@fable-org/fable-library-js/Seq.js';
+import { rangeDouble } from '../../../../node_modules/@fable-org/fable-library-js/Range.js';
 
 class FsRangeColumn extends FsRangeBase {
   constructor(rangeAddress) {
@@ -38,5 +41,17 @@ class FsRangeColumn extends FsRangeBase {
     return rangeColumn.Copy();
   }
 }
+function FsRangeColumn_$reflection() {
+  return class_type("FsSpreadsheet.FsRangeColumn", void 0, FsRangeColumn, FsRangeBase_$reflection());
+}
+function FsRangeColumn_$ctor_6A2513BC(rangeAddress) {
+  return new FsRangeColumn(rangeAddress);
+}
+function FsSpreadsheet_FsRangeAddress__FsRangeAddress_toRangeColumns_Static_6A2513BC(rangeAddress) {
+  const columns = toList(rangeDouble(rangeAddress.FirstAddress.ColumnNumber, 1, rangeAddress.LastAddress.ColumnNumber));
+  const fstRow = rangeAddress.FirstAddress.RowNumber | 0;
+  const lstRow = rangeAddress.LastAddress.RowNumber | 0;
+  return map((c) => new FsRangeColumn(new FsRangeAddress(new FsAddress(fstRow, c), new FsAddress(lstRow, c))), columns);
+}
 
-export { FsRangeColumn };
+export { FsRangeColumn, FsRangeColumn_$ctor_6A2513BC, FsRangeColumn_$reflection, FsSpreadsheet_FsRangeAddress__FsRangeAddress_toRangeColumns_Static_6A2513BC };