@nfdi4plants/arctrl 3.0.0-beta.9 → 3.0.0

package/dist/ts/ts/ROCrate/LDTypes/SoftwareSourceCode.js

@@ -0,0 +1,247 @@
+import { LDPerson } from './Person.js';
+import { unwrap, value } from '../../../node_modules/@fable-org/fable-library-js/Option.js';
+import { LDOrganization } from './Organization.js';
+import { LDNode } from '../LDObject.js';
+import { LDComment } from './Comment.js';
+import { clean } from '../Helper.js';
+import { createMissingIdentifier } from '../../Core/Helper/Identifier.js';
+import { class_type } from '../../../node_modules/@fable-org/fable-library-js/Reflection.js';
+
+class LDSoftwareSourceCode {
+  constructor() {
+  }
+  static get schemaType() {
+    return "http://schema.org/SoftwareSourceCode";
+  }
+  static get creator() {
+    return "http://schema.org/creator";
+  }
+  static get dateCreated() {
+    return "http://schema.org/dateCreated";
+  }
+  static get license() {
+    return "http://schema.org/license";
+  }
+  static get name() {
+    return "http://schema.org/name";
+  }
+  static get programmingLanguage() {
+    return "http://schema.org/programmingLanguage";
+  }
+  static get sdPublisher() {
+    return "http://schema.org/sdPublisher";
+  }
+  static get url() {
+    return "http://schema.org/url";
+  }
+  static get version() {
+    return "http://schema.org/version";
+  }
+  static get description() {
+    return "http://schema.org/description";
+  }
+  static get hasPart() {
+    return "http://schema.org/hasPart";
+  }
+  static get comment() {
+    return "http://schema.org/comment";
+  }
+  static getCreator(ssc, graph, context) {
+    return ssc.GetPropertyNodes(LDSoftwareSourceCode.creator, (ldObject, context_1) => {
+      if (LDPerson.validate(ldObject, unwrap(context_1))) {
+        return true;
+      } else {
+        return LDOrganization.validate(ldObject, unwrap(context_1));
+      }
+    }, unwrap(graph), unwrap(context));
+  }
+  static setCreator(ssc, creator, context) {
+    return ssc.SetProperty(LDSoftwareSourceCode.creator, creator, unwrap(context));
+  }
+  static tryGetDateCreated(ssc, context) {
+    const matchValue = ssc.TryGetPropertyAsSingleton(LDSoftwareSourceCode.dateCreated, unwrap(context));
+    let matchResult, d;
+    if (matchValue != null) {
+      if (typeof value(matchValue) === "string") {
+        matchResult = 0;
+        d = value(matchValue);
+      } else {
+        matchResult = 1;
+      }
+    } else {
+      matchResult = 1;
+    }
+    switch (matchResult) {
+      case 0:
+        return d;
+      default:
+        return void 0;
+    }
+  }
+  static setDateCreated(ssc, date, context) {
+    return ssc.SetProperty(LDSoftwareSourceCode.dateCreated, date, unwrap(context));
+  }
+  static getLicenses(ssc, graph, context) {
+    return ssc.GetPropertyNodes(LDSoftwareSourceCode.license, void 0, unwrap(graph), unwrap(context));
+  }
+  static setLicenses(ssc, licenses, context) {
+    return ssc.SetProperty(LDSoftwareSourceCode.license, licenses, unwrap(context));
+  }
+  static tryGetNameAsString(ssc, context) {
+    const matchValue = ssc.TryGetPropertyAsSingleton(LDSoftwareSourceCode.name, unwrap(context));
+    let matchResult, n;
+    if (matchValue != null) {
+      if (typeof value(matchValue) === "string") {
+        matchResult = 0;
+        n = value(matchValue);
+      } else {
+        matchResult = 1;
+      }
+    } else {
+      matchResult = 1;
+    }
+    switch (matchResult) {
+      case 0:
+        return n;
+      default:
+        return void 0;
+    }
+  }
+  static setNameAsString(ssc, name, context) {
+    return ssc.SetProperty(LDSoftwareSourceCode.name, name, unwrap(context));
+  }
+  static getProgrammingLanguages(ssc, graph, context) {
+    return ssc.GetPropertyNodes(LDSoftwareSourceCode.programmingLanguage, void 0, unwrap(graph), unwrap(context));
+  }
+  static setProgrammingLanguages(ssc, programmingLanguages, context) {
+    return ssc.SetProperty(LDSoftwareSourceCode.programmingLanguage, programmingLanguages, unwrap(context));
+  }
+  static tryGetSdPublisher(ssc, graph, context) {
+    let ldObject, context_1;
+    const matchValue = ssc.TryGetPropertyAsSingleNode(LDSoftwareSourceCode.sdPublisher, unwrap(graph), unwrap(context));
+    let matchResult, a_1;
+    if (matchValue != null) {
+      if (ldObject = value(matchValue), context_1 = context, LDPerson.validate(ldObject, unwrap(context_1)) ? true : LDOrganization.validate(ldObject, unwrap(context_1))) {
+        matchResult = 0;
+        a_1 = value(matchValue);
+      } else {
+        matchResult = 1;
+      }
+    } else {
+      matchResult = 1;
+    }
+    switch (matchResult) {
+      case 0:
+        return a_1;
+      default:
+        return void 0;
+    }
+  }
+  static setSdPublisher(ssc, sdPublisher, context) {
+    return ssc.SetProperty(LDSoftwareSourceCode.sdPublisher, sdPublisher, unwrap(context));
+  }
+  static tryGetUrl(ssc, context) {
+    const matchValue = ssc.TryGetPropertyAsSingleton(LDSoftwareSourceCode.url, unwrap(context));
+    let matchResult, u;
+    if (matchValue != null) {
+      if (typeof value(matchValue) === "string") {
+        matchResult = 0;
+        u = value(matchValue);
+      } else {
+        matchResult = 1;
+      }
+    } else {
+      matchResult = 1;
+    }
+    switch (matchResult) {
+      case 0:
+        return u;
+      default:
+        return void 0;
+    }
+  }
+  static setUrl(ssc, url, context) {
+    return ssc.SetProperty(LDSoftwareSourceCode.url, url, unwrap(context));
+  }
+  static tryGetVersion(ssc, context) {
+    const matchValue = ssc.TryGetPropertyAsSingleton(LDSoftwareSourceCode.version, unwrap(context));
+    let matchResult, v;
+    if (matchValue != null) {
+      if (typeof value(matchValue) === "string") {
+        matchResult = 0;
+        v = value(matchValue);
+      } else {
+        matchResult = 1;
+      }
+    } else {
+      matchResult = 1;
+    }
+    switch (matchResult) {
+      case 0:
+        return v;
+      default:
+        return void 0;
+    }
+  }
+  static setVersion(ssc, version, context) {
+    return ssc.SetProperty(LDSoftwareSourceCode.version, version, unwrap(context));
+  }
+  static tryGetDescription(ssc, context) {
+    const matchValue = ssc.TryGetPropertyAsSingleton(LDSoftwareSourceCode.description, unwrap(context));
+    let matchResult, d;
+    if (matchValue != null) {
+      if (typeof value(matchValue) === "string") {
+        matchResult = 0;
+        d = value(matchValue);
+      } else {
+        matchResult = 1;
+      }
+    } else {
+      matchResult = 1;
+    }
+    switch (matchResult) {
+      case 0:
+        return d;
+      default:
+        return void 0;
+    }
+  }
+  static setDescription(ssc, description, context) {
+    return ssc.SetProperty(LDSoftwareSourceCode.description, description, unwrap(context));
+  }
+  static getHasPart(ssc, graph, context) {
+    return ssc.GetPropertyNodes(LDSoftwareSourceCode.hasPart, void 0, unwrap(graph), unwrap(context));
+  }
+  static setHasPart(ssc, hasParts, context) {
+    return ssc.SetProperty(LDSoftwareSourceCode.hasPart, Array.from(hasParts), unwrap(context));
+  }
+  static getComments(ssc, graph, context) {
+    return ssc.GetPropertyNodes(LDSoftwareSourceCode.comment, (ldObject, context_1) => LDComment.validate(ldObject, unwrap(context_1)), unwrap(graph), unwrap(context));
+  }
+  static setComments(ssc, comments, context) {
+    return ssc.SetProperty(LDSoftwareSourceCode.comment, comments, unwrap(context));
+  }
+  static validate(lp, context) {
+    return lp.HasType(LDSoftwareSourceCode.schemaType, unwrap(context));
+  }
+  static create(id, creator, dateCreated, licenses, name, programmingLanguages, sdPublisher, url, version, description, hasParts, comments, context) {
+    const ssc = new LDNode(id == null ? clean(`#ComputationalWorkflow_${createMissingIdentifier()}`) : value(id), [LDSoftwareSourceCode.schemaType], void 0, unwrap(context));
+    ssc.SetOptionalProperty(LDSoftwareSourceCode.creator, creator, unwrap(context));
+    ssc.SetOptionalProperty(LDSoftwareSourceCode.dateCreated, dateCreated, unwrap(context));
+    ssc.SetOptionalProperty(LDSoftwareSourceCode.license, licenses, unwrap(context));
+    ssc.SetOptionalProperty(LDSoftwareSourceCode.name, name, unwrap(context));
+    ssc.SetOptionalProperty(LDSoftwareSourceCode.programmingLanguage, programmingLanguages, unwrap(context));
+    ssc.SetOptionalProperty(LDSoftwareSourceCode.sdPublisher, sdPublisher, unwrap(context));
+    ssc.SetOptionalProperty(LDSoftwareSourceCode.url, url, unwrap(context));
+    ssc.SetOptionalProperty(LDSoftwareSourceCode.version, version, unwrap(context));
+    ssc.SetOptionalProperty(LDSoftwareSourceCode.description, description, unwrap(context));
+    ssc.SetOptionalProperty(LDSoftwareSourceCode.hasPart, hasParts, unwrap(context));
+    ssc.SetOptionalProperty(LDSoftwareSourceCode.comment, comments, unwrap(context));
+    return ssc;
+  }
+}
+function LDSoftwareSourceCode_$reflection() {
+  return class_type("ARCtrl.ROCrate.LDSoftwareSourceCode", void 0, LDSoftwareSourceCode);
+}
+
+export { LDSoftwareSourceCode, LDSoftwareSourceCode_$reflection };

package/dist/ts/ts/ROCrate/LDTypes/WorkflowInvocation.d.ts

@@ -0,0 +1,12 @@
+import { LDNode } from '../LDObject.js';
+import { LDContext } from '../LDContext.js';
+import { TypeInfo } from '@fable-org/fable-library-js/Reflection.js';
+export declare class LDWorkflowInvocation {
+    constructor();
+    static get schemaType(): string[];
+    static genID(name: string, runName?: string): string;
+    static validate(wp: LDNode, context?: LDContext): boolean;
+    static create(name: string, instrument: LDNode, objects?: LDNode[], results?: LDNode[], description?: string, agents?: LDNode[], id?: string, endTime?: Date, disambiguatingDescriptions?: string[], executesLabProtocol?: LDNode, parameterValues?: LDNode[], context?: LDContext): LDNode;
+}
+export declare function LDWorkflowInvocation_$reflection(): TypeInfo;
+//# sourceMappingURL=WorkflowInvocation.d.ts.map

package/dist/ts/ts/ROCrate/LDTypes/WorkflowInvocation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WorkflowInvocation.d.ts","sourceRoot":"","sources":["../../../../../src/ARCtrl/ts/ROCrate/LDTypes/WorkflowInvocation.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AACxC,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAC5C,OAAO,EAAc,QAAQ,EAAE,MAAM,2CAA2C,CAAC;AAEjF,qBAAa,oBAAoB;;IAG7B,MAAM,KAAK,UAAU,IAAI,MAAM,EAAE,CAEhC;IACD,MAAM,CAAC,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM;IAGpD,MAAM,CAAC,QAAQ,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,SAAS,GAAG,OAAO;IAGzD,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,EAAE,EAAE,OAAO,CAAC,EAAE,MAAM,EAAE,EAAE,WAAW,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,IAAI,EAAE,0BAA0B,CAAC,EAAE,MAAM,EAAE,EAAE,mBAAmB,CAAC,EAAE,MAAM,EAAE,eAAe,CAAC,EAAE,MAAM,EAAE,EAAE,OAAO,CAAC,EAAE,SAAS,GAAG,MAAM;CAe9R;AAED,wBAAgB,gCAAgC,IAAI,QAAQ,CAE3D"}

package/dist/ts/ts/ROCrate/LDTypes/WorkflowInvocation.js

@@ -0,0 +1,40 @@
+import { LDCreateAction } from './CreateAction.js';
+import { LDLabProcess } from './LabProcess.js';
+import { clean } from '../Helper.js';
+import { value, unwrap } from '../../../node_modules/@fable-org/fable-library-js/Option.js';
+import { LDNode } from '../LDObject.js';
+import { class_type } from '../../../node_modules/@fable-org/fable-library-js/Reflection.js';
+
+class LDWorkflowInvocation {
+  constructor() {
+  }
+  static get schemaType() {
+    return [LDCreateAction.schemaType, LDLabProcess.schemaType];
+  }
+  static genID(name, runName) {
+    return runName == null ? clean(`#WorkflowInvocation_${name}`) : clean(`#WorkflowInvocation_R_${value(runName)}_${name}`);
+  }
+  static validate(wp, context) {
+    return LDCreateAction.validate(wp, unwrap(context)) && LDLabProcess.validate(wp, unwrap(context));
+  }
+  static create(name, instrument, objects, results, description, agents, id, endTime, disambiguatingDescriptions, executesLabProtocol, parameterValues, context) {
+    const at = ["WorkflowInvocation"];
+    const ca = new LDNode(id == null ? LDWorkflowInvocation.genID(name) : value(id), LDWorkflowInvocation.schemaType, at, unwrap(context));
+    ca.SetProperty(LDCreateAction.name, name, unwrap(context));
+    ca.SetOptionalProperty(LDCreateAction.object_, objects, unwrap(context));
+    ca.SetOptionalProperty(LDCreateAction.result, results, unwrap(context));
+    ca.SetProperty(LDCreateAction.instrument, instrument, unwrap(context));
+    ca.SetOptionalProperty(LDCreateAction.agent, agents, unwrap(context));
+    ca.SetOptionalProperty(LDCreateAction.description, description, unwrap(context));
+    ca.SetOptionalProperty(LDCreateAction.endTime, endTime, unwrap(context));
+    ca.SetOptionalProperty(LDCreateAction.disambiguatingDescription, disambiguatingDescriptions, unwrap(context));
+    ca.SetOptionalProperty(LDLabProcess.executesLabProtocol, executesLabProtocol, unwrap(context));
+    ca.SetOptionalProperty(LDLabProcess.parameterValue, parameterValues, unwrap(context));
+    return ca;
+  }
+}
+function LDWorkflowInvocation_$reflection() {
+  return class_type("ARCtrl.ROCrate.LDWorkflowInvocation", void 0, LDWorkflowInvocation);
+}
+
+export { LDWorkflowInvocation, LDWorkflowInvocation_$reflection };

package/dist/ts/ts/ROCrate/LDTypes/WorkflowProtocol.d.ts

@@ -0,0 +1,11 @@
+import { LDNode } from '../LDObject.js';
+import { LDContext } from '../LDContext.js';
+import { TypeInfo } from '@fable-org/fable-library-js/Reflection.js';
+export declare class LDWorkflowProtocol {
+    constructor();
+    static get schemaType(): string[];
+    static validate(wp: LDNode, context?: LDContext): boolean;
+    static create(id?: string, inputs?: LDNode[], outputs?: LDNode[], creator?: LDNode, dateCreated?: string, licenses?: LDNode[], name?: string, programmingLanguages?: LDNode[], sdPublisher?: LDNode, url?: string, version?: string, description?: string, hasParts?: LDNode[], intendedUse?: LDNode, comments?: LDNode[], computationalTools?: LDNode[], additionalType?: string[], context?: LDContext): LDNode;
+}
+export declare function LDWorkflowProtocol_$reflection(): TypeInfo;
+//# sourceMappingURL=WorkflowProtocol.d.ts.map

package/dist/ts/ts/ROCrate/LDTypes/WorkflowProtocol.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WorkflowProtocol.d.ts","sourceRoot":"","sources":["../../../../../src/ARCtrl/ts/ROCrate/LDTypes/WorkflowProtocol.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AACxC,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAG5C,OAAO,EAAc,QAAQ,EAAE,MAAM,2CAA2C,CAAC;AAEjF,qBAAa,kBAAkB;;IAG3B,MAAM,KAAK,UAAU,IAAI,MAAM,EAAE,CAEhC;IACD,MAAM,CAAC,QAAQ,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,SAAS,GAAG,OAAO;IAGzD,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,EAAE,EAAE,OAAO,CAAC,EAAE,MAAM,EAAE,EAAE,OAAO,CAAC,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,EAAE,EAAE,IAAI,CAAC,EAAE,MAAM,EAAE,oBAAoB,CAAC,EAAE,MAAM,EAAE,EAAE,WAAW,CAAC,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,EAAE,EAAE,WAAW,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,EAAE,EAAE,kBAAkB,CAAC,EAAE,MAAM,EAAE,EAAE,cAAc,CAAC,EAAE,MAAM,EAAE,EAAE,OAAO,CAAC,EAAE,SAAS,GAAG,MAAM;CAqBpZ;AAED,wBAAgB,8BAA8B,IAAI,QAAQ,CAEzD"}

package/dist/ts/ts/ROCrate/LDTypes/WorkflowProtocol.js

@@ -0,0 +1,46 @@
+import { LDFile } from './File.js';
+import { LDComputationalWorkflow } from './ComputationalWorkflow.js';
+import { LDSoftwareSourceCode } from './SoftwareSourceCode.js';
+import { LDLabProtocol } from './LabProtocol.js';
+import { unwrap, value } from '../../../node_modules/@fable-org/fable-library-js/Option.js';
+import { LDNode } from '../LDObject.js';
+import { clean } from '../Helper.js';
+import { createMissingIdentifier } from '../../Core/Helper/Identifier.js';
+import { class_type } from '../../../node_modules/@fable-org/fable-library-js/Reflection.js';
+
+class LDWorkflowProtocol {
+  constructor() {
+  }
+  static get schemaType() {
+    return [LDFile.schemaType, LDComputationalWorkflow.schemaType, LDSoftwareSourceCode.schemaType, LDLabProtocol.schemaType];
+  }
+  static validate(wp, context) {
+    return LDComputationalWorkflow.validate(wp, unwrap(context)) && LDSoftwareSourceCode.validate(wp, unwrap(context)) && LDLabProtocol.validate(wp, unwrap(context));
+  }
+  static create(id, inputs, outputs, creator, dateCreated, licenses, name, programmingLanguages, sdPublisher, url, version, description, hasParts, intendedUse, comments, computationalTools, additionalType, context) {
+    const at = ["WorkflowProtocol"];
+    const wp = new LDNode(id == null ? clean(`#ComputationalWorkflow_${createMissingIdentifier()}`) : value(id), LDWorkflowProtocol.schemaType, at, unwrap(context));
+    wp.SetOptionalProperty(LDComputationalWorkflow.input, inputs, unwrap(context));
+    wp.SetOptionalProperty(LDComputationalWorkflow.output, outputs, unwrap(context));
+    wp.SetOptionalProperty(LDComputationalWorkflow.creator, creator, unwrap(context));
+    wp.SetOptionalProperty(LDComputationalWorkflow.dateCreated, dateCreated, unwrap(context));
+    wp.SetOptionalProperty(LDComputationalWorkflow.license, licenses, unwrap(context));
+    wp.SetOptionalProperty(LDComputationalWorkflow.name, name, unwrap(context));
+    wp.SetOptionalProperty(LDComputationalWorkflow.programmingLanguage, programmingLanguages, unwrap(context));
+    wp.SetOptionalProperty(LDComputationalWorkflow.sdPublisher, sdPublisher, unwrap(context));
+    wp.SetOptionalProperty(LDComputationalWorkflow.url, url, unwrap(context));
+    wp.SetOptionalProperty(LDComputationalWorkflow.version, version, unwrap(context));
+    wp.SetOptionalProperty(LDComputationalWorkflow.description, description, unwrap(context));
+    wp.SetOptionalProperty(LDComputationalWorkflow.hasPart, hasParts, unwrap(context));
+    wp.SetOptionalProperty(LDLabProtocol.intendedUse, intendedUse, unwrap(context));
+    wp.SetOptionalProperty(LDLabProtocol.computationalTool, computationalTools, unwrap(context));
+    wp.SetOptionalProperty(LDComputationalWorkflow.additionalType, additionalType, unwrap(context));
+    wp.SetOptionalProperty(LDComputationalWorkflow.comment, comments, unwrap(context));
+    return wp;
+  }
+}
+function LDWorkflowProtocol_$reflection() {
+  return class_type("ARCtrl.ROCrate.LDWorkflowProtocol", void 0, LDWorkflowProtocol);
+}
+
+export { LDWorkflowProtocol, LDWorkflowProtocol_$reflection };