@nfdi4plants/arctrl 2.5.0 → 3.0.0-alpha.1

package/fable_modules/FsSpreadsheet.6.3.1/FsWorksheet.fs.js

@@ -1,433 +0,0 @@
-import { FsCellsCollection__RemoveValueAt_Z37302880, FsCellsCollection__TryRemoveValueAt_Z37302880, FsCellsCollection__RemoveCellAt_Z37302880, FsCellsCollection__Add_2E78CE33, FsCellsCollection__Add_Z21F271A4, FsCellsCollection__Add_Z334DF64D, FsCellsCollection__TryGetCell_Z37302880, FsCellsCollection__Copy, FsCellsCollection__get_MaxColumnNumber, FsCellsCollection__get_MaxRowNumber, FsCellsCollection__GetCells, FsCellsCollection_$ctor } from "./Cells/FsCellsCollection.fs.js";
-import { empty, maxBy, filter, exists, find, tryFind, iterate, last, head, sortBy, map } from "../fable-library-js.4.24.0/Seq.js";
-import { FsColumn } from "./FsColumn.fs.js";
-import { clear, safeHash, equals, disposeSafe, getEnumerator, numberHash, comparePrimitives } from "../fable-library-js.4.24.0/Util.js";
-import { FsAddress__get_ColumnNumber, FsAddress__get_RowNumber, FsAddress_$ctor_Z37302880 } from "./FsAddress.fs.js";
-import { FsRangeAddress__get_LastAddress, FsRangeAddress__get_FirstAddress, FsRangeAddress_$ctor_7E77A4A0 } from "./Ranges/FsRangeAddress.fs.js";
-import { groupBy } from "../fable-library-js.4.24.0/Seq2.js";
-import { value as value_3, defaultArg } from "../fable-library-js.4.24.0/Option.js";
-import { FsRow } from "./FsRow.fs.js";
-import { toConsole, printf, toFail } from "../fable-library-js.4.24.0/String.js";
-import { FsRangeBase__set_RangeAddress_6A2513BC } from "./Ranges/FsRangeBase.fs.js";
-import { addRangeInPlace, removeInPlace } from "../fable-library-js.4.24.0/Array.js";
-import { tryFind as tryFind_1, ofSeq } from "../fable-library-js.4.24.0/Map.js";
-import { FsTable } from "./Tables/FsTable.fs.js";
-import { iterate as iterate_1 } from "../fable-library-js.4.24.0/List.js";
-import { FsCell } from "./Cells/FsCell.fs.js";
-import { class_type } from "../fable-library-js.4.24.0/Reflection.js";
-
-export 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, FsCellsCollection_$ctor());
-    }
-    static init(name) {
-        return new FsWorksheet(name, [], [], FsCellsCollection_$ctor());
-    }
-    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,
-            }), [FsAddress_$ctor_Z37302880((c_2 = head(cells_1), c_2.RowNumber), columnIndex), FsAddress_$ctor_Z37302880((c_3 = last(cells_1), c_3.RowNumber), columnIndex)])), FsRangeAddress_$ctor_7E77A4A0(tupledArg_1[0], tupledArg_1[1])), self.CellCollection);
-        }, groupBy((c) => c.ColumnNumber, FsCellsCollection__GetCells(self._cells), {
-            Equals: (x, y) => (x === y),
-            GetHashCode: numberHash,
-        }));
-    }
-    get MaxRowIndex() {
-        const this$ = this;
-        return FsCellsCollection__get_MaxRowNumber(this$.CellCollection) | 0;
-    }
-    get MaxColumnIndex() {
-        const this$ = this;
-        return FsCellsCollection__get_MaxColumnNumber(this$.CellCollection) | 0;
-    }
-    Copy() {
-        let n, n_1;
-        const self = this;
-        const fcc = FsCellsCollection__Copy(self.CellCollection);
-        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 matchValue;
-            }
-        }
-    }
-    RowWithRange(rangeAddress, SkipSearch) {
-        const self = this;
-        const skipSearch = defaultArg(SkipSearch, false);
-        if (FsAddress__get_RowNumber(FsRangeAddress__get_FirstAddress(rangeAddress)) !== FsAddress__get_RowNumber(FsRangeAddress__get_LastAddress(rangeAddress))) {
-            toFail(printf("Row may not have a range address spanning over different row indices"));
-        }
-        if (skipSearch) {
-            const row = new FsRow(rangeAddress, self.CellCollection);
-            FsRangeBase__set_RangeAddress_6A2513BC(row, rangeAddress);
-            void (self._rows.push(row));
-            return row;
-        }
-        else {
-            const row_1 = self.Row(FsAddress__get_RowNumber(FsRangeAddress__get_FirstAddress(rangeAddress)));
-            FsRangeBase__set_RangeAddress_6A2513BC(row_1, 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) : undefined;
-    }
-    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 = FsRangeAddress_$ctor_7E77A4A0(FsAddress_$ctor_Z37302880(rowIndex, min), FsAddress_$ctor_Z37302880(rowIndex, max));
-            const matchValue = tryFind_1(rowIndex, rows);
-            if (matchValue == null) {
-                self.RowWithRange(newRange, true);
-            }
-            else {
-                FsRangeBase__set_RangeAddress_6A2513BC(matchValue, newRange);
-            }
-        }, groupBy((c) => c.RowNumber, FsCellsCollection__GetCells(self._cells), {
-            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 (FsAddress__get_ColumnNumber(FsRangeAddress__get_FirstAddress(rangeAddress)) !== FsAddress__get_ColumnNumber(FsRangeAddress__get_LastAddress(rangeAddress))) {
-            toFail(printf("Column may not have a range address spanning over different column indices"));
-        }
-        FsRangeBase__set_RangeAddress_6A2513BC(self.Column(FsAddress__get_ColumnNumber(FsRangeAddress__get_FirstAddress(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 matchValue;
-        }
-    }
-    static tryGetTableByName(tableName, sheet) {
-        return tryFind((t) => (t.Name === tableName), sheet.Tables);
-    }
-    static getTableByName(tableName, sheet) {
-        try {
-            return value_3(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 FsCellsCollection__TryGetCell_Z37302880(self.CellCollection, rowIndex, colIndex);
-    }
-    static tryGetCellAt(rowIndex, colIndex, sheet) {
-        return sheet.TryGetCellAt(rowIndex, colIndex);
-    }
-    GetCellAt(rowIndex, colIndex) {
-        const self = this;
-        return value_3(self.TryGetCellAt(rowIndex, colIndex));
-    }
-    static getCellAt(rowIndex, colIndex, sheet) {
-        return sheet.GetCellAt(rowIndex, colIndex);
-    }
-    AddCell(cell) {
-        const self = this;
-        const value = FsCellsCollection__Add_Z334DF64D(self.CellCollection, cell);
-        return self;
-    }
-    AddCells(cells) {
-        const self = this;
-        const value = FsCellsCollection__Add_Z21F271A4(self.CellCollection, cells);
-        return self;
-    }
-    InsertValueAt(value, rowIndex, colIndex) {
-        const self = this;
-        const cell = new FsCell(value);
-        FsCellsCollection__Add_2E78CE33(self.CellCollection, rowIndex, colIndex, cell);
-    }
-    InsertValueAt(value, rowIndex, colIndex) {
-        const self = this;
-        const cell = new FsCell(value);
-        FsCellsCollection__Add_2E78CE33(self.CellCollection, rowIndex, colIndex, cell);
-    }
-    static insertValueAt(value, rowIndex, colIndex, sheet) {
-        sheet.InsertValueAt(value, rowIndex, colIndex);
-    }
-    SetValueAt(value, rowIndex, colIndex) {
-        const self = this;
-        const matchValue = FsCellsCollection__TryGetCell_Z37302880(self.CellCollection, rowIndex, colIndex);
-        if (matchValue == null) {
-            const value_2 = FsCellsCollection__Add_2E78CE33(self.CellCollection, rowIndex, colIndex, value);
-            return self;
-        }
-        else {
-            const c = matchValue;
-            const value_1 = c.SetValueAs(value);
-            return self;
-        }
-    }
-    static setValueAt(value, rowIndex, colIndex, sheet) {
-        return sheet.SetValueAt(value, rowIndex, colIndex);
-    }
-    RemoveCellAt(rowIndex, colIndex) {
-        const self = this;
-        FsCellsCollection__RemoveCellAt_Z37302880(self.CellCollection, rowIndex, colIndex);
-        return self;
-    }
-    static removeCellAt(rowIndex, colIndex, sheet) {
-        return sheet.RemoveCellAt(rowIndex, colIndex);
-    }
-    TryRemoveValueAt(rowIndex, colIndex) {
-        const self = this;
-        FsCellsCollection__TryRemoveValueAt_Z37302880(self.CellCollection, rowIndex, colIndex);
-    }
-    static tryRemoveValueAt(rowIndex, colIndex, sheet) {
-        sheet.TryRemoveValueAt(rowIndex, colIndex);
-    }
-    RemoveValueAt(rowIndex, colIndex) {
-        const self = this;
-        FsCellsCollection__RemoveValueAt_Z37302880(self.CellCollection, 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);
-    }
-}
-
-export function FsWorksheet_$reflection() {
-    return class_type("FsSpreadsheet.FsWorksheet", undefined, FsWorksheet);
-}
-
-export function FsWorksheet_$ctor_7FDA5F7A(name, fsRows, fsTables, fsCellsCollection) {
-    return new FsWorksheet(name, fsRows, fsTables, fsCellsCollection);
-}
-

package/fable_modules/FsSpreadsheet.6.3.1/Json/Cell.fs

@@ -1,45 +0,0 @@
-module FsSpreadsheet.Json.Cell
-
-open FsSpreadsheet
-open Thoth.Json.Core
-
-[<Literal>]
-let column = "column"
-
-[<Literal>]
-let row = "row"
-
-[<Literal>]
-let value = "value"
-
-let encodeNoNumber (cell:FsCell) =
-    Encode.object [
-        value, Value.encode cell.Value
-    ]
-
-let encodeRows (cell:FsCell) =
-    Encode.object [
-        column, Encode.int cell.ColumnNumber
-        value, Value.encode cell.Value
-    ]
-
-let decodeRows rowNumber : Decoder<FsCell> =
-    Decode.object (fun builder ->
-        let v,dt = builder.Optional.Field value (Value.decode) |> Option.defaultValue ("", DataType.Empty)
-        let c = builder.Optional.Field column Decode.int |> Option.defaultValue 0
-        new FsCell(v,dt,FsAddress(Option.defaultValue 0 rowNumber,c))
-    )
-
-
-let encodeCols (cell:FsCell) =
-    Encode.object [
-        row, Encode.int cell.RowNumber
-        value, Value.encode cell.Value
-    ]
-
-let decodeCols colNumber : Decoder<FsCell> =
-    Decode.object (fun builder ->
-        let v,dt = builder.Optional.Field value (Value.decode) |> Option.defaultValue ("", DataType.Empty)
-        let r = builder.Optional.Field row Decode.int |> Option.defaultValue 0
-        new FsCell(v,dt,FsAddress(r,Option.defaultValue 0 colNumber))
-    )

package/fable_modules/FsSpreadsheet.6.3.1/Json/Cell.fs.js

@@ -1,64 +0,0 @@
-import { decode, encode } from "./Value.fs.js";
-import { map } from "../../fable-library-js.4.24.0/Seq.js";
-import { int, object } from "../../Thoth.Json.Core.0.4.0/Decode.fs.js";
-import { defaultArg } from "../../fable-library-js.4.24.0/Option.js";
-import { FsCell, DataType } from "../Cells/FsCell.fs.js";
-import { FsAddress_$ctor_Z37302880 } from "../FsAddress.fs.js";
-
-export 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);
-        },
-    };
-}
-
-export 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);
-        },
-    };
-}
-
-export function decodeRows(rowNumber) {
-    return object((builder) => {
-        let objectArg, objectArg_1;
-        const patternInput = defaultArg((objectArg = builder.Optional, objectArg.Field("value", decode)), ["", new DataType(4, [])]);
-        const c = defaultArg((objectArg_1 = builder.Optional, objectArg_1.Field("column", int)), 0) | 0;
-        return new FsCell(patternInput[0], patternInput[1], FsAddress_$ctor_Z37302880(defaultArg(rowNumber, 0), c));
-    });
-}
-
-export 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);
-        },
-    };
-}
-
-export function decodeCols(colNumber) {
-    return object((builder) => {
-        let objectArg, objectArg_1;
-        const patternInput = defaultArg((objectArg = builder.Optional, objectArg.Field("value", decode)), ["", new DataType(4, [])]);
-        return new FsCell(patternInput[0], patternInput[1], FsAddress_$ctor_Z37302880(defaultArg((objectArg_1 = builder.Optional, objectArg_1.Field("row", int)), 0), defaultArg(colNumber, 0)));
-    });
-}
-

package/fable_modules/FsSpreadsheet.6.3.1/Json/Column.fs

@@ -1,28 +0,0 @@
-module FsSpreadsheet.Json.Column
-
-open FsSpreadsheet
-open Thoth.Json.Core
-
-[<Literal>]
-let cells = "cells"
-
-[<Literal>]
-let number = "number"
-
-let encode (col:FsColumn) =
-    Encode.object [
-        number, Encode.int col.Index
-        cells, Encode.seq (col.Cells |> Seq.map Cell.encodeCols)
-    ]
-
-let encodeNoNumbers (col: FsCell seq) =
-    Encode.object [
-        cells, Encode.seq (col |> Seq.map Cell.encodeNoNumber)
-    ]
-
-let decode : Decoder<int option*FsCell seq> =
-    Decode.object (fun builder ->
-        let n = builder.Optional.Field number Decode.int
-        let cs = builder.Optional.Field cells (Decode.seq (Cell.decodeCols n)) |> Option.defaultValue Seq.empty
-        n,cs
-    )

package/fable_modules/FsSpreadsheet.6.3.1/Json/Column.fs.js

@@ -1,39 +0,0 @@
-import { seq } from "../../Thoth.Json.Core.0.4.0/Encode.fs.js";
-import { empty, map } from "../../fable-library-js.4.24.0/Seq.js";
-import { decodeCols, encodeNoNumber, encodeCols } from "./Cell.fs.js";
-import { seq as seq_1, int, object } from "../../Thoth.Json.Core.0.4.0/Decode.fs.js";
-import { defaultArg } from "../../fable-library-js.4.24.0/Option.js";
-
-export 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);
-        },
-    };
-}
-
-export 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);
-        },
-    };
-}
-
-export 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())];
-});
-

package/fable_modules/FsSpreadsheet.6.3.1/Json/Row.fs

@@ -1,28 +0,0 @@
-module FsSpreadsheet.Json.Row
-
-open FsSpreadsheet
-open Thoth.Json.Core
-
-[<Literal>]
-let cells = "cells"
-
-[<Literal>]
-let number = "number"
-
-let encode (row:FsRow) =
-    Encode.object [
-        number, Encode.int row.Index
-        cells, Encode.seq (row.Cells |> Seq.map Cell.encodeRows)
-    ]
-
-let encodeNoNumbers (row: FsCell seq) =
-    Encode.object [
-        cells, Encode.seq (row |> Seq.map Cell.encodeNoNumber)
-    ]
-
-let decode : Decoder<int option*FsCell seq> =
-    Decode.object (fun builder ->
-        let n = builder.Optional.Field number Decode.int
-        let cs = builder.Optional.Field cells (Decode.seq (Cell.decodeRows n)) |> Option.defaultValue Seq.empty
-        n,cs
-    )

package/fable_modules/FsSpreadsheet.6.3.1/Json/Row.fs.js

@@ -1,39 +0,0 @@
-import { seq } from "../../Thoth.Json.Core.0.4.0/Encode.fs.js";
-import { empty, map } from "../../fable-library-js.4.24.0/Seq.js";
-import { decodeRows, encodeNoNumber, encodeRows } from "./Cell.fs.js";
-import { seq as seq_1, int, object } from "../../Thoth.Json.Core.0.4.0/Decode.fs.js";
-import { defaultArg } from "../../fable-library-js.4.24.0/Option.js";
-
-export 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);
-        },
-    };
-}
-
-export 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);
-        },
-    };
-}
-
-export 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())];
-});
-