@nfdi4plants/arctrl 2.5.1 → 3.0.0-alpha.2

package/dist/ts/cjs/ts/Core/Table/CompositeCell.js

@@ -0,0 +1,317 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompositeCell = void 0;
+exports.CompositeCell_Term = CompositeCell_Term;
+exports.CompositeCell_FreeText = CompositeCell_FreeText;
+exports.CompositeCell_Unitized = CompositeCell_Unitized;
+exports.CompositeCell_Data = CompositeCell_Data;
+exports.CompositeCell_$reflection = CompositeCell_$reflection;
+const OntologyAnnotation_js_1 = require("../OntologyAnnotation.js");
+const Option_js_1 = require("@fable-org/fable-library-js/Option.js");
+const Data_js_1 = require("../Data.js");
+const Types_js_1 = require("@fable-org/fable-library-js/Types.js");
+const Reflection_js_1 = require("@fable-org/fable-library-js/Reflection.js");
+function CompositeCell_Term(Item) {
+    return new CompositeCell(0, [Item]);
+}
+function CompositeCell_FreeText(Item) {
+    return new CompositeCell(1, [Item]);
+}
+function CompositeCell_Unitized(Item1, Item2) {
+    return new CompositeCell(2, [Item1, Item2]);
+}
+function CompositeCell_Data(Item) {
+    return new CompositeCell(3, [Item]);
+}
+class CompositeCell extends Types_js_1.Union {
+    constructor(tag, fields) {
+        super();
+        this.tag = tag;
+        this.fields = fields;
+    }
+    cases() {
+        return ["Term", "FreeText", "Unitized", "Data"];
+    }
+    get isUnitized() {
+        const this$ = this;
+        return this$.tag === /* Unitized */ 2;
+    }
+    get isTerm() {
+        const this$ = this;
+        return this$.tag === /* Term */ 0;
+    }
+    get isFreeText() {
+        const this$ = this;
+        return this$.tag === /* FreeText */ 1;
+    }
+    get isData() {
+        const this$ = this;
+        return this$.tag === /* Data */ 3;
+    }
+    GetEmptyCell() {
+        const this$ = this;
+        return (this$.tag === /* Unitized */ 2) ? CompositeCell.emptyUnitized : ((this$.tag === /* FreeText */ 1) ? CompositeCell.emptyFreeText : ((this$.tag === /* Data */ 3) ? CompositeCell.emptyData : CompositeCell.emptyTerm));
+    }
+    GetContent() {
+        const this$ = this;
+        switch (this$.tag) {
+            case /* Term */ 0: {
+                const oa = this$.fields[0];
+                return [oa.NameText, (0, Option_js_1.defaultArg)(oa.TermSourceREF, ""), (0, Option_js_1.defaultArg)(oa.TermAccessionNumber, "")];
+            }
+            case /* Unitized */ 2: {
+                const oa_1 = this$.fields[1];
+                return [this$.fields[0], oa_1.NameText, (0, Option_js_1.defaultArg)(oa_1.TermSourceREF, ""), (0, Option_js_1.defaultArg)(oa_1.TermAccessionNumber, "")];
+            }
+            case /* Data */ 3: {
+                const d = this$.fields[0];
+                return [(0, Option_js_1.defaultArg)(d.Name, ""), (0, Option_js_1.defaultArg)(d.Format, ""), (0, Option_js_1.defaultArg)(d.SelectorFormat, "")];
+            }
+            default:
+                return [this$.fields[0]];
+        }
+    }
+    ToUnitizedCell() {
+        const this$ = this;
+        switch (this$.tag) {
+            case /* FreeText */ 1: {
+                const text = this$.fields[0];
+                return CompositeCell_Unitized("", OntologyAnnotation_js_1.OntologyAnnotation.create(text));
+            }
+            case /* Term */ 0:
+                return CompositeCell_Unitized("", this$.fields[0]);
+            case /* Data */ 3: {
+                const d = this$.fields[0];
+                return CompositeCell_Unitized("", OntologyAnnotation_js_1.OntologyAnnotation.create(d.NameText));
+            }
+            default:
+                return this$;
+        }
+    }
+    ToTermCell() {
+        const this$ = this;
+        switch (this$.tag) {
+            case /* Unitized */ 2:
+                return CompositeCell_Term(this$.fields[1]);
+            case /* FreeText */ 1: {
+                const text = this$.fields[0];
+                return CompositeCell_Term(OntologyAnnotation_js_1.OntologyAnnotation.create(text));
+            }
+            case /* Data */ 3: {
+                const d = this$.fields[0];
+                return CompositeCell_Term(new OntologyAnnotation_js_1.OntologyAnnotation(d.NameText));
+            }
+            default:
+                return this$;
+        }
+    }
+    ToFreeTextCell() {
+        const this$ = this;
+        switch (this$.tag) {
+            case /* Term */ 0: {
+                const term = this$.fields[0];
+                return CompositeCell_FreeText(term.NameText);
+            }
+            case /* Unitized */ 2: {
+                const unit = this$.fields[1];
+                return CompositeCell_FreeText(unit.NameText);
+            }
+            case /* Data */ 3: {
+                const d = this$.fields[0];
+                return CompositeCell_FreeText(d.NameText);
+            }
+            default:
+                return this$;
+        }
+    }
+    ToDataCell() {
+        const this$ = this;
+        switch (this$.tag) {
+            case /* FreeText */ 1: {
+                const txt = this$.fields[0];
+                return CompositeCell.createDataFromString(txt);
+            }
+            case /* Term */ 0: {
+                const term = this$.fields[0];
+                return CompositeCell.createDataFromString(term.NameText);
+            }
+            case /* Data */ 3:
+                return this$;
+            default: {
+                const unit = this$.fields[1];
+                return CompositeCell.createDataFromString(unit.NameText);
+            }
+        }
+    }
+    get AsUnitized() {
+        const this$ = this;
+        if (this$.tag === /* Unitized */ 2) {
+            return [this$.fields[0], this$.fields[1]];
+        }
+        else {
+            throw new Error("Not a Unitized cell.");
+        }
+    }
+    get AsTerm() {
+        const this$ = this;
+        if (this$.tag === /* Term */ 0) {
+            return this$.fields[0];
+        }
+        else {
+            throw new Error("Not a Term Cell.");
+        }
+    }
+    get AsFreeText() {
+        const this$ = this;
+        if (this$.tag === /* FreeText */ 1) {
+            return this$.fields[0];
+        }
+        else {
+            throw new Error("Not a FreeText Cell.");
+        }
+    }
+    get AsData() {
+        const this$ = this;
+        if (this$.tag === /* Data */ 3) {
+            return this$.fields[0];
+        }
+        else {
+            throw new Error("Not a Data Cell.");
+        }
+    }
+    static createTerm(oa) {
+        return CompositeCell_Term(oa);
+    }
+    static createTermFromString(name, tsr, tan) {
+        return CompositeCell_Term(OntologyAnnotation_js_1.OntologyAnnotation.create((0, Option_js_1.unwrap)(name), (0, Option_js_1.unwrap)(tsr), (0, Option_js_1.unwrap)(tan)));
+    }
+    static createUnitized(value, oa) {
+        return CompositeCell_Unitized(value, (0, Option_js_1.defaultArg)(oa, new OntologyAnnotation_js_1.OntologyAnnotation()));
+    }
+    static createUnitizedFromString(value, name, tsr, tan) {
+        const tupledArg = [value, OntologyAnnotation_js_1.OntologyAnnotation.create((0, Option_js_1.unwrap)(name), (0, Option_js_1.unwrap)(tsr), (0, Option_js_1.unwrap)(tan))];
+        return CompositeCell_Unitized(tupledArg[0], tupledArg[1]);
+    }
+    static createFreeText(value) {
+        return CompositeCell_FreeText(value);
+    }
+    static createData(d) {
+        return CompositeCell_Data(d);
+    }
+    static createDataFromString(value, format, selectorFormat) {
+        return CompositeCell_Data(Data_js_1.Data.create(undefined, value, undefined, (0, Option_js_1.unwrap)(format), (0, Option_js_1.unwrap)(selectorFormat)));
+    }
+    static get emptyTerm() {
+        return CompositeCell_Term(new OntologyAnnotation_js_1.OntologyAnnotation());
+    }
+    static get emptyFreeText() {
+        return CompositeCell_FreeText("");
+    }
+    static get emptyUnitized() {
+        return CompositeCell_Unitized("", new OntologyAnnotation_js_1.OntologyAnnotation());
+    }
+    static get emptyData() {
+        return CompositeCell_Data(Data_js_1.Data.create());
+    }
+    UpdateWithOA(oa) {
+        const this$ = this;
+        switch (this$.tag) {
+            case /* Unitized */ 2: {
+                const v = this$.fields[0];
+                return CompositeCell.createUnitized(v, oa);
+            }
+            case /* FreeText */ 1:
+                return CompositeCell.createFreeText(oa.NameText);
+            case /* Data */ 3: {
+                const d = this$.fields[0];
+                d.Name = oa.NameText;
+                return CompositeCell_Data(d);
+            }
+            default:
+                return CompositeCell.createTerm(oa);
+        }
+    }
+    static updateWithOA(oa, cell) {
+        return cell.UpdateWithOA(oa);
+    }
+    toString() {
+        const this$ = this;
+        switch (this$.tag) {
+            case /* FreeText */ 1:
+                return this$.fields[0];
+            case /* Unitized */ 2: {
+                const oa_1 = this$.fields[1];
+                return `${this$.fields[0]} ${oa_1.NameText}`;
+            }
+            case /* Data */ 3: {
+                const d = this$.fields[0];
+                return `${d.NameText}`;
+            }
+            default: {
+                const oa = this$.fields[0];
+                return `${oa.NameText}`;
+            }
+        }
+    }
+    Copy() {
+        const this$ = this;
+        switch (this$.tag) {
+            case /* FreeText */ 1:
+                return CompositeCell_FreeText(this$.fields[0]);
+            case /* Unitized */ 2: {
+                const oa_1 = this$.fields[1];
+                return CompositeCell_Unitized(this$.fields[0], oa_1.Copy());
+            }
+            case /* Data */ 3: {
+                const d = this$.fields[0];
+                return CompositeCell_Data(d.Copy());
+            }
+            default: {
+                const oa = this$.fields[0];
+                return CompositeCell_Term(oa.Copy());
+            }
+        }
+    }
+    ValidateAgainstHeader(header, raiseException) {
+        const this$ = this;
+        const raiseExeption = (0, Option_js_1.defaultArg)(raiseException, false);
+        const cell = this$;
+        if (header.IsDataColumn && (cell.isData ? true : cell.isFreeText)) {
+            return true;
+        }
+        else if (header.IsDataColumn) {
+            if (raiseExeption) {
+                throw new Error(`Invalid combination of header \`${header}\` and cell \`${cell}\`, Data header should have either Data or Freetext cells`);
+            }
+            return false;
+        }
+        else if (header.IsTermColumn && (cell.isTerm ? true : cell.isUnitized)) {
+            return true;
+        }
+        else if (!header.IsTermColumn && cell.isFreeText) {
+            return true;
+        }
+        else {
+            if (raiseExeption) {
+                throw new Error(`Invalid combination of header \`${header}\` and cell \`${cell}\``);
+            }
+            return false;
+        }
+    }
+    static term(oa) {
+        return CompositeCell_Term(oa);
+    }
+    static freeText(s) {
+        return CompositeCell_FreeText(s);
+    }
+    static unitized(v, oa) {
+        return CompositeCell_Unitized(v, oa);
+    }
+    static data(d) {
+        return CompositeCell_Data(d);
+    }
+}
+exports.CompositeCell = CompositeCell;
+function CompositeCell_$reflection() {
+    return (0, Reflection_js_1.union_type)("ARCtrl.CompositeCell", [], CompositeCell, () => [[["Item", (0, OntologyAnnotation_js_1.OntologyAnnotation_$reflection)()]], [["Item", Reflection_js_1.string_type]], [["Item1", Reflection_js_1.string_type], ["Item2", (0, OntologyAnnotation_js_1.OntologyAnnotation_$reflection)()]], [["Item", (0, Data_js_1.Data_$reflection)()]]]);
+}

package/dist/ts/cjs/ts/Core/Table/CompositeColumn.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompositeColumn = void 0;
+exports.CompositeColumn_$reflection = CompositeColumn_$reflection;
+const Option_js_1 = require("@fable-org/fable-library-js/Option.js");
+const CompositeHeader_js_1 = require("./CompositeHeader.js");
+const CompositeCell_js_1 = require("./CompositeCell.js");
+const Seq_js_1 = require("@fable-org/fable-library-js/Seq.js");
+const Types_js_1 = require("@fable-org/fable-library-js/Types.js");
+const Reflection_js_1 = require("@fable-org/fable-library-js/Reflection.js");
+class CompositeColumn extends Types_js_1.Record {
+    constructor(Header, Cells) {
+        super();
+        this.Header = Header;
+        this.Cells = Cells;
+    }
+    static create(header, cells) {
+        return new CompositeColumn(header, (0, Option_js_1.defaultArg)(cells, []));
+    }
+    Validate(raiseException) {
+        const this$ = this;
+        return !(0, Seq_js_1.exists)((c) => !c.ValidateAgainstHeader(this$.Header, (0, Option_js_1.unwrap)(raiseException)), this$.Cells);
+    }
+    TryGetColumnUnits() {
+        const this$ = this;
+        const arr = (0, Seq_js_1.toArray)((0, Seq_js_1.delay)(() => (0, Seq_js_1.collect)((cell) => (cell.isUnitized ? (0, Seq_js_1.singleton)(cell.AsUnitized[1]) : (0, Seq_js_1.empty)()), this$.Cells)));
+        return (arr.length === 0) ? undefined : arr;
+    }
+    GetDefaultEmptyCell() {
+        const this$ = this;
+        if (!this$.Header.IsTermColumn) {
+            return CompositeCell_js_1.CompositeCell.emptyFreeText;
+        }
+        else {
+            let patternInput;
+            const arg = [0, 0];
+            patternInput = (0, Seq_js_1.fold)((tupledArg, cell) => {
+                const units = tupledArg[0] | 0;
+                const terms = tupledArg[1] | 0;
+                if (cell.isUnitized) {
+                    return [units + 1, terms];
+                }
+                else {
+                    return [units, terms + 1];
+                }
+            }, [arg[0], arg[1]], this$.Cells);
+            return (patternInput[1] >= patternInput[0]) ? CompositeCell_js_1.CompositeCell.emptyTerm : CompositeCell_js_1.CompositeCell.emptyUnitized;
+        }
+    }
+    get IsUnique() {
+        const this$ = this;
+        return this$.Header.IsUnique;
+    }
+}
+exports.CompositeColumn = CompositeColumn;
+function CompositeColumn_$reflection() {
+    return (0, Reflection_js_1.record_type)("ARCtrl.CompositeColumn", [], CompositeColumn, () => [["Header", (0, CompositeHeader_js_1.CompositeHeader_$reflection)()], ["Cells", (0, Reflection_js_1.array_type)((0, CompositeCell_js_1.CompositeCell_$reflection)())]]);
+}