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

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

@@ -0,0 +1,334 @@
+import { OntologyAnnotation } from '../OntologyAnnotation.js';
+import { defaultArg, unwrap } from '../../../node_modules/@fable-org/fable-library-js/Option.js';
+import { Data } from '../Data.js';
+import { Union } from '../../../node_modules/@fable-org/fable-library-js/Types.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 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, defaultArg(oa.TermSourceREF, ""), defaultArg(oa.TermAccessionNumber, "")];
+      }
+      case /* Unitized */
+      2: {
+        const oa_1 = this$.fields[1];
+        return [this$.fields[0], oa_1.NameText, defaultArg(oa_1.TermSourceREF, ""), defaultArg(oa_1.TermAccessionNumber, "")];
+      }
+      case /* Data */
+      3: {
+        const d = this$.fields[0];
+        return [defaultArg(d.Name, ""), defaultArg(d.Format, ""), 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.create(text));
+      }
+      case /* Term */
+      0:
+        return CompositeCell_Unitized("", this$.fields[0]);
+      case /* Data */
+      3: {
+        const d = this$.fields[0];
+        return CompositeCell_Unitized("", 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.create(text));
+      }
+      case /* Data */
+      3: {
+        const d = this$.fields[0];
+        return CompositeCell_Term(new 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.create(unwrap(name), unwrap(tsr), unwrap(tan)));
+  }
+  static createUnitized(value, oa) {
+    return CompositeCell_Unitized(value, defaultArg(oa, new OntologyAnnotation()));
+  }
+  static createUnitizedFromString(value, name, tsr, tan) {
+    const tupledArg = [value, OntologyAnnotation.create(unwrap(name), unwrap(tsr), 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.create(void 0, value, void 0, unwrap(format), unwrap(selectorFormat)));
+  }
+  static get emptyTerm() {
+    return CompositeCell_Term(new OntologyAnnotation());
+  }
+  static get emptyFreeText() {
+    return CompositeCell_FreeText("");
+  }
+  static get emptyUnitized() {
+    return CompositeCell_Unitized("", new OntologyAnnotation());
+  }
+  static get emptyData() {
+    return CompositeCell_Data(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 = 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);
+  }
+}
+
+export { CompositeCell, CompositeCell_Data, CompositeCell_FreeText, CompositeCell_Term, CompositeCell_Unitized };

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

@@ -0,0 +1,52 @@
+import { defaultArg, unwrap } from '../../../node_modules/@fable-org/fable-library-js/Option.js';
+import { Record } from '../../../node_modules/@fable-org/fable-library-js/Types.js';
+import '../Helper/Url.js';
+import { exists, toArray, delay, isEmpty, fold, collect, singleton, empty } from '../../../node_modules/@fable-org/fable-library-js/Seq.js';
+import { CompositeCell } from './CompositeCell.js';
+
+class CompositeColumn extends Record {
+  constructor(Header, Cells) {
+    super();
+    this.Header = Header;
+    this.Cells = Cells;
+  }
+  static create(header, cells) {
+    return new CompositeColumn(header, defaultArg(cells, []));
+  }
+  Validate(raiseException) {
+    const this$ = this;
+    return !exists((c) => !c.ValidateAgainstHeader(this$.Header, unwrap(raiseException)), this$.Cells);
+  }
+  TryGetColumnUnits() {
+    const this$ = this;
+    let arr;
+    const collection = toArray(delay(() => collect((cell) => cell.isUnitized ? singleton(cell.AsUnitized[1]) : empty(), this$.Cells)));
+    arr = Array.from(collection);
+    return isEmpty(arr) ? void 0 : arr;
+  }
+  GetDefaultEmptyCell() {
+    const this$ = this;
+    if (!this$.Header.IsTermColumn) {
+      return CompositeCell.emptyFreeText;
+    } else {
+      let patternInput;
+      const arg = [0, 0];
+      patternInput = 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.emptyTerm : CompositeCell.emptyUnitized;
+    }
+  }
+  get IsUnique() {
+    const this$ = this;
+    return this$.Header.IsUnique;
+  }
+}
+
+export { CompositeColumn };