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

package/dist/ts/ts/Json/ROCrate/LDNode.js

@@ -0,0 +1,190 @@
+import { ErrorReason$1_BadOneOf, ErrorReason$1_BadPrimitive } from '../../fable_modules/Thoth.Json.Core.0.7.0/Types.fs.js';
+import { resizeArrayOrSingleton, dateTime } from '../Encode.js';
+import { LDNode, LDValue, LDRef } from '../../ROCrate/LDObject.js';
+import { decoder as decoder$1, encoder as encoder$2 } from './LDValue.js';
+import { decoder as decoder$2, encoder as encoder$3 } from './LDRef.js';
+import { getEnumerator, disposeSafe, int32ToString, equals, defaultOf, isIterable } from '../../../node_modules/@fable-org/fable-library-js/Util.js';
+import { list } from '../../fable_modules/Thoth.Json.Core.0.7.0/Encode.fs.js';
+import { toList, delay, map as map$1, append, singleton, empty, collect, enumerateFromFunctions } from '../../../node_modules/@fable-org/fable-library-js/Seq.js';
+import { decoder as decoder$3, encoder as encoder$1 } from './LDContext.js';
+import { unwrap, value } from '../../../node_modules/@fable-org/fable-library-js/Option.js';
+import { map, oneOf, string, int, decimal, Getters$2_$ctor_Z4BE6C149, Getters$2__get_Errors } from '../../fable_modules/Thoth.Json.Core.0.7.0/Decode.fs.js';
+import { Decode_resizeArrayOrSingleton, Helpers_prependPath } from '../Decode.js';
+import { ofArray, isEmpty, length, head } from '../../../node_modules/@fable-org/fable-library-js/List.js';
+import { FSharpResult$2_Error, FSharpResult$2_Ok } from '../../../node_modules/@fable-org/fable-library-js/Result.js';
+import { fold } from '../../../node_modules/@fable-org/fable-library-js/Array.js';
+
+function genericEncoder(obj) {
+  if (typeof obj === "string") {
+    const s = obj;
+    return {
+      Encode(helpers) {
+        return helpers.encodeString(s);
+      }
+    };
+  } else if (typeof obj === "number") {
+    const i = obj | 0;
+    return {
+      Encode(helpers_1) {
+        return helpers_1.encodeSignedIntegralNumber(i);
+      }
+    };
+  } else if (typeof obj === "boolean") {
+    const b = obj;
+    return {
+      Encode(helpers_2) {
+        return helpers_2.encodeBool(b);
+      }
+    };
+  } else if (typeof obj === "number") {
+    const f = obj;
+    return {
+      Encode(helpers_3) {
+        return helpers_3.encodeDecimalNumber(f);
+      }
+    };
+  } else if (obj instanceof Date) {
+    const d = obj;
+    return dateTime(d);
+  } else if (obj instanceof LDValue) {
+    const v = obj;
+    return encoder$2(v);
+  } else if (obj instanceof LDRef) {
+    const r = obj;
+    return encoder$3(r);
+  } else if (obj instanceof LDNode) {
+    const o = obj;
+    return encoder(o);
+  } else if (equals(obj, defaultOf())) {
+    return {
+      Encode(helpers_4) {
+        return helpers_4.encodeNull();
+      }
+    };
+  } else if (isIterable(obj)) {
+    const l = obj;
+    return list(toList(delay(() => map$1(genericEncoder, enumerateFromFunctions(() => getEnumerator(l), (enumerator) => enumerator["System.Collections.IEnumerator.MoveNext"](), (enumerator_1) => enumerator_1["System.Collections.IEnumerator.get_Current"]())))));
+  } else {
+    throw new Error("Unknown type");
+  }
+}
+function encoder(obj) {
+  const values_1 = toList(delay(() => {
+    let value$1;
+    return append(singleton(["@id", (value$1 = obj.Id, {
+      Encode(helpers) {
+        return helpers.encodeString(value$1);
+      }
+    })]), delay(() => append(singleton(["@type", resizeArrayOrSingleton((value_1) => ({
+      Encode(helpers_1) {
+        return helpers_1.encodeString(value_1);
+      }
+    }), obj.SchemaType)]), delay(() => append(obj.AdditionalType.length !== 0 ? singleton(["additionalType", resizeArrayOrSingleton((value_3) => ({
+      Encode(helpers_2) {
+        return helpers_2.encodeString(value_3);
+      }
+    }), obj.AdditionalType)]) : empty(), delay(() => {
+      let matchValue;
+      return append((matchValue = obj.TryGetContext(), matchValue != null ? singleton(["@context", encoder$1(value(matchValue))]) : empty()), delay(() => collect((kv) => {
+        const l = kv[0].toLocaleLowerCase();
+        return l !== "id" && l !== "schematype" && l !== "additionaltype" && l !== "@context" && !l.startsWith("init@") && !l.startsWith("init_") ? singleton([kv[0], genericEncoder(kv[1])]) : empty();
+      }, obj.GetProperties(true))));
+    }))))));
+  }));
+  return {
+    Encode(helpers_3) {
+      const arg = map$1((tupledArg) => [tupledArg[0], tupledArg[1].Encode(helpers_3)], values_1);
+      return helpers_3.encodeObject(arg);
+    }
+  };
+}
+function getDecoder(expectObject) {
+  const decode = (expectObject_1) => {
+    const decodeObject = {
+      Decode(helpers, value$1) {
+        let arg_7, objectArg_3, arg_9, objectArg_4;
+        if (helpers.isObject(value$1)) {
+          const getters = Getters$2_$ctor_Z4BE6C149(helpers, value$1);
+          const properties = helpers.getProperties(value$1);
+          let result;
+          const get$ = getters;
+          let t;
+          const arg_1 = Decode_resizeArrayOrSingleton(string);
+          const objectArg = get$.Required;
+          t = objectArg.Field("@type", arg_1);
+          let id;
+          const objectArg_1 = get$.Required;
+          id = objectArg_1.Field("@id", string);
+          let context;
+          const objectArg_2 = get$.Optional;
+          context = objectArg_2.Field("@context", decoder$3);
+          const o = new LDNode(id, t, unwrap((arg_7 = Decode_resizeArrayOrSingleton(string), objectArg_3 = get$.Optional, objectArg_3.Field("additionalType", arg_7))));
+          const enumerator = getEnumerator(properties);
+          try {
+            while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+              const property = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+              if (property !== "@id" && property !== "@type" && property !== "@context") {
+                o.SetProperty(property, (arg_9 = decode(false), objectArg_4 = get$.Required, objectArg_4.Field(property, arg_9)));
+              }
+            }
+          } finally {
+            disposeSafe(enumerator);
+          }
+          if (context != null) {
+            o.SetContext(value(context));
+          }
+          result = o;
+          const matchValue = Getters$2__get_Errors(getters);
+          if (!isEmpty(matchValue)) {
+            const errors = matchValue;
+            return length(errors) > 1 ? FSharpResult$2_Error(["", ErrorReason$1_BadOneOf(errors)]) : FSharpResult$2_Error(head(matchValue));
+          } else {
+            return FSharpResult$2_Ok(result);
+          }
+        } else {
+          return FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("an object", value$1)]);
+        }
+      }
+    };
+    const resizeArray = {
+      Decode(helpers_1, value_1) {
+        if (helpers_1.isArray(value_1)) {
+          let i = -1;
+          return fold((acc, value_2) => {
+            let tupledArg;
+            i = i + 1 | 0;
+            if (acc.tag === /* Ok */
+            0) {
+              const acc_1 = acc.fields[0];
+              let matchValue_1;
+              let copyOfStruct = decode(false);
+              matchValue_1 = copyOfStruct.Decode(helpers_1, value_2);
+              if (matchValue_1.tag === /* Ok */
+              0) {
+                const value_3 = matchValue_1.fields[0];
+                void acc_1.push(value_3);
+                return FSharpResult$2_Ok(acc_1);
+              } else {
+                return FSharpResult$2_Error((tupledArg = matchValue_1.fields[0], Helpers_prependPath(".[" + int32ToString(i) + "]", tupledArg[0], tupledArg[1])));
+              }
+            } else {
+              return acc;
+            }
+          }, FSharpResult$2_Ok([]), helpers_1.asArray(value_1));
+        } else {
+          return FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("an array", value_1)]);
+        }
+      }
+    };
+    if (expectObject_1) {
+      return map((value_4) => value_4, decodeObject);
+    } else {
+      return oneOf(ofArray([map((value_5) => value_5, decoder$1), map((value_6) => value_6, decodeObject), map((value_7) => value_7, decoder$2), map((value_8) => value_8, resizeArray), map((value_9) => value_9, string), map((value_10) => value_10, int), map((value_11) => value_11, decimal)]));
+    }
+  };
+  return decode(expectObject);
+}
+const decoder = map((value) => value, getDecoder(true));
+const genericDecoder = getDecoder(false);
+
+export { decoder, encoder, genericDecoder, genericEncoder, getDecoder };

package/dist/ts/ts/Json/ROCrate/LDRef.d.ts

@@ -1,5 +1,5 @@
 import { LDRef } from '../../ROCrate/LDObject.js';
-import { IEncodable, Decoder$1 } from '../../fable_modules/Thoth.Json.Core.0.4.0/Types.fs.js';
+import { IEncodable, Decoder$1 } from '../../fable_modules/Thoth.Json.Core.0.7.0/Types.fs.js';
 export declare const decoder: Decoder$1<LDRef>;
 export declare function encoder(r: LDRef): IEncodable;
 //# sourceMappingURL=LDRef.d.ts.map

package/dist/ts/ts/Json/ROCrate/LDRef.js

@@ -0,0 +1,24 @@
+import { object, string } from '../../fable_modules/Thoth.Json.Core.0.7.0/Decode.fs.js';
+import { LDRef } from '../../ROCrate/LDObject.js';
+import { map } from '../../../node_modules/@fable-org/fable-library-js/Seq.js';
+
+const decoder = object((decoders) => {
+  let objectArg;
+  return new LDRef((objectArg = decoders.Required, objectArg.Field("@id", string)));
+});
+function encoder(r) {
+  let value;
+  const values_1 = [["@id", (value = r.Id, {
+    Encode(helpers) {
+      return helpers.encodeString(value);
+    }
+  })]];
+  return {
+    Encode(helpers_1) {
+      const arg = map((tupledArg) => [tupledArg[0], tupledArg[1].Encode(helpers_1)], values_1);
+      return helpers_1.encodeObject(arg);
+    }
+  };
+}
+
+export { decoder, encoder };

package/dist/ts/ts/Json/ROCrate/LDValue.d.ts

@@ -1,4 +1,4 @@
-import { IEncodable, Decoder$1 } from '../../fable_modules/Thoth.Json.Core.0.4.0/Types.fs.js';
+import { IEncodable, Decoder$1 } from '../../fable_modules/Thoth.Json.Core.0.7.0/Types.fs.js';
 import { LDValue } from '../../ROCrate/LDObject.js';
 export declare const genericDecoder: Decoder$1<any>;
 export declare function genericEncoder(value: any): IEncodable;

package/dist/ts/ts/Json/ROCrate/LDValue.js

@@ -0,0 +1,63 @@
+import { oneOf, map, string, int, decimal, object } from '../../fable_modules/Thoth.Json.Core.0.7.0/Decode.fs.js';
+import { ofArray } from '../../../node_modules/@fable-org/fable-library-js/List.js';
+import { dateTime } from '../Encode.js';
+import { LDValue } from '../../ROCrate/LDObject.js';
+import { unwrap } from '../../../node_modules/@fable-org/fable-library-js/Option.js';
+import { map as map$1 } from '../../../node_modules/@fable-org/fable-library-js/Seq.js';
+
+const genericDecoder = oneOf(ofArray([map((value) => value, string), map((value_1) => value_1, int), map((value_2) => value_2, decimal)]));
+function genericEncoder(value) {
+  if (typeof value === "string") {
+    const s = value;
+    return {
+      Encode(helpers) {
+        return helpers.encodeString(s);
+      }
+    };
+  } else if (typeof value === "number") {
+    const i = value | 0;
+    return {
+      Encode(helpers_1) {
+        return helpers_1.encodeSignedIntegralNumber(i);
+      }
+    };
+  } else if (typeof value === "boolean") {
+    const b = value;
+    return {
+      Encode(helpers_2) {
+        return helpers_2.encodeBool(b);
+      }
+    };
+  } else if (typeof value === "number") {
+    const f = value;
+    return {
+      Encode(helpers_3) {
+        return helpers_3.encodeDecimalNumber(f);
+      }
+    };
+  } else if (value instanceof Date) {
+    return dateTime(value);
+  } else {
+    throw new Error("Unknown type");
+  }
+}
+const decoder = object((decoders) => {
+  let objectArg, objectArg_1;
+  return new LDValue((objectArg = decoders.Required, objectArg.Field("@value", genericDecoder)), unwrap((objectArg_1 = decoders.Optional, objectArg_1.Field("@type", string))));
+});
+function encoder(v) {
+  let value;
+  const values_1 = [["@value", genericEncoder(v.Value)], ["@type", (value = v.ValueType, {
+    Encode(helpers) {
+      return helpers.encodeString(value);
+    }
+  })]];
+  return {
+    Encode(helpers_1) {
+      const arg = map$1((tupledArg) => [tupledArg[0], tupledArg[1].Encode(helpers_1)], values_1);
+      return helpers_1.encodeObject(arg);
+    }
+  };
+}
+
+export { decoder, encoder, genericDecoder, genericEncoder };

package/dist/ts/ts/Json/StringTable.d.ts

@@ -1,6 +1,6 @@
 import { int32 } from '@fable-org/fable-library-js/Int32.js';
 import { IMap } from '@fable-org/fable-library-js/Util.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';
 export declare function arrayFromMap(otm: IMap<string, int32>): string[];
 export declare function encoder(ot: string[]): IEncodable;
 export declare const decoder: Decoder$1<string[]>;

package/dist/ts/ts/Json/StringTable.js

@@ -0,0 +1,66 @@
+import { map, fill, item, setItem } from '../../node_modules/@fable-org/fable-library-js/Array.js';
+import { iterate } from '../../node_modules/@fable-org/fable-library-js/Seq.js';
+import { defaultOf } from '../../node_modules/@fable-org/fable-library-js/Util.js';
+import { array, string, int } from '../fable_modules/Thoth.Json.Core.0.7.0/Decode.fs.js';
+import { value } from '../../node_modules/@fable-org/fable-library-js/Option.js';
+import { tryGetValue, addToDict } from '../../node_modules/@fable-org/fable-library-js/MapUtil.js';
+import { FSharpRef } from '../../node_modules/@fable-org/fable-library-js/Types.js';
+import { FSharpResult$2_Error, FSharpResult$2_Ok } from '../../node_modules/@fable-org/fable-library-js/Result.js';
+
+function arrayFromMap(otm) {
+  const a = fill(new Array(otm.size), 0, otm.size, "");
+  iterate((kv) => {
+    setItem(a, kv[1], kv[0]);
+  }, otm);
+  return a;
+}
+function encoder(ot) {
+  const values = map((value) => ({
+    Encode(helpers) {
+      return helpers.encodeString(value);
+    }
+  }), ot);
+  return {
+    Encode(helpers_1) {
+      const arg = map((v) => v.Encode(helpers_1), values);
+      return helpers_1.encodeArray(arg);
+    }
+  };
+}
+const decoder = array(string);
+function encodeString(otm, s) {
+  let matchValue;
+  let patternInput;
+  let outArg = defaultOf();
+  patternInput = [tryGetValue(otm, s, new FSharpRef(() => outArg, (v) => {
+    outArg = v | 0;
+  })), outArg];
+  matchValue = patternInput[0] ? patternInput[1] : void 0;
+  if (matchValue == null) {
+    const i_1 = otm.size | 0;
+    addToDict(otm, s, i_1);
+    return {
+      Encode(helpers_1) {
+        return helpers_1.encodeSignedIntegralNumber(i_1);
+      }
+    };
+  } else {
+    const i = value(matchValue) | 0;
+    return {
+      Encode(helpers) {
+        return helpers.encodeSignedIntegralNumber(i);
+      }
+    };
+  }
+}
+function decodeString(ot) {
+  return {
+    Decode(s, json) {
+      const matchValue = int.Decode(s, json);
+      return matchValue.tag === /* Error */
+      1 ? FSharpResult$2_Error(matchValue.fields[0]) : FSharpResult$2_Ok(item(matchValue.fields[0], ot));
+    }
+  };
+}
+
+export { arrayFromMap, decodeString, decoder, encodeString, encoder };

package/dist/ts/ts/Json/Study.d.ts

@@ -1,7 +1,7 @@
 import { Option } from '@fable-org/fable-library-js/Option.js';
 import { FSharpList } from '@fable-org/fable-library-js/List.js';
 import { ArcStudy, ArcAssay } from '../Core/ArcTypes.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 { IMap } from '@fable-org/fable-library-js/Util.js';
 import { int32 } from '@fable-org/fable-library-js/Int32.js';