@nfdi4plants/arctrl 1.0.0-alpha6

package/fable_modules/FsSpreadsheet.4.1.0/FsColumn.fs.js

@@ -0,0 +1,125 @@
+import { FsRangeAddress__Copy, FsRangeAddress__get_LastAddress, FsRangeAddress__get_FirstAddress, FsRangeAddress_$ctor_7E77A4A0 } from "./Ranges/FsRangeAddress.fs.js";
+import { FsAddress__set_ColumnNumber_Z524259A4, FsAddress__get_ColumnNumber, FsAddress__get_RowNumber, FsAddress_$ctor_Z37302880 } from "./FsAddress.fs.js";
+import { FsCellsCollection__Add_Z21F271A4, FsCellsCollection__GetCellsInColumn_Z524259A4, FsCellsCollection_$ctor } from "./Cells/FsCellsCollection.fs.js";
+import { exists, map, maxBy, minBy, length } from "../fable-library.4.1.4/Seq.js";
+import { toIterator, getEnumerator, comparePrimitives } from "../fable-library.4.1.4/Util.js";
+import { FsRangeBase_$reflection, FsRangeBase, FsRangeBase__Cell_Z3407A44B, FsRangeBase__get_RangeAddress, FsRangeBase__Cells_Z2740B3CA } from "./Ranges/FsRangeBase.fs.js";
+import { class_type } from "../fable-library.4.1.4/Reflection.js";
+
+export class FsColumn extends FsRangeBase {
+    constructor(rangeAddress, cells) {
+        super(rangeAddress);
+        this["cells@18"] = cells;
+    }
+    static empty() {
+        return new FsColumn(FsRangeAddress_$ctor_7E77A4A0(FsAddress_$ctor_Z37302880(0, 0), FsAddress_$ctor_Z37302880(0, 0)), FsCellsCollection_$ctor());
+    }
+    static createAt(index, cells) {
+        const getIndexBy = (f) => {
+            if (length(FsCellsCollection__GetCellsInColumn_Z524259A4(cells, index)) === 0) {
+                return 1;
+            }
+            else {
+                return FsAddress__get_RowNumber(f((c) => FsAddress__get_RowNumber(c.Address))(FsCellsCollection__GetCellsInColumn_Z524259A4(cells, index)).Address) | 0;
+            }
+        };
+        const minRowIndex = getIndexBy((projection) => ((source_1) => minBy(projection, source_1, {
+            Compare: comparePrimitives,
+        }))) | 0;
+        const maxRowIndex = getIndexBy((projection_1) => ((source_2) => maxBy(projection_1, source_2, {
+            Compare: comparePrimitives,
+        }))) | 0;
+        return new FsColumn(FsRangeAddress_$ctor_7E77A4A0(FsAddress_$ctor_Z37302880(minRowIndex, index), FsAddress_$ctor_Z37302880(maxRowIndex, index)), cells);
+    }
+    get Cells() {
+        const this$ = this;
+        return FsRangeBase__Cells_Z2740B3CA(this$, this$["cells@18"]);
+    }
+    get Index() {
+        const this$ = this;
+        return FsAddress__get_ColumnNumber(FsRangeAddress__get_FirstAddress(FsRangeBase__get_RangeAddress(this$))) | 0;
+    }
+    set Index(i) {
+        const this$ = this;
+        FsAddress__set_ColumnNumber_Z524259A4(FsRangeAddress__get_FirstAddress(FsRangeBase__get_RangeAddress(this$)), i);
+        FsAddress__set_ColumnNumber_Z524259A4(FsRangeAddress__get_LastAddress(FsRangeBase__get_RangeAddress(this$)), i);
+    }
+    get MinRowIndex() {
+        const this$ = this;
+        return FsAddress__get_RowNumber(FsRangeAddress__get_FirstAddress(FsRangeBase__get_RangeAddress(this$))) | 0;
+    }
+    get MaxRowIndex() {
+        const this$ = this;
+        return FsAddress__get_RowNumber(FsRangeAddress__get_LastAddress(FsRangeBase__get_RangeAddress(this$))) | 0;
+    }
+    Copy() {
+        const this$ = this;
+        const ra = FsRangeAddress__Copy(FsRangeBase__get_RangeAddress(this$));
+        const cells = map((c) => c.Copy(), this$.Cells);
+        const fcc = FsCellsCollection_$ctor();
+        FsCellsCollection__Add_Z21F271A4(fcc, cells);
+        return new FsColumn(ra, fcc);
+    }
+    static copy(column) {
+        return column.Copy();
+    }
+    static getIndex(column) {
+        return column.Index;
+    }
+    HasCellAt(rowIndex) {
+        const this$ = this;
+        return exists((c) => (c.RowNumber === rowIndex), this$.Cells);
+    }
+    static hasCellAt(rowIndex, column) {
+        return column.HasCellAt(rowIndex);
+    }
+    Item(rowIndex) {
+        const this$ = this;
+        return FsRangeBase__Cell_Z3407A44B(this$, FsAddress_$ctor_Z37302880(rowIndex, 1), this$["cells@18"]);
+    }
+    static item(rowIndex, column) {
+        return column.Item(rowIndex);
+    }
+    TryItem(rowIndex) {
+        const this$ = this;
+        return this$.HasCellAt(rowIndex) ? this$.Item(rowIndex) : void 0;
+    }
+    static tryItem(rowIndex, column) {
+        return column.TryItem(rowIndex);
+    }
+    ToDenseColumn() {
+        const this$ = this;
+        for (let i = this$.MinRowIndex; i <= this$.MaxRowIndex; i++) {
+            this$.Item(i);
+        }
+    }
+    static toDenseColumn(column) {
+        column.ToDenseColumn();
+        return column;
+    }
+    static createDenseColumnOf(column) {
+        const newColumn = column.Copy();
+        newColumn.ToDenseColumn();
+        return newColumn;
+    }
+    GetEnumerator() {
+        const this$ = this;
+        return getEnumerator(this$.Cells);
+    }
+    [Symbol.iterator]() {
+        return toIterator(getEnumerator(this));
+    }
+    "System.Collections.IEnumerable.GetEnumerator"() {
+        const this$ = this;
+        return getEnumerator(this$);
+    }
+}
+
+export function FsColumn_$reflection() {
+    return class_type("FsSpreadsheet.FsColumn", void 0, FsColumn, FsRangeBase_$reflection());
+}
+
+export function FsColumn_$ctor_7678C70A(rangeAddress, cells) {
+    return new FsColumn(rangeAddress, cells);
+}
+

package/fable_modules/FsSpreadsheet.4.1.0/FsRow.fs

@@ -0,0 +1,202 @@
+namespace FsSpreadsheet
+
+
+open System.Collections.Generic
+open System.Collections
+
+open Fable.Core
+
+
+// Type based on the type XLRow used in ClosedXml
+/// <summary>
+/// Creates an FsRow from the given FsRangeAddress, consisting of FsCells within a given FsCellsCollection, and a styleValue.
+/// </summary>
+/// <remarks>The FsCellsCollection must only cover 1 row!</remarks>
+/// <exception cref="System.Exception">if given FsCellsCollection has more than 1 row.</exception>
+[<AttachMembers>]
+type FsRow (rangeAddress : FsRangeAddress, cells : FsCellsCollection)= 
+
+    inherit FsRangeBase(rangeAddress)
+
+    let cells = cells
+
+    // ----------
+    // Creation
+    // ----------
+
+    static member empty() = FsRow (FsRangeAddress(FsAddress(0,0), FsAddress(0,0)), FsCellsCollection())
+
+    /// <summary>
+    /// Creates an FsRow from a given FsCellsCollection and an rowIndex.
+    /// </summary>
+    /// <remarks>The appropriate range of the cells (i.e. minimum colIndex and maximum colIndex) is derived from the FsCells with the matching rowIndex.</remarks>
+    static member createAt(index, (cells : FsCellsCollection)) = 
+        let getIndexBy (f : (FsCell -> int) -> seq<FsCell> -> FsCell) = 
+            match cells.GetCellsInRow index |> Seq.length with
+            | 0 -> 1
+            | _ ->
+                (
+                    cells.GetCellsInRow index 
+                    |> f (fun c -> c.Address.ColumnNumber)
+                ).Address.ColumnNumber
+        let minColIndex = getIndexBy Seq.minBy
+        let maxColIndex = getIndexBy Seq.maxBy
+        FsRow (FsRangeAddress(FsAddress(index, minColIndex), FsAddress(index, maxColIndex)), cells)
+
+    interface IEnumerable<FsCell> with
+        member this.GetEnumerator() : System.Collections.Generic.IEnumerator<FsCell> = this.Cells.GetEnumerator()
+
+    interface IEnumerable with
+        member this.GetEnumerator() = (this :> IEnumerable<FsCell>).GetEnumerator() :> IEnumerator
+
+    // ----------
+    // PROPERTIES
+    // ----------
+
+    /// The associated FsCells.
+    member this.Cells = 
+        base.Cells(cells)
+
+    /// <summary>
+    /// The index of the FsRow.
+    /// </summary>
+    member this.Index 
+        with get() = this.RangeAddress.FirstAddress.RowNumber
+        and set(i) = 
+            this.RangeAddress.FirstAddress.RowNumber <- i
+            this.RangeAddress.LastAddress.RowNumber <- i
+
+    /// <summary>
+    /// The number of the lowest column index of the FsRow where an FsCell exists.
+    /// </summary>
+    member this.MinColIndex
+        with get() = this.RangeAddress.FirstAddress.ColumnNumber
+
+    /// <summary>
+    /// The number of the highest column index of the FsRow where an FsCell exists.
+    /// </summary>
+    member this.MaxColIndex
+        with get() = this.RangeAddress.LastAddress.ColumnNumber
+
+
+    // -------
+    // METHODS
+    // -------
+
+    /// <summary>
+    /// Creates a deep copy of this FsRow.
+    /// </summary>
+    member this.Copy() =
+        let ra = this.RangeAddress.Copy()
+        let cells = this.Cells |> Seq.map (fun c -> c.Copy())
+        let fcc = FsCellsCollection()
+        fcc.Add cells
+        FsRow(ra, fcc)
+
+    /// <summary>
+    /// Returns a deep copy of a given FsRow.
+    /// </summary>
+    static member copy (row : FsRow) =
+        row.Copy()
+
+    /// <summary>
+    /// Returns the index of the given FsRow.
+    /// </summary>
+    static member getIndex (row : FsRow) = 
+        row.Index
+
+    /// <summary>
+    /// Checks if there is an FsCell at given column index.
+    /// </summary>
+    /// <param name="colIndex">The number of the column where the presence of an FsCell shall be checked.</param>
+    member this.HasCellAt(colIndex) =
+        this.Cells
+        |> Seq.exists (fun c -> c.ColumnNumber = colIndex)
+
+    /// <summary>
+    /// Checks if there is an FsCell at given column index of a given FsRow.
+    /// </summary>
+    /// <param name="colIndex">The number of the column where the presence of an FsCell shall be checked.</param>
+    static member hasCellAt colIndex (row : FsRow) =
+        row.HasCellAt colIndex
+
+    /// <summary>
+    /// Returns the FsCell at columnIndex if it exists. Else creates an empty FsCell at that position.
+    /// </summary>
+    member this.Item(columnIndex) =
+        // use FsRangeBase call with colindex 1
+        base.Cell(FsAddress(1, columnIndex), cells)
+
+    /// <summary>
+    /// Returns the FsCell at the given columnIndex from an FsRow if it exists. Else creates an ampty FsCell at that position.
+    /// </summary>
+    static member item colIndex (row : FsRow) =
+        row.Item(colIndex)
+
+    /// <summary>
+    /// Returns the FsCell at the given columnIndex if it exists. Else returns None.
+    /// </summary>
+    /// <param name="colIndex">The number of the column where the FsCell shall be retrieved.</param>
+    member this.TryItem(colIndex) =
+        if this.HasCellAt colIndex then Some this[colIndex]
+        else None
+
+    /// <summary>
+    /// Returns the FsCell at the given columnIndex if it exists in the given FsRow. Else returns None.
+    /// </summary>
+    /// <param name="colIndex">The number of the column where the FsCell shall be retrieved.</param>
+    static member tryItem colIndex (row : FsRow) =
+        row.TryItem colIndex
+
+    /// <summary>
+    /// Inserts the value at columnIndex as an FsCell. If there is an FsCell at the position, this FsCells and all the ones right to it are shifted to the right.
+    /// </summary>
+    member this.InsertValueAt(colIndex, (value : 'a)) =
+        let cell = FsCell(value)
+        cells.Add(int32 this.Index, int32 colIndex, cell)
+
+    /// <summary>
+    /// Adds a value at the given row- and columnIndex to FsRow using.
+    ///
+    /// If a cell exists in the given position, shoves it to the right.
+    /// </summary>
+    static member insertValueAt colIndex value (row : FsRow) =
+        row.InsertValueAt(colIndex, value) |> ignore
+        row
+
+    //member this.SortCells() = _cells <- _cells |> List.sortBy (fun c -> c.WorksheetColumn)
+
+    // TO DO (later)
+    ///// Takes an FsCellsCollection and creates an FsRow from the given rowIndex and the cells in the FsCellsCollection that share the same rowIndex.
+    //static member fromCellsCollection rowIndex (cellsCollection : FsCellsCollection) =
+
+    /// <summary>
+    /// Transforms the FsRow into a dense FsRow.
+    /// 
+    /// FsRows are sparse by default. This means there are no FsCells present between positions with that are filled with FsCells. In dense FsRows, such "empty positions" are then filled with empty FsCells.
+    /// </summary>
+    member this.ToDenseRow() =
+        for i = this.MinColIndex to this.MaxColIndex do 
+            ignore this[i]
+
+    /// <summary>
+    /// Transforms the given FsRow into a dense FsRow.
+    /// 
+    /// FsRows are sparse by default. This means there are no FsCells present between positions with that are filled with FsCells. In dense FsRows, such "empty positions" are then filled with empty FsCells.
+    /// </summary>
+    /// <param name="row">The FsRow that gets transformed into a dense FsRow.</param>
+    /// <remarks>This is an in-place operation.</remarks>
+    static member toDenseRow (row : FsRow) =
+        row.ToDenseRow()
+        row
+
+    /// <summary>
+    /// Takes a given FsRow and returns a new dense FsRow from it.
+    /// 
+    /// FsRows are sparse by default. This means there are no FsCells present between positions with that are filled with FsCells. In dense FsRows, such "empty positions" are then filled with empty FsCells.
+    /// </summary>
+    /// <param name="row">The FsRow that whose copy gets transformed into a dense FsRow.</param>
+    static member createDenseRowOf (row : FsRow) =
+        let newRow = row.Copy()
+        newRow.ToDenseRow()
+        newRow

package/fable_modules/FsSpreadsheet.4.1.0/FsRow.fs.js

@@ -0,0 +1,135 @@
+import { FsRangeAddress__Copy, FsRangeAddress__get_LastAddress, FsRangeAddress__get_FirstAddress, FsRangeAddress_$ctor_7E77A4A0 } from "./Ranges/FsRangeAddress.fs.js";
+import { FsAddress__set_RowNumber_Z524259A4, FsAddress__get_RowNumber, FsAddress__get_ColumnNumber, FsAddress_$ctor_Z37302880 } from "./FsAddress.fs.js";
+import { FsCellsCollection__Add_2E78CE33, FsCellsCollection__Add_Z21F271A4, FsCellsCollection__GetCellsInRow_Z524259A4, FsCellsCollection_$ctor } from "./Cells/FsCellsCollection.fs.js";
+import { exists, map, maxBy, minBy, length } from "../fable-library.4.1.4/Seq.js";
+import { toIterator, getEnumerator, comparePrimitives } from "../fable-library.4.1.4/Util.js";
+import { FsRangeBase_$reflection, FsRangeBase, FsRangeBase__Cell_Z3407A44B, FsRangeBase__get_RangeAddress, FsRangeBase__Cells_Z2740B3CA } from "./Ranges/FsRangeBase.fs.js";
+import { FsCell } from "./Cells/FsCell.fs.js";
+import { class_type } from "../fable-library.4.1.4/Reflection.js";
+
+export class FsRow extends FsRangeBase {
+    constructor(rangeAddress, cells) {
+        super(rangeAddress);
+        this["cells@21"] = cells;
+    }
+    static empty() {
+        return new FsRow(FsRangeAddress_$ctor_7E77A4A0(FsAddress_$ctor_Z37302880(0, 0), FsAddress_$ctor_Z37302880(0, 0)), FsCellsCollection_$ctor());
+    }
+    static createAt(index, cells) {
+        const getIndexBy = (f) => {
+            if (length(FsCellsCollection__GetCellsInRow_Z524259A4(cells, index)) === 0) {
+                return 1;
+            }
+            else {
+                return FsAddress__get_ColumnNumber(f((c) => FsAddress__get_ColumnNumber(c.Address))(FsCellsCollection__GetCellsInRow_Z524259A4(cells, index)).Address) | 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(FsRangeAddress_$ctor_7E77A4A0(FsAddress_$ctor_Z37302880(index, minColIndex), FsAddress_$ctor_Z37302880(index, maxColIndex)), cells);
+    }
+    get Cells() {
+        const this$ = this;
+        return FsRangeBase__Cells_Z2740B3CA(this$, this$["cells@21"]);
+    }
+    get Index() {
+        const this$ = this;
+        return FsAddress__get_RowNumber(FsRangeAddress__get_FirstAddress(FsRangeBase__get_RangeAddress(this$))) | 0;
+    }
+    set Index(i) {
+        const this$ = this;
+        FsAddress__set_RowNumber_Z524259A4(FsRangeAddress__get_FirstAddress(FsRangeBase__get_RangeAddress(this$)), i);
+        FsAddress__set_RowNumber_Z524259A4(FsRangeAddress__get_LastAddress(FsRangeBase__get_RangeAddress(this$)), i);
+    }
+    get MinColIndex() {
+        const this$ = this;
+        return FsAddress__get_ColumnNumber(FsRangeAddress__get_FirstAddress(FsRangeBase__get_RangeAddress(this$))) | 0;
+    }
+    get MaxColIndex() {
+        const this$ = this;
+        return FsAddress__get_ColumnNumber(FsRangeAddress__get_LastAddress(FsRangeBase__get_RangeAddress(this$))) | 0;
+    }
+    Copy() {
+        const this$ = this;
+        const ra = FsRangeAddress__Copy(FsRangeBase__get_RangeAddress(this$));
+        const cells = map((c) => c.Copy(), this$.Cells);
+        const fcc = FsCellsCollection_$ctor();
+        FsCellsCollection__Add_Z21F271A4(fcc, 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 FsRangeBase__Cell_Z3407A44B(this$, FsAddress_$ctor_Z37302880(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);
+        FsCellsCollection__Add_2E78CE33(this$["cells@21"], this$.Index, colIndex, cell);
+    }
+    static insertValueAt(colIndex, value, row) {
+        const value_1 = row.InsertValueAt(colIndex, value);
+        return row;
+    }
+    ToDenseRow() {
+        const this$ = this;
+        for (let i = this$.MinColIndex; i <= this$.MaxColIndex; i++) {
+            this$.Item(i);
+        }
+    }
+    static toDenseRow(row) {
+        row.ToDenseRow();
+        return row;
+    }
+    static createDenseRowOf(row) {
+        const newRow = row.Copy();
+        newRow.ToDenseRow();
+        return newRow;
+    }
+    GetEnumerator() {
+        const this$ = this;
+        return getEnumerator(this$.Cells);
+    }
+    [Symbol.iterator]() {
+        return toIterator(getEnumerator(this));
+    }
+    "System.Collections.IEnumerable.GetEnumerator"() {
+        const this$ = this;
+        return getEnumerator(this$);
+    }
+}
+
+export function FsRow_$reflection() {
+    return class_type("FsSpreadsheet.FsRow", void 0, FsRow, FsRangeBase_$reflection());
+}
+
+export function FsRow_$ctor_7678C70A(rangeAddress, cells) {
+    return new FsRow(rangeAddress, cells);
+}
+

package/fable_modules/FsSpreadsheet.4.1.0/FsSpreadsheet.fableproj

@@ -0,0 +1,58 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFrameworks>netstandard2.0</TargetFrameworks>
+    <GenerateDocumentationFile>true</GenerateDocumentationFile>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Compile Include="FsAddress.fs" />
+    <Compile Include="Cells\FsCell.fs" />
+    <Compile Include="Cells\FsCellsCollection.fs" />
+    <Compile Include="Ranges\FsRangeAddress.fs" />
+    <Compile Include="Ranges\FsRangeBase.fs" />
+    <Compile Include="Ranges\FsRangeRow.fs" />
+    <Compile Include="Ranges\FsRangeColumn.fs" />
+    <Compile Include="Ranges\FsRange.fs" />
+    <Compile Include="FsRow.fs" />
+    <Compile Include="FsColumn.fs" />
+    <Compile Include="Tables\FsTableField.fs" />
+    <Compile Include="Tables\FsTableRow.fs" />
+    <Compile Include="Tables\FsTable.fs" />
+    <Compile Include="FsWorksheet.fs" />
+    <Compile Include="FsWorkbook.fs" />
+    <Compile Include="SheetBuilder.fs" />
+    <Compile Include="DSL\Expression.fs" />
+    <Compile Include="DSL\Types.fs" />
+    <Compile Include="DSL\Transform.fs" />
+    <Compile Include="DSL\Operators.fs" />
+    <Compile Include="DSL\CellBuilder.fs" />
+    <Compile Include="DSL\RowBuilder.fs" />
+    <Compile Include="DSL\ColumnBuilder.fs" />
+    <Compile Include="DSL\TableBuilder.fs" />
+    <Compile Include="DSL\SheetBuilder.fs" />
+    <Compile Include="DSL\WorkbookBuilder.fs" />
+    <Compile Include="DSL\DSL.fs" />
+    <None Include="..\..\docs\img\logo.png" Pack="true" PackagePath="\" />
+  </ItemGroup>
+
+  <PropertyGroup>
+    <Authors>Heinrich Lukas Weil, Oliver Maus, Kevin Schneider, Kevin Frey, Timo Mühlhaus</Authors>
+    <Description>Fable compliant Spreadsheet creation and manipulation in FSharp</Description>
+    <Summary>Spreadsheet creation and manipulation in FSharp</Summary>
+    <PackageLicenseExpression>MIT</PackageLicenseExpression>
+    <PackageIcon>logo.png</PackageIcon>
+    <PackageTags>F# FSharp spreadsheet Excel xlsx datascience fable fable-library</PackageTags>
+    <RepositoryUrl>https://github.com/CSBiology/FsSpreadsheet</RepositoryUrl>
+    <RepositoryType>git</RepositoryType>
+  </PropertyGroup>
+
+  <ItemGroup>
+	<Content Include="*.fsproj; **\*.fs; **\*.fsi" PackagePath="fable\" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Fable.Core" Version="4.0.0" />
+  </ItemGroup>
+
+</Project>