@nfdi4plants/arctrl 2.3.1 → 2.5.0

package/ROCrate/LDContext.js

@@ -0,0 +1,283 @@
+import { Dictionary } from "../fable_modules/fable-library-js.4.24.0/MutableMap.js";
+import { stringHash, comparePrimitives, safeHash, disposeSafe, getEnumerator, defaultOf, structuralHash, equals } from "../fable_modules/fable-library-js.4.24.0/Util.js";
+import { tryPick, sort, map, reduce, iterate } from "../fable_modules/fable-library-js.4.24.0/Seq.js";
+import { getItemFromDict, tryGetValue, addToDict } from "../fable_modules/fable-library-js.4.24.0/MapUtil.js";
+import { toString, FSharpRef } from "../fable_modules/fable-library-js.4.24.0/Types.js";
+import { defaultArg, unwrap, some } from "../fable_modules/fable-library-js.4.24.0/Option.js";
+import { ActivePatterns_$007CRegex$007C_$007C } from "../Core/Helper/Regex.js";
+import { Uri } from "../fable_modules/fable-library-js.4.24.0/Uri.js";
+import { Dictionary_addOrUpdate } from "../Core/Helper/Collections.js";
+import { hash as hash_2, mergeHashes, boxHashSeq } from "../Core/Helper/HashCodes.js";
+import { class_type } from "../fable_modules/fable-library-js.4.24.0/Reflection.js";
+
+export function Dictionary_ofSeq(s) {
+    const dict = new Dictionary([], {
+        Equals: equals,
+        GetHashCode: structuralHash,
+    });
+    iterate((tupledArg) => {
+        addToDict(dict, tupledArg[0], tupledArg[1]);
+    }, s);
+    return dict;
+}
+
+export 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 undefined;
+    }
+}
+
+export const IRIHelper_compactIRIRegex = "(?<prefix>.*):(?<suffix>[^\\/][^\\/].*)";
+
+export function IRIHelper_$007CCompactIri$007C_$007C(termDefition) {
+    const activePatternResult = ActivePatterns_$007CRegex$007C_$007C(IRIHelper_compactIRIRegex, termDefition);
+    if (activePatternResult != null) {
+        const result = activePatternResult;
+        return [(result.groups && result.groups.prefix) || "", (result.groups && result.groups.suffix) || ""];
+    }
+    else {
+        return undefined;
+    }
+}
+
+export function IRIHelper_combine(baseIRI, relative) {
+    if (relative.startsWith("http://") ? true : relative.startsWith("https://")) {
+        return relative;
+    }
+    else {
+        return toString(Uri.create(Uri.create(baseIRI), relative));
+    }
+}
+
+export function IRIHelper_combineOptional(baseIRI, relative) {
+    if (baseIRI == null) {
+        if (relative != null) {
+            const r_1 = relative;
+            return r_1;
+        }
+        else {
+            return undefined;
+        }
+    }
+    else if (relative == null) {
+        const b_1 = baseIRI;
+        return b_1;
+    }
+    else {
+        const b = baseIRI;
+        const r = relative;
+        return IRIHelper_combine(b, r);
+    }
+}
+
+export class LDContext {
+    constructor(mappings, baseContexts) {
+        this["baseContexts@54"] = defaultArg(baseContexts, []);
+        this.name = undefined;
+        this["mappings@58"] = ((mappings == null) ? (new Map([])) : mappings);
+        this.reverseMappings = (new Map([]));
+        this.compactReverseMappings = (new Map([]));
+        let enumerator = getEnumerator(this["mappings@58"]);
+        try {
+            while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+                const kvp = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+                this.addReverseMapping(kvp[0], kvp[1]);
+            }
+        }
+        finally {
+            disposeSafe(enumerator);
+        }
+    }
+    get Mappings() {
+        const this$ = this;
+        return this$["mappings@58"];
+    }
+    get BaseContexts() {
+        const this$ = this;
+        return this$["baseContexts@54"];
+    }
+    set BaseContexts(value) {
+        const this$ = this;
+        this$["baseContexts@54"] = value;
+    }
+    get Name() {
+        const this$ = this;
+        return unwrap(this$.name);
+    }
+    set Name(value) {
+        const this$ = this;
+        this$.name = value;
+    }
+    AddMapping(term, definition) {
+        const this$ = this;
+        Dictionary_addOrUpdate(term, definition, this$["mappings@58"]);
+        this$.addReverseMapping(term, definition);
+    }
+    TryResolveTerm(term) {
+        const this$ = this;
+        return (term.indexOf(":") >= 0) ? reduce(IRIHelper_combineOptional, map((term_1) => this$.tryFindTerm(term_1), term.split(":"))) : this$.tryFindTerm(term);
+    }
+    TryGetTerm(iri) {
+        const this$ = this;
+        return this$.tryFindIri(iri);
+    }
+    PropertyNamesMatch(p1, p2) {
+        let p2Def_2, p1Def_2, p1Def_1, p2Def_1;
+        const this$ = this;
+        if (p1 === p2) {
+            return true;
+        }
+        else {
+            const p1Def = this$.TryResolveTerm(p1);
+            const p2Def = this$.TryResolveTerm(p2);
+            return (p1Def == null) ? ((p2Def != null) && ((p2Def_2 = p2Def, p1 === p2Def_2))) : ((p2Def == null) ? ((p1Def_2 = p1Def, p1Def_2 === p2)) : ((p1Def_1 = p1Def, (p2Def_1 = p2Def, p1Def_1 === p2Def_1))));
+        }
+    }
+    static fromMappingSeq(mappings) {
+        return new LDContext(Dictionary_ofSeq(mappings));
+    }
+    static combine_InPlace(baseContext, specificContext) {
+        void (specificContext.BaseContexts.push(baseContext));
+        return specificContext;
+    }
+    static combine(baseContext, specificContext) {
+        return new LDContext(undefined, [specificContext, baseContext]);
+    }
+    static tryCombineOptional(baseContext, specificContext) {
+        let s_1, f_1, f, s;
+        return (baseContext == null) ? ((specificContext != null) ? ((s_1 = specificContext, s_1)) : undefined) : ((specificContext == null) ? ((f_1 = baseContext, f_1)) : ((f = baseContext, (s = specificContext, LDContext.combine(f, s)))));
+    }
+    ShallowCopy() {
+        const this$ = this;
+        const newMappings = new Map([]);
+        let enumerator = getEnumerator(this$["mappings@58"]);
+        try {
+            while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+                const kvp = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+                addToDict(newMappings, kvp[0], kvp[1]);
+            }
+        }
+        finally {
+            disposeSafe(enumerator);
+        }
+        return new LDContext(newMappings, this$["baseContexts@54"]);
+    }
+    DeepCopy() {
+        const this$ = this;
+        const newMappings = new Map([]);
+        let enumerator = getEnumerator(this$["mappings@58"]);
+        try {
+            while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+                const kvp = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+                addToDict(newMappings, kvp[0], kvp[1]);
+            }
+        }
+        finally {
+            disposeSafe(enumerator);
+        }
+        const newBaseContexts = [];
+        let enumerator_1 = getEnumerator(this$["baseContexts@54"]);
+        try {
+            while (enumerator_1["System.Collections.IEnumerator.MoveNext"]()) {
+                const ctx = enumerator_1["System.Collections.Generic.IEnumerator`1.get_Current"]();
+                void (newBaseContexts.push(ctx.DeepCopy()));
+            }
+        }
+        finally {
+            disposeSafe(enumerator_1);
+        }
+        return new LDContext(newMappings, newBaseContexts);
+    }
+    StructurallyEquals(other) {
+        const this$ = this;
+        return safeHash(this$) === safeHash(other);
+    }
+    ReferenceEquals(other) {
+        const this$ = this;
+        return this$ === other;
+    }
+    Equals(other) {
+        let other_1;
+        const this$ = this;
+        return (other instanceof LDContext) && ((other_1 = other, this$.StructurallyEquals(other_1)));
+    }
+    GetHashCode() {
+        const this$ = this;
+        const mappingsHash = boxHashSeq(map((k) => mergeHashes(hash_2(k), hash_2(getItemFromDict(this$.Mappings, k))), sort(this$.Mappings.keys(), {
+            Compare: comparePrimitives,
+        }))) | 0;
+        let nameHash;
+        const matchValue = this$.Name;
+        nameHash = ((matchValue == null) ? 0 : stringHash(matchValue));
+        const baseContextsHash = ((this$["baseContexts@54"].length === 0) ? 0 : reduce(mergeHashes, map(safeHash, this$["baseContexts@54"]))) | 0;
+        return mergeHashes(mergeHashes(mappingsHash, nameHash), baseContextsHash) | 0;
+    }
+    "System.ICloneable.Clone"() {
+        const this$ = this;
+        return this$.DeepCopy();
+    }
+    addReverseMapping(key, value) {
+        const this$ = this;
+        Dictionary_addOrUpdate(value, key, this$.reverseMappings);
+        const activePatternResult = IRIHelper_$007CCompactIri$007C_$007C(value);
+        if (activePatternResult != null) {
+            const prefix = activePatternResult[0];
+            const suffix = activePatternResult[1];
+            Dictionary_addOrUpdate(prefix, [suffix, key], this$.compactReverseMappings);
+            const matchValue = Dictionary_tryFind(prefix, this$["mappings@58"]);
+            if (matchValue == null) {
+            }
+            else {
+                Dictionary_addOrUpdate(IRIHelper_combine(matchValue, suffix), key, this$.reverseMappings);
+            }
+        }
+        else {
+            const matchValue_1 = Dictionary_tryFind(key, this$.compactReverseMappings);
+            if (matchValue_1 == null) {
+            }
+            else {
+                const term = matchValue_1[1];
+                Dictionary_addOrUpdate(IRIHelper_combine(value, matchValue_1[0]), term, this$.reverseMappings);
+            }
+        }
+    }
+    tryFindTerm(term) {
+        let prefix, suffix, d;
+        const this$ = this;
+        let definition;
+        const matchValue = Dictionary_tryFind(term, this$["mappings@58"]);
+        definition = ((matchValue == null) ? tryPick((ctx) => ctx.TryResolveTerm(term), this$["baseContexts@54"]) : matchValue);
+        if (definition == null) {
+            return undefined;
+        }
+        else {
+            const activePatternResult = IRIHelper_$007CCompactIri$007C_$007C(definition);
+            return (activePatternResult != null) ? ((prefix = activePatternResult[0], (suffix = activePatternResult[1], IRIHelper_combine((prefix === term) ? prefix : defaultArg(this$.tryFindTerm(prefix), prefix), (suffix === term) ? suffix : defaultArg(this$.tryFindTerm(suffix), suffix))))) : ((d = definition, d));
+        }
+    }
+    tryFindIri(iri) {
+        const this$ = this;
+        const matchValue = Dictionary_tryFind(iri, this$.reverseMappings);
+        return (matchValue == null) ? tryPick((ctx) => ctx.TryGetTerm(iri), this$["baseContexts@54"]) : matchValue;
+    }
+    tryCompactIRI(iri) {
+        throw new Error("TryCompactIRI is Not implemented yet");
+    }
+}
+
+export function LDContext_$reflection() {
+    return class_type("ARCtrl.ROCrate.LDContext", undefined, LDContext);
+}
+
+export function LDContext_$ctor_7878CD77(mappings, baseContexts) {
+    return new LDContext(mappings, baseContexts);
+}
+