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

package/dist/ts/ts/Core/Helper/Collections.js

@@ -0,0 +1,323 @@
+import { structuralHash, equals, getEnumerator, disposeSafe, defaultOf } from '../../../node_modules/@fable-org/fable-library-js/Util.js';
+import { some, value } from '../../../node_modules/@fable-org/fable-library-js/Option.js';
+import { iterate, map, isEmpty } from '../../../node_modules/@fable-org/fable-library-js/Seq.js';
+import { empty, isEmpty as isEmpty$1, tail, head, append, singleton } from '../../../node_modules/@fable-org/fable-library-js/List.js';
+import { tryGetValue, addToDict } from '../../../node_modules/@fable-org/fable-library-js/MapUtil.js';
+import { Dictionary } from '../../../node_modules/@fable-org/fable-library-js/MutableMap.js';
+import { FSharpRef } from '../../../node_modules/@fable-org/fable-library-js/Types.js';
+import { min } from '../../../node_modules/@fable-org/fable-library-js/Double.js';
+import { contains } from '../../../node_modules/@fable-org/fable-library-js/Array.js';
+import { groupBy } from '../../../node_modules/@fable-org/fable-library-js/Seq2.js';
+
+function Option_fromValueWithDefault(d, v) {
+  if (equals(d, v)) {
+    return void 0;
+  } else {
+    return some(v);
+  }
+}
+function Option_fromSeq(v) {
+  if (isEmpty(v)) {
+    return void 0;
+  } else {
+    return some(v);
+  }
+}
+function List_tryPickAndRemove(f, lst) {
+  const loop = (newList_mut, remainingList_mut) => {
+    loop:
+      while (true) {
+        const newList = newList_mut, remainingList = remainingList_mut;
+        if (!isEmpty$1(remainingList)) {
+          const t = tail(remainingList);
+          const h = head(remainingList);
+          const matchValue = f(h);
+          if (matchValue == null) {
+            newList_mut = append(newList, singleton(h));
+            remainingList_mut = t;
+            continue loop;
+          } else {
+            return [some(value(matchValue)), append(newList, t)];
+          }
+        } else {
+          return [void 0, newList];
+        }
+      }
+  };
+  return loop(empty(), lst);
+}
+function Dictionary_ofSeq(s) {
+  const dict = new Dictionary([], {
+    Equals: equals,
+    GetHashCode: structuralHash
+  });
+  iterate((tupledArg) => {
+    addToDict(dict, tupledArg[0], tupledArg[1]);
+  }, s);
+  return dict;
+}
+function Dictionary_tryFind(key, dict) {
+  let patternInput;
+  let outArg = defaultOf();
+  patternInput = [tryGetValue(dict, key, new FSharpRef(() => outArg, (v) => {
+    outArg = v;
+  })), outArg];
+  if (patternInput[0]) {
+    return some(patternInput[1]);
+  } else {
+    return void 0;
+  }
+}
+function Dictionary_init() {
+  return new Dictionary([], {
+    Equals: equals,
+    GetHashCode: structuralHash
+  });
+}
+function Dictionary_items(dict) {
+  return dict;
+}
+function StringDictionary_ofSeq(s) {
+  return new Map(s);
+}
+function ResizeArray_create(i, v) {
+  const a = [];
+  if (i > 0) {
+    for (let forLoopVar = 1; forLoopVar <= i; forLoopVar++) {
+      void a.push(v);
+    }
+  }
+  return a;
+}
+function ResizeArray_singleton(a) {
+  const b = [];
+  void b.push(a);
+  return b;
+}
+function ResizeArray_map(f, a) {
+  const b = [];
+  let enumerator = getEnumerator(a);
+  try {
+    while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+      const i = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+      void b.push(f(i));
+    }
+  } finally {
+    disposeSafe(enumerator);
+  }
+  return b;
+}
+function ResizeArray_mapi(f, a) {
+  const b = [];
+  for (let i = 0; i <= a.length - 1; i++) {
+    void b.push(f(i, a[i]));
+  }
+  return b;
+}
+function ResizeArray_choose(f, a) {
+  const b = [];
+  let enumerator = getEnumerator(a);
+  try {
+    while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+      const matchValue = f(enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]());
+      if (matchValue == null) {
+      } else {
+        const x = value(matchValue);
+        void b.push(x);
+      }
+    }
+  } finally {
+    disposeSafe(enumerator);
+  }
+  return b;
+}
+function ResizeArray_filter(f, a) {
+  const b = [];
+  let enumerator = getEnumerator(a);
+  try {
+    while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+      const i = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+      if (f(i)) {
+        void b.push(i);
+      }
+    }
+  } finally {
+    disposeSafe(enumerator);
+  }
+  return b;
+}
+function ResizeArray_fold(f, s, a) {
+  let state = s;
+  let enumerator = getEnumerator(a);
+  try {
+    while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+      const i = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+      state = f(state, i);
+    }
+  } finally {
+    disposeSafe(enumerator);
+  }
+  return state;
+}
+function ResizeArray_iter(f, a) {
+  let enumerator = getEnumerator(a);
+  try {
+    while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+      f(enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]());
+    }
+  } finally {
+    disposeSafe(enumerator);
+  }
+}
+function ResizeArray_iteri(f, a) {
+  for (let i = 0; i <= a.length - 1; i++) {
+    f(i, a[i]);
+  }
+}
+function ResizeArray_init(n, f) {
+  const a = [];
+  for (let i = 0; i <= n - 1; i++) {
+    void a.push(f(i));
+  }
+  return a;
+}
+function ResizeArray_collect(f, a) {
+  const b = [];
+  let enumerator = getEnumerator(a);
+  try {
+    while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+      const enumerator_1 = getEnumerator(f(enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]()));
+      try {
+        while (enumerator_1["System.Collections.IEnumerator.MoveNext"]()) {
+          const j = enumerator_1["System.Collections.Generic.IEnumerator`1.get_Current"]();
+          void b.push(j);
+        }
+      } finally {
+        disposeSafe(enumerator_1);
+      }
+    }
+  } finally {
+    disposeSafe(enumerator);
+  }
+  return b;
+}
+function ResizeArray_distinct(a) {
+  const b = [];
+  let enumerator = getEnumerator(a);
+  try {
+    while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+      const i = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+      if (!contains(i, b, {
+        Equals: equals,
+        GetHashCode: structuralHash
+      })) {
+        void b.push(i);
+      }
+    }
+  } finally {
+    disposeSafe(enumerator);
+  }
+  return b;
+}
+function ResizeArray_isEmpty(a) {
+  return a.length === 0;
+}
+function ResizeArray_append(a, b) {
+  const c = [];
+  let enumerator = getEnumerator(a);
+  try {
+    while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+      const i = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+      void c.push(i);
+    }
+  } finally {
+    disposeSafe(enumerator);
+  }
+  let enumerator_1 = getEnumerator(b);
+  try {
+    while (enumerator_1["System.Collections.IEnumerator.MoveNext"]()) {
+      const i_1 = enumerator_1["System.Collections.Generic.IEnumerator`1.get_Current"]();
+      void c.push(i_1);
+    }
+  } finally {
+    disposeSafe(enumerator_1);
+  }
+  return c;
+}
+function ResizeArray_appendSingleton(b, a) {
+  const c = [];
+  let enumerator = getEnumerator(a);
+  try {
+    while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+      const i = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+      void c.push(i);
+    }
+  } finally {
+    disposeSafe(enumerator);
+  }
+  void c.push(b);
+  return c;
+}
+function ResizeArray_indexed(a) {
+  const b = [];
+  for (let i = 0; i <= a.length - 1; i++) {
+    void b.push([i, a[i]]);
+  }
+  return b;
+}
+function ResizeArray_groupBy(f, a) {
+  const collection = map((tupledArg) => [tupledArg[0], Array.from(tupledArg[1])], groupBy(f, a, {
+    Equals: equals,
+    GetHashCode: structuralHash
+  }));
+  return Array.from(collection);
+}
+function ResizeArray_tryPick(f, a) {
+  const loop = (i_mut) => {
+    loop:
+      while (true) {
+        const i = i_mut;
+        if (i < a.length) {
+          const matchValue = f(a[i]);
+          if (matchValue == null) {
+            i_mut = i + 1;
+            continue loop;
+          } else {
+            return some(value(matchValue));
+          }
+        } else {
+          return void 0;
+        }
+      }
+  };
+  return loop(0);
+}
+function ResizeArray_zip(a, b) {
+  const c = [];
+  const n = min(a.length, b.length) | 0;
+  for (let i = 0; i <= n - 1; i++) {
+    void c.push([a[i], b[i]]);
+  }
+  return c;
+}
+function ResizeArray_tryFind(f, a) {
+  const loop = (i_mut) => {
+    loop:
+      while (true) {
+        const i = i_mut;
+        if (i < a.length) {
+          if (f(a[i])) {
+            return some(a[i]);
+          } else {
+            i_mut = i + 1;
+            continue loop;
+          }
+        } else {
+          return void 0;
+        }
+      }
+  };
+  return loop(0);
+}
+
+export { Dictionary_init, Dictionary_items, Dictionary_ofSeq, Dictionary_tryFind, List_tryPickAndRemove, Option_fromSeq, Option_fromValueWithDefault, ResizeArray_append, ResizeArray_appendSingleton, ResizeArray_choose, ResizeArray_collect, ResizeArray_create, ResizeArray_distinct, ResizeArray_filter, ResizeArray_fold, ResizeArray_groupBy, ResizeArray_indexed, ResizeArray_init, ResizeArray_isEmpty, ResizeArray_iter, ResizeArray_iteri, ResizeArray_map, ResizeArray_mapi, ResizeArray_singleton, ResizeArray_tryFind, ResizeArray_tryPick, ResizeArray_zip, StringDictionary_ofSeq };

package/dist/ts/ts/Core/Helper/HashCodes.js

@@ -0,0 +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 as fold$1 } from '../../../node_modules/@fable-org/fable-library-js/Array.js';
+import { fold } 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$1((acc, o) => mergeHashes(acc, hash(o)), 0, a);
+}
+function boxHashSeq(a) {
+  return fold((acc, o) => mergeHashes(acc, hash(o)), 0, a);
+}
+
+export { boxHashArray, boxHashOption, boxHashSeq, hash, hashDateTime, mergeHashes };

package/dist/ts/ts/Core/Helper/Identifier.js

@@ -0,0 +1,96 @@
+import { ActivePatterns_$007CRegex$007C_$007C } from './Regex.js';
+import { newGuid } from '../../../node_modules/@fable-org/fable-library-js/Guid.js';
+import { value } from '../../../node_modules/@fable-org/fable-library-js/Option.js';
+import { combineMany } from '../../FileSystem/Path.js';
+
+function tryCheckValidCharacters(identifier) {
+  if (ActivePatterns_$007CRegex$007C_$007C("^[a-zA-Z0-9_\\- ]+$", identifier) != null) {
+    return true;
+  } else {
+    return false;
+  }
+}
+function checkValidCharacters(identifier) {
+  if (tryCheckValidCharacters(identifier)) ; else {
+    throw new Error(`New identifier "${identifier}"contains forbidden characters! Allowed characters are: letters, digits, underscore (_), dash (-) and whitespace ( ).`);
+  }
+}
+function createMissingIdentifier() {
+  let copyOfStruct;
+  return "MISSING_IDENTIFIER_" + (copyOfStruct = newGuid(), copyOfStruct);
+}
+function removeMissingIdentifier(str) {
+  if (str.startsWith("MISSING_IDENTIFIER_")) {
+    return "";
+  } else {
+    return str;
+  }
+}
+function Assay_tryIdentifierFromFileName(fileName) {
+  const activePatternResult = ActivePatterns_$007CRegex$007C_$007C("^(assays(\\/|\\\\))?(?<identifier>[a-zA-Z0-9_\\- ]+)((\\/|\\\\)isa.assay.xlsx)?$", fileName);
+  if (activePatternResult != null) {
+    const m = value(activePatternResult);
+    return m.groups && m.groups.identifier || "";
+  } else {
+    return void 0;
+  }
+}
+function Assay_fileNameFromIdentifier(identifier) {
+  checkValidCharacters(identifier);
+  return combineMany(["assays", identifier, "isa.assay.xlsx"]);
+}
+function Assay_datamapFileNameFromIdentifier(identifier) {
+  checkValidCharacters(identifier);
+  return combineMany(["assays", identifier, "isa.datamap.xlsx"]);
+}
+function Study_tryIdentifierFromFileName(fileName) {
+  const activePatternResult = ActivePatterns_$007CRegex$007C_$007C("^(studies(\\/|\\\\))?(?<identifier>[a-zA-Z0-9_\\- ]+)((\\/|\\\\)isa.study.xlsx)?$", fileName);
+  if (activePatternResult != null) {
+    const m = value(activePatternResult);
+    return m.groups && m.groups.identifier || "";
+  } else {
+    return void 0;
+  }
+}
+function Study_fileNameFromIdentifier(identifier) {
+  checkValidCharacters(identifier);
+  return combineMany(["studies", identifier, "isa.study.xlsx"]);
+}
+function Study_tryFileNameFromIdentifier(identifier) {
+  if (tryCheckValidCharacters(identifier)) {
+    return combineMany(["studies", identifier, "isa.study.xlsx"]);
+  } else {
+    return void 0;
+  }
+}
+function Study_datamapFileNameFromIdentifier(identifier) {
+  checkValidCharacters(identifier);
+  return combineMany(["studies", identifier, "isa.datamap.xlsx"]);
+}
+function Workflow_tryIdentifierFromFileName(fileName) {
+  const activePatternResult = ActivePatterns_$007CRegex$007C_$007C("^(workflows(\\/|\\\\))?(?<identifier>[a-zA-Z0-9_\\- ]+)((\\/|\\\\)isa.workflow.xlsx)?$", fileName);
+  if (activePatternResult != null) {
+    const m = value(activePatternResult);
+    return m.groups && m.groups.identifier || "";
+  } else {
+    return void 0;
+  }
+}
+function Workflow_fileNameFromIdentifier(identifier) {
+  checkValidCharacters(identifier);
+  return combineMany(["workflows", identifier, "isa.workflow.xlsx"]);
+}
+function Workflow_datamapFileNameFromIdentifier(identifier) {
+  checkValidCharacters(identifier);
+  return combineMany(["workflows", identifier, "isa.datamap.xlsx"]);
+}
+function Run_fileNameFromIdentifier(identifier) {
+  checkValidCharacters(identifier);
+  return combineMany(["runs", identifier, "isa.run.xlsx"]);
+}
+function Run_datamapFileNameFromIdentifier(identifier) {
+  checkValidCharacters(identifier);
+  return combineMany(["runs", identifier, "isa.datamap.xlsx"]);
+}
+
+export { Assay_datamapFileNameFromIdentifier, Assay_fileNameFromIdentifier, Assay_tryIdentifierFromFileName, Run_datamapFileNameFromIdentifier, Run_fileNameFromIdentifier, Study_datamapFileNameFromIdentifier, Study_fileNameFromIdentifier, Study_tryFileNameFromIdentifier, Study_tryIdentifierFromFileName, Workflow_datamapFileNameFromIdentifier, Workflow_fileNameFromIdentifier, Workflow_tryIdentifierFromFileName, checkValidCharacters, createMissingIdentifier, removeMissingIdentifier, tryCheckValidCharacters };

package/dist/ts/ts/Core/Helper/ORCID.js

@@ -0,0 +1,34 @@
+import { match } from '../../../node_modules/@fable-org/fable-library-js/RegExp.js';
+import { value } from '../../../node_modules/@fable-org/fable-library-js/Option.js';
+import { ActivePatterns_$007CRegex$007C_$007C } from './Regex.js';
+
+const orcidRegex = /[0-9]{4}-[0-9]{4}-[0-9]{4}-[0-9]{3}[0-9X]/gu;
+function tryGetOrcidNumber(orcid) {
+  const m = match(orcidRegex, orcid);
+  if (m != null) {
+    return m[0];
+  } else {
+    return void 0;
+  }
+}
+const orcidPrefix = "http://orcid.org/";
+function $007CORCID$007C_$007C(input) {
+  const activePatternResult = ActivePatterns_$007CRegex$007C_$007C("[0-9]{4}-[0-9]{4}-[0-9]{4}-[0-9]{3}[0-9X]", input);
+  if (activePatternResult != null) {
+    const r = value(activePatternResult);
+    return r[0];
+  } else {
+    return void 0;
+  }
+}
+function tryGetOrcidURL(orcid) {
+  const activePatternResult = $007CORCID$007C_$007C(orcid);
+  if (activePatternResult != null) {
+    const orcid_1 = value(activePatternResult);
+    return `${orcidPrefix}${orcid_1}`;
+  } else {
+    return void 0;
+  }
+}
+
+export { $007CORCID$007C_$007C, orcidPrefix, orcidRegex, tryGetOrcidNumber, tryGetOrcidURL };