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

package/dist/ts/ts/FileSystem/FileSystemTree.js

@@ -0,0 +1,339 @@
+import { defaultArg, unwrap } from '../../node_modules/@fable-org/fable-library-js/Option.js';
+import { tryFind, map, append, item, tryPick, head, tail, choose, equalsWith } from '../../node_modules/@fable-org/fable-library-js/Array.js';
+import { split, combineMany } from './Path.js';
+import { toArray, delay, append as append$1, singleton } from '../../node_modules/@fable-org/fable-library-js/Seq.js';
+import { Array_distinct, Array_groupBy } from '../../node_modules/@fable-org/fable-library-js/Seq2.js';
+import { curry2, arrayHash, stringHash } from '../../node_modules/@fable-org/fable-library-js/Util.js';
+import { empty, cons, toArray as toArray$1, reverse } from '../../node_modules/@fable-org/fable-library-js/List.js';
+import { Union } from '../../node_modules/@fable-org/fable-library-js/Types.js';
+
+function FileSystemTree_File(name) {
+  return new FileSystemTree(0, [name]);
+}
+function FileSystemTree_Folder(name, children) {
+  return new FileSystemTree(1, [name, children]);
+}
+class FileSystemTree extends Union {
+  constructor(tag, fields) {
+    super();
+    this.tag = tag;
+    this.fields = fields;
+  }
+  cases() {
+    return ["File", "Folder"];
+  }
+  get Name() {
+    const this$ = this;
+    let n;
+    if (this$.tag === /* Folder */
+    1) {
+      n = this$.fields[0];
+    } else {
+      n = this$.fields[0];
+    }
+    return n;
+  }
+  get isFolder() {
+    const this$ = this;
+    return this$.tag === /* Folder */
+    1;
+  }
+  get isFile() {
+    const this$ = this;
+    return this$.tag === /* File */
+    0;
+  }
+  static get ROOT_NAME() {
+    return "root";
+  }
+  static createFile(name) {
+    return FileSystemTree_File(name);
+  }
+  static createFolder(name, children) {
+    return FileSystemTree_Folder(name, defaultArg(children, []));
+  }
+  static createRootFolder(children) {
+    return FileSystemTree_Folder(FileSystemTree.ROOT_NAME, children);
+  }
+  TryGetChildByName(name) {
+    const this$ = this;
+    return this$.tag === /* File */
+    0 ? void 0 : tryFind((c) => c.Name === name, this$.fields[1]);
+  }
+  static tryGetChildByName(name) {
+    return (fst) => fst.TryGetChildByName(name);
+  }
+  ContainsChildWithName(name) {
+    const this$ = this;
+    if (this$.tag === /* File */
+    0) {
+      return false;
+    } else {
+      const array = this$.fields[1];
+      return array.some((c) => c.Name === name);
+    }
+  }
+  static containsChildWithName(name) {
+    return (fst) => fst.ContainsChildWithName(name);
+  }
+  TryGetPath(path) {
+    const this$ = this;
+    const loop = (parent, pathParts) => {
+      if (parent.tag === /* File */
+      0) {
+        const name_1 = parent.fields[0];
+        if (pathParts.length === 1 && item(0, pathParts) === name_1) {
+          return parent;
+        } else {
+          return void 0;
+        }
+      } else if (parent.fields[0] === "root") {
+        const children = parent.fields[1];
+        return tryPick((child) => loop(child, pathParts), children);
+      } else {
+        const children_1 = parent.fields[1];
+        const name = parent.fields[0];
+        if (name === head(pathParts)) {
+          if (pathParts.length === 1) {
+            return parent;
+          } else {
+            const remainingParts = tail(pathParts);
+            return tryPick((child_1) => loop(child_1, remainingParts), children_1);
+          }
+        } else {
+          return void 0;
+        }
+      }
+    };
+    return loop(this$, split(path));
+  }
+  AddFile(path) {
+    const this$ = this;
+    const existingPaths = this$.ToFilePaths();
+    const filePaths = toArray(delay(() => append$1(singleton(path), delay(() => existingPaths))));
+    return FileSystemTree.fromFilePaths(filePaths);
+  }
+  static addFile(path) {
+    return (tree) => tree.AddFile(path);
+  }
+  static fromFilePaths(paths) {
+    const loop = (paths_1, parent) => {
+      const files = map((arg) => {
+        const name = head(arg);
+        return FileSystemTree.createFile(name);
+      }, paths_1.filter((p) => p.length === 1));
+      const folders = map((tupledArg) => {
+        const parent_1 = FileSystemTree.createFolder(tupledArg[0], []);
+        return loop(map(tail, tupledArg[1]), parent_1);
+      }, Array_groupBy(head, paths_1.filter((p_1) => p_1.length > 1), {
+        Equals: (x_3, y_2) => x_3 === y_2,
+        GetHashCode: stringHash
+      }));
+      if (parent.tag === /* Folder */
+      1) {
+        const name_1 = parent.fields[0];
+        return FileSystemTree.createFolder(name_1, toArray(delay(() => append$1(files, delay(() => folders)))));
+      } else {
+        return parent;
+      }
+    };
+    return loop(Array_distinct(map(split, paths), {
+      Equals: (x, y) => equalsWith((x_1, y_1) => x_1 === y_1, x, y),
+      GetHashCode: arrayHash
+    }), FileSystemTree.createFolder(FileSystemTree.ROOT_NAME, []));
+  }
+  ToFilePaths(removeRoot) {
+    const this$ = this;
+    const res = [];
+    const loop = (output, parent) => {
+      if (parent.tag === /* Folder */
+      1) {
+        const n_1 = parent.fields[0];
+        const array = parent.fields[1];
+        array.forEach((filest) => {
+          loop(cons(n_1, output), filest);
+        });
+      } else {
+        const item = combineMany(toArray$1(reverse(cons(parent.fields[0], output))));
+        void res.push(item);
+      }
+    };
+    if (defaultArg(removeRoot, true)) {
+      if (this$.tag === /* File */
+      0) {
+        const n_2 = this$.fields[0];
+        void res.push(n_2);
+      } else {
+        const children_1 = this$.fields[1];
+        const action_1 = curry2(loop)(empty());
+        children_1.forEach(action_1);
+      }
+    } else {
+      loop(empty(), this$);
+    }
+    return Array.from(res);
+  }
+  static toFilePaths(removeRoot) {
+    return (root) => root.ToFilePaths(unwrap(removeRoot));
+  }
+  FilterFiles(predicate) {
+    const this$ = this;
+    const loop = (parent) => {
+      if (parent.tag === /* Folder */
+      1) {
+        return FileSystemTree_Folder(parent.fields[0], choose(loop, parent.fields[1]));
+      } else {
+        const n = parent.fields[0];
+        if (predicate(n)) {
+          return FileSystemTree_File(n);
+        } else {
+          return void 0;
+        }
+      }
+    };
+    return loop(this$);
+  }
+  static filterFiles(predicate) {
+    return (tree) => tree.FilterFiles(predicate);
+  }
+  FilterFolders(predicate) {
+    const this$ = this;
+    const loop = (parent) => {
+      if (parent.tag === /* Folder */
+      1) {
+        const n_1 = parent.fields[0];
+        const children = parent.fields[1];
+        if (predicate(n_1)) {
+          return FileSystemTree_Folder(n_1, choose(loop, children));
+        } else {
+          return void 0;
+        }
+      } else {
+        return FileSystemTree_File(parent.fields[0]);
+      }
+    };
+    return loop(this$);
+  }
+  static filterFolders(predicate) {
+    return (tree) => tree.FilterFolders(predicate);
+  }
+  Filter(predicate) {
+    const this$ = this;
+    const loop = (parent) => {
+      if (parent.tag === /* Folder */
+      1) {
+        const n_1 = parent.fields[0];
+        const children = parent.fields[1];
+        if (predicate(n_1)) {
+          const filteredChildren = choose(loop, children);
+          if (filteredChildren.length === 0) {
+            return void 0;
+          } else {
+            return FileSystemTree_Folder(n_1, filteredChildren);
+          }
+        } else {
+          return void 0;
+        }
+      } else {
+        const n = parent.fields[0];
+        if (predicate(n)) {
+          return FileSystemTree_File(n);
+        } else {
+          return void 0;
+        }
+      }
+    };
+    return loop(this$);
+  }
+  static filter(predicate) {
+    return (tree) => tree.Filter(predicate);
+  }
+  Union(otherFST) {
+    let array_1;
+    const this$ = this;
+    const paths = Array_distinct((array_1 = this$.ToFilePaths(), append(otherFST.ToFilePaths(), array_1)), {
+      Equals: (x, y) => x === y,
+      GetHashCode: stringHash
+    });
+    return FileSystemTree.fromFilePaths(paths);
+  }
+  Copy() {
+    const this$ = this;
+    return this$.tag === /* File */
+    0 ? FileSystemTree_File(this$.fields[0]) : FileSystemTree_Folder(this$.fields[0], map((c) => c.Copy(), this$.fields[1]));
+  }
+  static createGitKeepFile() {
+    return FileSystemTree.createFile(".gitkeep");
+  }
+  static createReadmeFile() {
+    return FileSystemTree.createFile("README.md");
+  }
+  static createEmptyFolder(name) {
+    return FileSystemTree.createFolder(name, [FileSystemTree.createGitKeepFile()]);
+  }
+  static createAssayFolder(assayName, hasDataMap) {
+    const hasDataMap_1 = defaultArg(hasDataMap, false);
+    const dataset = FileSystemTree.createEmptyFolder("dataset");
+    const protocols = FileSystemTree.createEmptyFolder("protocols");
+    const readme = FileSystemTree.createReadmeFile();
+    const assayFile = FileSystemTree.createFile("isa.assay.xlsx");
+    if (hasDataMap_1) {
+      const dataMapFile = FileSystemTree.createFile("isa.datamap.xlsx");
+      return FileSystemTree.createFolder(assayName, [dataset, protocols, assayFile, readme, dataMapFile]);
+    } else {
+      return FileSystemTree.createFolder(assayName, [dataset, protocols, assayFile, readme]);
+    }
+  }
+  static createStudyFolder(studyName, hasDataMap) {
+    const hasDataMap_1 = defaultArg(hasDataMap, false);
+    const resources = FileSystemTree.createEmptyFolder("resources");
+    const protocols = FileSystemTree.createEmptyFolder("protocols");
+    const readme = FileSystemTree.createReadmeFile();
+    const studyFile = FileSystemTree.createFile("isa.study.xlsx");
+    if (hasDataMap_1) {
+      const dataMapFile = FileSystemTree.createFile("isa.datamap.xlsx");
+      return FileSystemTree.createFolder(studyName, [resources, protocols, studyFile, readme, dataMapFile]);
+    } else {
+      return FileSystemTree.createFolder(studyName, [resources, protocols, studyFile, readme]);
+    }
+  }
+  static createWorkflowFolder(workflowName, hasDataMap) {
+    const hasDataMap_1 = defaultArg(hasDataMap, false);
+    const readme = FileSystemTree.createReadmeFile();
+    const workflowFile = FileSystemTree.createFile("isa.workflow.xlsx");
+    if (hasDataMap_1) {
+      const dataMapFile = FileSystemTree.createFile("isa.datamap.xlsx");
+      return FileSystemTree.createFolder(workflowName, [workflowFile, readme, dataMapFile]);
+    } else {
+      return FileSystemTree.createFolder(workflowName, [workflowFile, readme]);
+    }
+  }
+  static createRunFolder(runName, hasDataMap) {
+    const hasDataMap_1 = defaultArg(hasDataMap, false);
+    const readme = FileSystemTree.createReadmeFile();
+    const runFile = FileSystemTree.createFile("isa.run.xlsx");
+    if (hasDataMap_1) {
+      const dataMapFile = FileSystemTree.createFile("isa.datamap.xlsx");
+      return FileSystemTree.createFolder(runName, [runFile, readme, dataMapFile]);
+    } else {
+      return FileSystemTree.createFolder(runName, [runFile, readme]);
+    }
+  }
+  static createInvestigationFile() {
+    return FileSystemTree.createFile("isa.investigation.xlsx");
+  }
+  static createAssaysFolder(assays) {
+    return FileSystemTree.createFolder("assays", append([FileSystemTree.createGitKeepFile()], assays));
+  }
+  static createStudiesFolder(studies) {
+    return FileSystemTree.createFolder("studies", append([FileSystemTree.createGitKeepFile()], studies));
+  }
+  static createWorkflowsFolder(workflows) {
+    return FileSystemTree.createFolder("workflows", append([FileSystemTree.createGitKeepFile()], workflows));
+  }
+  static createRunsFolder(runs) {
+    return FileSystemTree.createFolder("runs", append([FileSystemTree.createGitKeepFile()], runs));
+  }
+}
+
+export { FileSystemTree, FileSystemTree_File, FileSystemTree_Folder };

package/dist/ts/ts/FileSystem/Path.js

@@ -0,0 +1,36 @@
+import { join, split as split$1, trimEnd, trimStart, trim } from '../../node_modules/@fable-org/fable-library-js/String.js';
+import { mapIndexed } from '../../node_modules/@fable-org/fable-library-js/Array.js';
+
+const seperators = ["/", "\\"];
+function split(path) {
+  const array = split$1(path, seperators, void 0, 3);
+  return array.filter((p) => {
+    if (p !== "") {
+      return p !== ".";
+    } else {
+      return false;
+    }
+  });
+}
+function combine(path1, path2) {
+  return trimEnd(path1, ...seperators) + "/" + trimStart(path2, ...seperators);
+}
+function combineMany(paths) {
+  return join("/", mapIndexed((i, p) => {
+    if (i === 0) {
+      return trimEnd(p, ...seperators);
+    } else if (i === paths.length - 1) {
+      return trimStart(p, ...seperators);
+    } else {
+      return trim(p, ...seperators);
+    }
+  }, paths));
+}
+function getAssayFolderPath(assayIdentifier) {
+  return combine("assays", assayIdentifier);
+}
+function getStudyFolderPath(studyIdentifier) {
+  return combine("studies", studyIdentifier);
+}
+
+export { combine, combineMany, getAssayFolderPath, getStudyFolderPath, seperators, split };

package/dist/ts/ts/Json/Assay.d.ts

@@ -1,6 +1,6 @@
 import { FSharpList } from '@fable-org/fable-library-js/List.js';
 import { Option } from '@fable-org/fable-library-js/Option.js';
-import { Decoder$1, IEncodable } from '../fable_modules/Thoth.Json.Core.0.4.0/Types.fs.js';
+import { Decoder$1, IEncodable } from '../fable_modules/Thoth.Json.Core.0.7.0/Types.fs.js';
 import { OntologyAnnotation } from '../Core/OntologyAnnotation.js';
 import { ArcAssay } from '../Core/ArcTypes.js';
 import { IMap } from '@fable-org/fable-library-js/Util.js';
@@ -11,7 +11,7 @@ export declare const decoder: Decoder$1<ArcAssay>;
 export declare function encoderCompressed(stringTable: IMap<string, int32>, oaTable: IMap<OntologyAnnotation, int32>, cellTable: IMap<CompositeCell_$union, int32>, assay: ArcAssay): IEncodable;
 export declare function decoderCompressed(stringTable: string[], oaTable: OntologyAnnotation[], cellTable: CompositeCell_$union[]): Decoder$1<ArcAssay>;
 export declare function ROCrate_genID(a: ArcAssay): string;
-export declare function ROCrate_encoder(studyName: Option<string>, a: ArcAssay): IEncodable;
+export declare function ROCrate_encoder(assayName: Option<string>, a: ArcAssay): IEncodable;
 export declare const ROCrate_decoder: Decoder$1<ArcAssay>;
 export declare function ISAJson_encoder(studyName: Option<string>, idMap: Option<IMap<string, IEncodable>>, a: ArcAssay): IEncodable;
 export declare const ISAJson_allowedFields: FSharpList<string>;

package/dist/ts/ts/Json/Assay.js

@@ -0,0 +1,221 @@
+import { ofArray, choose, singleton, empty } from '../../node_modules/@fable-org/fable-library-js/List.js';
+import { defaultArg, bind, map, value, unwrap } from '../../node_modules/@fable-org/fable-library-js/Option.js';
+import { tryInclude, tryIncludeSeq, tryIncludeList } from './Encode.js';
+import { OntologyAnnotation_ISAJson_decoder, OntologyAnnotation_decoder, OntologyAnnotation_ROCrate_decoderPropertyValue, OntologyAnnotation_ROCrate_decoderDefinedTerm, OntologyAnnotation_encoder, OntologyAnnotation_ROCrate_encoderPropertyValue, OntologyAnnotation_ROCrate_encoderDefinedTerm, OntologyAnnotation_ISAJson_encoder } from './OntologyAnnotation.js';
+import { decoder as decoder$2, decoderCompressed as decoderCompressed$2, encoder as encoder$1, encoderCompressed as encoderCompressed$2 } from './DataMap/DataMap.js';
+import { decoder as decoder$1, decoderCompressed as decoderCompressed$1, encoder as encoder$2, encoderCompressed as encoderCompressed$1 } from './Table/ArcTable.js';
+import { decoder as decoder$3, ROCrate_decoder as ROCrate_decoder$2, encoder as encoder$3, ROCrate_encoder as ROCrate_encoder$1 } from './Person.js';
+import { ISAJson_decoder as ISAJson_decoder$2, decoder as decoder$4, ROCrate_decoder as ROCrate_decoder$3, encoder as encoder$4, ROCrate_encoder as ROCrate_encoder$3, ISAJson_encoder as ISAJson_encoder$3 } from './Comment.js';
+import { Comment$ } from '../Core/Comment.js';
+import { tryPick, length, map as map$2, toList, delay, append, empty as empty$1, singleton as singleton$1 } from '../../node_modules/@fable-org/fable-library-js/Seq.js';
+import { ArcAssay } from '../Core/ArcTypes.js';
+import { string, list, resizeArray, map as map$1, object } from '../fable_modules/Thoth.Json.Core.0.7.0/Decode.fs.js';
+import { replace } from '../../node_modules/@fable-org/fable-library-js/String.js';
+import { createMissingIdentifier, Assay_tryIdentifierFromFileName, Assay_fileNameFromIdentifier } from '../Core/Helper/Identifier.js';
+import { ARCtrl_ArcTables__ArcTables_fromProcesses_Static_62A3309D, JsonTypes_decomposeTechnologyPlatform, ARCtrl_ArcTables__ArcTables_GetProcesses, JsonTypes_composeTechnologyPlatform } from '../Core/Conversion.js';
+import { getData, getUnits, getCharacteristics } from '../Core/Process/ProcessSequence.js';
+import { list as list$1 } from '../fable_modules/Thoth.Json.Core.0.7.0/Encode.fs.js';
+import { ISAJson_encoder as ISAJson_encoder$1, ROCrate_encoder as ROCrate_encoder$4 } from './Data.js';
+import { ISAJson_decoder as ISAJson_decoder$1, ROCrate_decoder as ROCrate_decoder$1, ROCrate_encoder as ROCrate_encoder$2, ISAJson_encoder as ISAJson_encoder$2 } from './Process/Process.js';
+import { context_jsonvalue } from './context/rocrate/isa_assay_context.js';
+import { encoder as encoder$5 } from './Process/MaterialAttribute.js';
+import { encoder as encoder$6 } from './Process/AssayMaterials.js';
+import { ResizeArray_filter, Option_fromValueWithDefault } from '../Core/Helper/Collections.js';
+import { encode } from './IDTable.js';
+import { Decode_objectNoAdditionalProperties } from './Decode.js';
+
+function encoder(assay) {
+  let value;
+  const values_1 = choose((tupledArg) => map((v_1) => [tupledArg[0], v_1], tupledArg[1]), ofArray([["Identifier", (value = assay.Identifier, {
+    Encode(helpers) {
+      return helpers.encodeString(value);
+    }
+  })], tryInclude("Title", (value_1) => ({
+    Encode(helpers_1) {
+      return helpers_1.encodeString(value_1);
+    }
+  }), assay.Title), tryInclude("Description", (value_3) => ({
+    Encode(helpers_2) {
+      return helpers_2.encodeString(value_3);
+    }
+  }), assay.Description), tryInclude("MeasurementType", OntologyAnnotation_encoder, assay.MeasurementType), tryInclude("TechnologyType", OntologyAnnotation_encoder, assay.TechnologyType), tryInclude("TechnologyPlatform", OntologyAnnotation_encoder, assay.TechnologyPlatform), tryInclude("DataMap", encoder$1, assay.DataMap), tryIncludeSeq("Tables", encoder$2, assay.Tables), tryIncludeSeq("Performers", encoder$3, assay.Performers), tryIncludeSeq("Comments", encoder$4, assay.Comments)]));
+  return {
+    Encode(helpers_3) {
+      const arg = map$2((tupledArg_1) => [tupledArg_1[0], tupledArg_1[1].Encode(helpers_3)], values_1);
+      return helpers_3.encodeObject(arg);
+    }
+  };
+}
+const decoder = object((get$) => {
+  let objectArg, objectArg_1, objectArg_2, objectArg_3, objectArg_4, objectArg_5, arg_13, objectArg_6, objectArg_7, arg_17, objectArg_8, arg_19, objectArg_9;
+  return ArcAssay.create((objectArg = get$.Required, objectArg.Field("Identifier", string)), unwrap((objectArg_1 = get$.Optional, objectArg_1.Field("Title", string))), unwrap((objectArg_2 = get$.Optional, objectArg_2.Field("Description", string))), unwrap((objectArg_3 = get$.Optional, objectArg_3.Field("MeasurementType", OntologyAnnotation_decoder))), unwrap((objectArg_4 = get$.Optional, objectArg_4.Field("TechnologyType", OntologyAnnotation_decoder))), unwrap((objectArg_5 = get$.Optional, objectArg_5.Field("TechnologyPlatform", OntologyAnnotation_decoder))), unwrap((arg_13 = resizeArray(decoder$1), objectArg_6 = get$.Optional, objectArg_6.Field("Tables", arg_13))), unwrap((objectArg_7 = get$.Optional, objectArg_7.Field("DataMap", decoder$2))), unwrap((arg_17 = resizeArray(decoder$3), objectArg_8 = get$.Optional, objectArg_8.Field("Performers", arg_17))), unwrap((arg_19 = resizeArray(decoder$4), objectArg_9 = get$.Optional, objectArg_9.Field("Comments", arg_19))));
+});
+function encoderCompressed(stringTable, oaTable, cellTable, assay) {
+  let value;
+  const values_1 = choose((tupledArg) => map((v_1) => [tupledArg[0], v_1], tupledArg[1]), ofArray([["Identifier", (value = assay.Identifier, {
+    Encode(helpers) {
+      return helpers.encodeString(value);
+    }
+  })], tryInclude("Title", (value_1) => ({
+    Encode(helpers_1) {
+      return helpers_1.encodeString(value_1);
+    }
+  }), assay.Title), tryInclude("Description", (value_3) => ({
+    Encode(helpers_2) {
+      return helpers_2.encodeString(value_3);
+    }
+  }), assay.Description), tryInclude("MeasurementType", OntologyAnnotation_encoder, assay.MeasurementType), tryInclude("TechnologyType", OntologyAnnotation_encoder, assay.TechnologyType), tryInclude("TechnologyPlatform", OntologyAnnotation_encoder, assay.TechnologyPlatform), tryIncludeSeq("Tables", (table) => encoderCompressed$1(stringTable, oaTable, cellTable, table), assay.Tables), tryInclude("DataMap", (dm) => encoderCompressed$2(stringTable, oaTable, cellTable, dm), assay.DataMap), tryIncludeSeq("Performers", encoder$3, assay.Performers), tryIncludeSeq("Comments", encoder$4, assay.Comments)]));
+  return {
+    Encode(helpers_3) {
+      const arg = map$2((tupledArg_1) => [tupledArg_1[0], tupledArg_1[1].Encode(helpers_3)], values_1);
+      return helpers_3.encodeObject(arg);
+    }
+  };
+}
+function decoderCompressed(stringTable, oaTable, cellTable) {
+  return object((get$) => {
+    let objectArg, objectArg_1, objectArg_2, objectArg_3, objectArg_4, objectArg_5, arg_13, objectArg_6, arg_15, objectArg_7, arg_17, objectArg_8, arg_19, objectArg_9;
+    return ArcAssay.create((objectArg = get$.Required, objectArg.Field("Identifier", string)), unwrap((objectArg_1 = get$.Optional, objectArg_1.Field("Title", string))), unwrap((objectArg_2 = get$.Optional, objectArg_2.Field("Description", string))), unwrap((objectArg_3 = get$.Optional, objectArg_3.Field("MeasurementType", OntologyAnnotation_decoder))), unwrap((objectArg_4 = get$.Optional, objectArg_4.Field("TechnologyType", OntologyAnnotation_decoder))), unwrap((objectArg_5 = get$.Optional, objectArg_5.Field("TechnologyPlatform", OntologyAnnotation_decoder))), unwrap((arg_13 = resizeArray(decoderCompressed$1(stringTable, oaTable, cellTable)), objectArg_6 = get$.Optional, objectArg_6.Field("Tables", arg_13))), unwrap((arg_15 = decoderCompressed$2(), objectArg_7 = get$.Optional, objectArg_7.Field("DataMap", arg_15))), unwrap((arg_17 = resizeArray(decoder$3), objectArg_8 = get$.Optional, objectArg_8.Field("Performers", arg_17))), unwrap((arg_19 = resizeArray(decoder$4), objectArg_9 = get$.Optional, objectArg_9.Field("Comments", arg_19))));
+  });
+}
+function ROCrate_genID(a) {
+  const matchValue = a.Identifier;
+  if (matchValue === "") {
+    return "#EmptyAssay";
+  } else {
+    return `assays/${replace(matchValue, " ", "_")}/`;
+  }
+}
+function ROCrate_encoder(assayName, a) {
+  let value, value_3, assayName_1;
+  const fileName = Assay_fileNameFromIdentifier(a.Identifier);
+  const processes = ARCtrl_ArcTables__ArcTables_GetProcesses(a);
+  const dataFiles = getData(processes);
+  const values_1 = choose((tupledArg) => map((v_1) => [tupledArg[0], v_1], tupledArg[1]), ofArray([["@id", (value = ROCrate_genID(a), {
+    Encode(helpers) {
+      return helpers.encodeString(value);
+    }
+  })], ["@type", list$1(singleton({
+    Encode(helpers_1) {
+      return helpers_1.encodeString("Assay");
+    }
+  }))], ["additionalType", {
+    Encode(helpers_2) {
+      return helpers_2.encodeString("Assay");
+    }
+  }], ["identifier", (value_3 = a.Identifier, {
+    Encode(helpers_3) {
+      return helpers_3.encodeString(value_3);
+    }
+  })], ["filename", {
+    Encode(helpers_4) {
+      return helpers_4.encodeString(fileName);
+    }
+  }], tryInclude("title", (value_5) => ({
+    Encode(helpers_5) {
+      return helpers_5.encodeString(value_5);
+    }
+  }), a.Title), tryInclude("description", (value_7) => ({
+    Encode(helpers_6) {
+      return helpers_6.encodeString(value_7);
+    }
+  }), a.Description), tryInclude("measurementType", OntologyAnnotation_ROCrate_encoderPropertyValue, a.MeasurementType), tryInclude("technologyType", OntologyAnnotation_ROCrate_encoderDefinedTerm, a.TechnologyType), tryInclude("technologyPlatform", OntologyAnnotation_ROCrate_encoderDefinedTerm, a.TechnologyPlatform), tryIncludeSeq("performers", ROCrate_encoder$1, a.Performers), tryIncludeList("dataFiles", ROCrate_encoder$4, dataFiles), tryIncludeList("processSequence", (assayName_1 = a.Identifier, (oa_5) => ROCrate_encoder$2(assayName, assayName_1, oa_5)), processes), tryIncludeSeq("comments", ROCrate_encoder$3, a.Comments), ["@context", context_jsonvalue]]));
+  return {
+    Encode(helpers_7) {
+      const arg = map$2((tupledArg_1) => [tupledArg_1[0], tupledArg_1[1].Encode(helpers_7)], values_1);
+      return helpers_7.encodeObject(arg);
+    }
+  };
+}
+const ROCrate_decoder = object((get$) => {
+  let objectArg, arg_3, objectArg_1, objectArg_2, objectArg_3, objectArg_4, objectArg_5, objectArg_6, arg_16, objectArg_7, arg_18, objectArg_8;
+  const identifier = defaultArg((objectArg = get$.Optional, objectArg.Field("identifier", string)), createMissingIdentifier());
+  const tables = map((arg_4) => {
+    const a = ARCtrl_ArcTables__ArcTables_fromProcesses_Static_62A3309D(arg_4);
+    return a.Tables;
+  }, (arg_3 = list(ROCrate_decoder$1), objectArg_1 = get$.Optional, objectArg_1.Field("processSequence", arg_3)));
+  return new ArcAssay(identifier, unwrap((objectArg_2 = get$.Optional, objectArg_2.Field("title", string))), unwrap((objectArg_3 = get$.Optional, objectArg_3.Field("description", string))), unwrap((objectArg_4 = get$.Optional, objectArg_4.Field("measurementType", OntologyAnnotation_ROCrate_decoderPropertyValue))), unwrap((objectArg_5 = get$.Optional, objectArg_5.Field("technologyType", OntologyAnnotation_ROCrate_decoderDefinedTerm))), unwrap((objectArg_6 = get$.Optional, objectArg_6.Field("technologyPlatform", OntologyAnnotation_ROCrate_decoderDefinedTerm))), unwrap(tables), void 0, unwrap((arg_16 = resizeArray(ROCrate_decoder$2), objectArg_7 = get$.Optional, objectArg_7.Field("performers", arg_16))), unwrap((arg_18 = resizeArray(ROCrate_decoder$3), objectArg_8 = get$.Optional, objectArg_8.Field("comments", arg_18))));
+});
+function ISAJson_encoder(studyName, idMap, a) {
+  const f = (a_1) => {
+    let assayName;
+    const fileName = Assay_fileNameFromIdentifier(a_1.Identifier);
+    const processes = ARCtrl_ArcTables__ArcTables_GetProcesses(a_1);
+    const encodedUnits = tryIncludeList("unitCategories", (oa) => OntologyAnnotation_ISAJson_encoder(idMap, oa), getUnits(processes));
+    const encodedCharacteristics = tryIncludeList("characteristicCategories", (value_1) => encoder$5(idMap, value_1), getCharacteristics(processes));
+    const encodedMaterials = tryInclude("materials", (ps) => encoder$6(idMap, ps), Option_fromValueWithDefault(empty(), processes));
+    const encocedDataFiles = tryIncludeList("dataFiles", (oa_1) => ISAJson_encoder$1(idMap, oa_1), getData(processes));
+    getUnits(processes);
+    const comments = toList(delay(() => append(a_1.Comments.length > 0 ? a_1.Comments : empty$1(), delay(() => append(a_1.Title != null ? singleton$1(Comment$.create("title", value(a_1.Title))) : empty$1(), delay(() => a_1.Description != null ? singleton$1(Comment$.create("description", value(a_1.Description))) : empty$1()))))));
+    const values_1 = choose((tupledArg) => map((v_1) => [tupledArg[0], v_1], tupledArg[1]), ofArray([["filename", {
+      Encode(helpers) {
+        return helpers.encodeString(fileName);
+      }
+    }], tryInclude("@id", (value_5) => ({
+      Encode(helpers_1) {
+        return helpers_1.encodeString(value_5);
+      }
+    }), ROCrate_genID(a_1)), tryInclude("measurementType", (oa_2) => OntologyAnnotation_ISAJson_encoder(idMap, oa_2), a_1.MeasurementType), tryInclude("technologyType", (oa_3) => OntologyAnnotation_ISAJson_encoder(idMap, oa_3), a_1.TechnologyType), tryInclude("technologyPlatform", (value_7) => ({
+      Encode(helpers_2) {
+        return helpers_2.encodeString(value_7);
+      }
+    }), map(JsonTypes_composeTechnologyPlatform, a_1.TechnologyPlatform)), encocedDataFiles, encodedMaterials, encodedCharacteristics, encodedUnits, tryIncludeList("processSequence", (assayName = a_1.Identifier, (oa_4) => ISAJson_encoder$2(studyName, assayName, idMap, oa_4)), processes), tryIncludeSeq("comments", (comment) => ISAJson_encoder$3(idMap, comment), comments)]));
+    return {
+      Encode(helpers_3) {
+        const arg = map$2((tupledArg_1) => [tupledArg_1[0], tupledArg_1[1].Encode(helpers_3)], values_1);
+        return helpers_3.encodeObject(arg);
+      }
+    };
+  };
+  if (idMap != null) {
+    return encode(ROCrate_genID, f, a, value(idMap));
+  } else {
+    return f(a);
+  }
+}
+const ISAJson_allowedFields = ofArray(["@id", "filename", "measurementType", "technologyType", "technologyPlatform", "dataFiles", "materials", "characteristicCategories", "unitCategories", "processSequence", "comments", "@type", "@context"]);
+const ISAJson_decoder = Decode_objectNoAdditionalProperties(ISAJson_allowedFields, (get$) => {
+  let objectArg, arg_3, objectArg_1, objectArg_3, objectArg_4, arg_12, objectArg_5;
+  const identifier = defaultArg(bind(Assay_tryIdentifierFromFileName, (objectArg = get$.Optional, objectArg.Field("filename", string))), createMissingIdentifier());
+  const tables = map((arg_4) => {
+    const a = ARCtrl_ArcTables__ArcTables_fromProcesses_Static_62A3309D(arg_4);
+    return a.Tables;
+  }, (arg_3 = list(ISAJson_decoder$1), objectArg_1 = get$.Optional, objectArg_1.Field("processSequence", arg_3)));
+  let comments;
+  const arg_6 = resizeArray(ISAJson_decoder$2);
+  const objectArg_2 = get$.Optional;
+  comments = objectArg_2.Field("comments", arg_6);
+  const title = bind((c) => tryPick((x) => {
+    if (x.Name != null && value(x.Name) === "title") {
+      return x.Value;
+    } else {
+      return void 0;
+    }
+  }, c), comments);
+  const description = bind((c_1) => tryPick((x_1) => {
+    if (x_1.Name != null && value(x_1.Name) === "description") {
+      return x_1.Value;
+    } else {
+      return void 0;
+    }
+  }, c_1), comments);
+  const comments_1 = bind((c_2) => {
+    const matchValue = ResizeArray_filter((x_2) => {
+      if (x_2.Name == null) {
+        return true;
+      } else if (value(x_2.Name) !== "title") {
+        return value(x_2.Name) !== "description";
+      } else {
+        return false;
+      }
+    }, c_2);
+    if (length(matchValue) === 0) {
+      return void 0;
+    } else {
+      return matchValue;
+    }
+  }, comments);
+  return new ArcAssay(identifier, unwrap(title), unwrap(description), unwrap((objectArg_3 = get$.Optional, objectArg_3.Field("measurementType", OntologyAnnotation_ISAJson_decoder))), unwrap((objectArg_4 = get$.Optional, objectArg_4.Field("technologyType", OntologyAnnotation_ISAJson_decoder))), unwrap((arg_12 = map$1(JsonTypes_decomposeTechnologyPlatform, string), objectArg_5 = get$.Optional, objectArg_5.Field("technologyPlatform", arg_12))), unwrap(tables), void 0, void 0, unwrap(comments_1));
+});
+
+export { ISAJson_allowedFields, ISAJson_decoder, ISAJson_encoder, ROCrate_decoder, ROCrate_encoder, ROCrate_genID, decoder, decoderCompressed, encoder, encoderCompressed };

package/dist/ts/ts/Json/Comment.d.ts

@@ -1,5 +1,5 @@
 import { Option } from '@fable-org/fable-library-js/Option.js';
-import { Decoder$1, IEncodable } from '../fable_modules/Thoth.Json.Core.0.4.0/Types.fs.js';
+import { Decoder$1, IEncodable } from '../fable_modules/Thoth.Json.Core.0.7.0/Types.fs.js';
 import { Comment$ } from '../Core/Comment.js';
 import { IMap } from '@fable-org/fable-library-js/Util.js';
 export declare function encoder(comment: Comment$): IEncodable;