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

package/README.md

@@ -3,6 +3,8 @@
 
 # ARCtrl
 
+[![DOI](https://img.shields.io/badge/Cite%20Us-10.5281%2Fzenodo.15194394-008273?logo=zenodo&logoColor=C70039)](https://doi.org/10.5281/zenodo.15194394)
+
 > **ARCtrl** the easy way to read, manipulate and write ARCs in __.NET__, __JavaScript__ and __Python__! ❤️
 
 | Version | Downloads |

package/dist/ts/index.js

@@ -0,0 +1,63 @@
+export { ARC } from './ts/ARC.js';
+export { ArcAssay, ArcInvestigation, ArcRun, ArcStudy, ArcWorkflow } from './ts/Core/ArcTypes.js';
+export { CompositeCell } from './ts/Core/Table/CompositeCell.js';
+export { CompositeHeader, IOType } from './ts/Core/Table/CompositeHeader.js';
+export { CompositeColumn } from './ts/Core/Table/CompositeColumn.js';
+export { ArcTable } from './ts/Core/Table/ArcTable.js';
+export { Organisation, Template } from './ts/Core/Template.js';
+export { Templates } from './ts/Core/Templates.js';
+export { JsonController } from './ts/Json.js';
+export { XlsxController } from './ts/Xlsx.js';
+export { Person } from './ts/Core/Person.js';
+export { Publication } from './ts/Core/Publication.js';
+export { OntologyAnnotation } from './ts/Core/OntologyAnnotation.js';
+export { Comment$ as Comment } from './ts/Core/Comment.js';
+export { Contract } from './ts/Contract/Contract.js';
+export { WebController } from './ts/Template.Web.js';
+export { FileSystem } from './ts/FileSystem/FileSystem.js';
+export { FileSystemTree } from './ts/FileSystem/FileSystemTree.js';
+import { LDRef, LDValue, LDGraph, LDNode } from './ts/ROCrate/LDObject.js';
+import { LDContext } from './ts/ROCrate/LDContext.js';
+import { initBioschemasContext, initV1_2DRAFT, initV1_1 } from './ts/ROCrate/ROCrateContext.js';
+import { LDComment } from './ts/ROCrate/Generic/Comment.js';
+import { LDDefinedTerm } from './ts/ROCrate/Generic/DefinedTerm.js';
+import { LDFile } from './ts/ROCrate/Generic/File.js';
+import { LDLabProcess } from './ts/ROCrate/Generic/LabProcess.js';
+import { LDLabProtocol } from './ts/ROCrate/Generic/LabProtocol.js';
+import { LDOrganization } from './ts/ROCrate/Generic/Organization.js';
+import { LDPerson } from './ts/ROCrate/Generic/Person.js';
+import { LDPostalAddress } from './ts/ROCrate/Generic/PostalAddress.js';
+import { LDPropertyValue } from './ts/ROCrate/Generic/PropertyValue.js';
+import { LDSample } from './ts/ROCrate/Generic/Sample.js';
+import { LDScholarlyArticle } from './ts/ROCrate/Generic/ScholarlyArticle.js';
+import { LDDataset } from './ts/ROCrate/Generic/Dataset.js';
+import { LDNodeExtensions_PyJsInterop, LDGraphExtensions_PyJsInterop } from './ts/JsonIO/LDObject.js';
+import { TypeExtensions_Conversion } from './ts/Conversion.js';
+
+const ROCrate = {
+  LDNode,
+  LDGraph,
+  LDValue,
+  LDRef,
+  LDContext,
+  initV1_1,
+  initV1_2DRAFT,
+  initBioschemasContext,
+  LDComment,
+  LDDefinedTerm,
+  LDFile,
+  LDLabProcess,
+  LDLabProtocol,
+  LDOrganization,
+  LDPerson,
+  LDPostalAddress,
+  LDPropertyValue,
+  LDSample,
+  LDScholarlyArticle,
+  LDDataset,
+  LDGraphIO: LDGraphExtensions_PyJsInterop,
+  LDNodeIO: LDNodeExtensions_PyJsInterop,
+  Conversion: TypeExtensions_Conversion
+};
+
+export { ROCrate };

package/dist/ts/node_modules/@fable-org/fable-library-js/Array.js

@@ -0,0 +1,354 @@
+import { Helpers_allocateArrayFromCons } from './Native.js';
+import { value, some, defaultArg, map as map$1 } from './Option.js';
+import { equals, defaultOf, getEnumerator, disposeSafe } from './Util.js';
+
+function differentLengths() {
+    throw new Error("Arrays had different lengths");
+}
+function append(array1, array2, cons) {
+    const len1 = array1.length | 0;
+    const len2 = array2.length | 0;
+    const newArray = Helpers_allocateArrayFromCons(cons, len1 + len2);
+    for (let i = 0; i <= (len1 - 1); i++) {
+        setItem(newArray, i, item(i, array1));
+    }
+    for (let i_1 = 0; i_1 <= (len2 - 1); i_1++) {
+        setItem(newArray, i_1 + len1, item(i_1, array2));
+    }
+    return newArray;
+}
+function fill(target, targetIndex, count, value) {
+    const start = targetIndex | 0;
+    return target.fill(value, start, (start + count));
+}
+function mapIndexed(f, source, cons) {
+    const len = source.length | 0;
+    const target = Helpers_allocateArrayFromCons(cons, len);
+    for (let i = 0; i <= (len - 1); i++) {
+        setItem(target, i, f(i, item(i, source)));
+    }
+    return target;
+}
+function map(f, source, cons) {
+    const len = source.length | 0;
+    const target = Helpers_allocateArrayFromCons(cons, len);
+    for (let i = 0; i <= (len - 1); i++) {
+        setItem(target, i, f(item(i, source)));
+    }
+    return target;
+}
+function map3(f, source1, source2, source3, cons) {
+    if ((source1.length !== source2.length) ? true : (source2.length !== source3.length)) {
+        throw new Error("Arrays had different lengths");
+    }
+    const result = Helpers_allocateArrayFromCons(cons, source1.length);
+    for (let i = 0; i <= (source1.length - 1); i++) {
+        setItem(result, i, f(item(i, source1), item(i, source2), item(i, source3)));
+    }
+    return result;
+}
+function concat(arrays, cons) {
+    const arrays_1 = Array.isArray(arrays) ? arrays : (Array.from(arrays));
+    const matchValue = arrays_1.length | 0;
+    switch (matchValue) {
+        case 0:
+            return Helpers_allocateArrayFromCons(cons, 0);
+        case 1:
+            return item(0, arrays_1);
+        default: {
+            let totalIdx = 0;
+            let totalLength = 0;
+            for (let idx = 0; idx <= (arrays_1.length - 1); idx++) {
+                const arr_1 = item(idx, arrays_1);
+                totalLength = ((totalLength + arr_1.length) | 0);
+            }
+            const result = Helpers_allocateArrayFromCons(cons, totalLength);
+            for (let idx_1 = 0; idx_1 <= (arrays_1.length - 1); idx_1++) {
+                const arr_2 = item(idx_1, arrays_1);
+                for (let j = 0; j <= (arr_2.length - 1); j++) {
+                    setItem(result, totalIdx, item(j, arr_2));
+                    totalIdx = ((totalIdx + 1) | 0);
+                }
+            }
+            return result;
+        }
+    }
+}
+function collect(mapping, array, cons) {
+    return concat(map(mapping, array, defaultOf()), cons);
+}
+function indexOf(array, item_1, start, count, eq) {
+    const start_1 = defaultArg(start, 0) | 0;
+    const end$0027 = defaultArg(map$1((c) => (start_1 + c), count), array.length) | 0;
+    const loop = (i_mut) => {
+        loop: while (true) {
+            const i = i_mut;
+            if (i >= end$0027) {
+                return -1;
+            }
+            else if (eq.Equals(item_1, item(i, array))) {
+                return i | 0;
+            }
+            else {
+                i_mut = (i + 1);
+                continue loop;
+            }
+        }
+    };
+    return loop(start_1) | 0;
+}
+function contains(value, array, eq) {
+    return indexOf(array, value, undefined, undefined, eq) >= 0;
+}
+function singleton(value, cons) {
+    const ar = Helpers_allocateArrayFromCons(cons, 1);
+    setItem(ar, 0, value);
+    return ar;
+}
+function initialize(count, initializer, cons) {
+    if (count < 0) {
+        throw new Error("The input must be non-negative\\nParameter name: count");
+    }
+    const result = Helpers_allocateArrayFromCons(cons, count);
+    for (let i = 0; i <= (count - 1); i++) {
+        setItem(result, i, initializer(i));
+    }
+    return result;
+}
+function skip(count, array, cons) {
+    if (count > array.length) {
+        throw new Error("count is greater than array length\\nParameter name: count");
+    }
+    if (count === array.length) {
+        return Helpers_allocateArrayFromCons(cons, 0);
+    }
+    else {
+        const count_1 = (count) | 0;
+        return array.slice(count_1);
+    }
+}
+function addInPlace(x, array) {
+    array.push(x);
+}
+function addRangeInPlace(range, array) {
+    const enumerator = getEnumerator(range);
+    try {
+        while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+            addInPlace(enumerator["System.Collections.Generic.IEnumerator`1.get_Current"](), array);
+        }
+    }
+    finally {
+        disposeSafe(enumerator);
+    }
+}
+function insertRangeInPlace(index, range, array) {
+    let index_1;
+    let i = index;
+    const enumerator = getEnumerator(range);
+    try {
+        while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+            const x = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+            (index_1 = (i | 0), array.splice(index_1, 0, x));
+            i = ((i + 1) | 0);
+        }
+    }
+    finally {
+        disposeSafe(enumerator);
+    }
+}
+function removeInPlace(item_1, array, eq) {
+    const i = indexOf(array, item_1, undefined, undefined, eq) | 0;
+    if (i > -1) {
+        array.splice(i, 1);
+        return true;
+    }
+    else {
+        return false;
+    }
+}
+function tryFind(predicate, array) {
+    return array.find(predicate);
+}
+function tryFindIndex(predicate, array) {
+    const matchValue = (array.findIndex(predicate)) | 0;
+    if (matchValue > -1) {
+        return matchValue;
+    }
+    else {
+        return undefined;
+    }
+}
+function tryPick(chooser, array) {
+    const loop = (i_mut) => {
+        loop: while (true) {
+            const i = i_mut;
+            if (i >= array.length) {
+                return undefined;
+            }
+            else {
+                const matchValue = chooser(item(i, array));
+                if (matchValue == null) {
+                    i_mut = (i + 1);
+                    continue loop;
+                }
+                else {
+                    return matchValue;
+                }
+            }
+        }
+    };
+    return loop(0);
+}
+function choose(chooser, array, cons) {
+    const res = [];
+    for (let i = 0; i <= (array.length - 1); i++) {
+        const matchValue = chooser(item(i, array));
+        if (matchValue != null) {
+            const y = value(matchValue);
+            res.push(y);
+        }
+    }
+    if (equals(cons, defaultOf())) {
+        return res;
+    }
+    else {
+        return map((x) => x, res, cons);
+    }
+}
+function fold(folder, state, array) {
+    const folder_1 = folder;
+    return array.reduce((folder_1), state);
+}
+function iterateIndexed(action, array) {
+    for (let i = 0; i <= (array.length - 1); i++) {
+        action(i, item(i, array));
+    }
+}
+function forAll(predicate, array) {
+    return array.every(predicate);
+}
+function sortBy(projection, xs, comparer) {
+    const xs_1 = xs.slice();
+    xs_1.sort((x, y) => comparer.Compare(projection(x), projection(y)));
+    return xs_1;
+}
+function sortDescending(xs, comparer) {
+    const xs_1 = xs.slice();
+    xs_1.sort((x, y) => (comparer.Compare(x, y) * -1));
+    return xs_1;
+}
+function unzip(array) {
+    const len = array.length | 0;
+    const res1 = new Array(len);
+    const res2 = new Array(len);
+    iterateIndexed((i, tupledArg) => {
+        setItem(res1, i, tupledArg[0]);
+        setItem(res2, i, tupledArg[1]);
+    }, array);
+    return [res1, res2];
+}
+function equalsWith(equals, array1, array2) {
+    if (array1 == null) {
+        if (array2 == null) {
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+    else if (array2 == null) {
+        return false;
+    }
+    else {
+        let i = 0;
+        let result = true;
+        const length1 = array1.length | 0;
+        const length2 = array2.length | 0;
+        if (length1 > length2) {
+            return false;
+        }
+        else if (length1 < length2) {
+            return false;
+        }
+        else {
+            while ((i < length1) && result) {
+                result = equals(item(i, array1), item(i, array2));
+                i = ((i + 1) | 0);
+            }
+            return result;
+        }
+    }
+}
+function head(array) {
+    if (array.length === 0) {
+        throw new Error("The input array was empty\\nParameter name: array");
+    }
+    else {
+        return item(0, array);
+    }
+}
+function tryHead(array) {
+    if (array.length === 0) {
+        return undefined;
+    }
+    else {
+        return some(item(0, array));
+    }
+}
+function tail(array) {
+    if (array.length === 0) {
+        throw new Error("Not enough elements\\nParameter name: array");
+    }
+    return array.slice(1);
+}
+function item(index, array) {
+    if ((index < 0) ? true : (index >= array.length)) {
+        throw new Error("Index was outside the bounds of the array.\\nParameter name: index");
+    }
+    else {
+        return array[index];
+    }
+}
+function setItem(array, index, value) {
+    if ((index < 0) ? true : (index >= array.length)) {
+        throw new Error("Index was outside the bounds of the array.\\nParameter name: index");
+    }
+    else {
+        array[index] = value;
+    }
+}
+function tryItem(index, array) {
+    if ((index < 0) ? true : (index >= array.length)) {
+        return undefined;
+    }
+    else {
+        return some(array[index]);
+    }
+}
+function foldBack(folder, array, state) {
+    return array.reduceRight(((delegateArg, delegateArg_1) => folder(delegateArg_1, delegateArg)), state);
+}
+function transpose(arrays, cons) {
+    const arrays_1 = Array.isArray(arrays) ? arrays : (Array.from(arrays));
+    const len = arrays_1.length | 0;
+    if (len === 0) {
+        return new Array(0);
+    }
+    else {
+        const firstArray = item(0, arrays_1);
+        const lenInner = firstArray.length | 0;
+        if (!forAll((a) => (a.length === lenInner), arrays_1)) {
+            differentLengths();
+        }
+        const result = new Array(lenInner);
+        for (let i = 0; i <= (lenInner - 1); i++) {
+            setItem(result, i, Helpers_allocateArrayFromCons(cons, len));
+            for (let j = 0; j <= (len - 1); j++) {
+                item(i, result)[j] = item(i, item(j, arrays_1));
+            }
+        }
+        return result;
+    }
+}
+
+export { addInPlace, addRangeInPlace, append, choose, collect, concat, contains, equalsWith, fill, fold, foldBack, forAll, head, indexOf, initialize, insertRangeInPlace, item, iterateIndexed, map, map3, mapIndexed, removeInPlace, setItem, singleton, skip, sortBy, sortDescending, tail, transpose, tryFind, tryFindIndex, tryHead, tryItem, tryPick, unzip };

package/dist/ts/node_modules/@fable-org/fable-library-js/Async.js

@@ -0,0 +1,28 @@
+import { Trampoline, CancellationToken, protectedCont, OperationCanceledError } from './AsyncBuilder.js';
+
+function emptyContinuation(_x) {
+    // NOP
+}
+function awaitPromise(p) {
+    return fromContinuations((conts) => p.then(conts[0]).catch((err) => (err instanceof OperationCanceledError
+        ? conts[2] : conts[1])(err)));
+}
+const defaultCancellationToken = new CancellationToken();
+function fromContinuations(f) {
+    return protectedCont((ctx) => f([ctx.onSuccess, ctx.onError, ctx.onCancel]));
+}
+function startWithContinuations(computation, continuation, exceptionContinuation, cancellationContinuation, cancelToken) {
+    const trampoline = new Trampoline();
+    computation({
+        onSuccess: continuation ? continuation : emptyContinuation,
+        onError: exceptionContinuation,
+        onCancel: cancellationContinuation,
+        cancelToken: cancelToken ? cancelToken : defaultCancellationToken,
+        trampoline,
+    });
+}
+function startAsPromise(computation, cancellationToken) {
+    return new Promise((resolve, reject) => startWithContinuations(computation, resolve, reject, reject, defaultCancellationToken));
+}
+
+export { awaitPromise, defaultCancellationToken, fromContinuations, startAsPromise, startWithContinuations };

package/dist/ts/node_modules/@fable-org/fable-library-js/AsyncBuilder.js

@@ -0,0 +1,186 @@
+import { ensureErrorOrException } from './Types.js';
+
+class CancellationToken {
+    constructor(cancelled = false) {
+        this._id = 0;
+        this._cancelled = cancelled;
+        this._listeners = new Map();
+    }
+    get isCancelled() {
+        return this._cancelled;
+    }
+    cancel() {
+        if (!this._cancelled) {
+            this._cancelled = true;
+            for (const [, listener] of this._listeners) {
+                listener();
+            }
+        }
+    }
+    addListener(f) {
+        const id = this._id;
+        this._listeners.set(this._id++, f);
+        return id;
+    }
+    removeListener(id) {
+        return this._listeners.delete(id);
+    }
+    register(f, state) {
+        const $ = this;
+        const id = this.addListener(state == null ? f : () => f(state));
+        return { Dispose() { $.removeListener(id); } };
+    }
+    Dispose() {
+        // Implement IDisposable for compatibility but do nothing
+        // According to docs, calling Dispose does not trigger cancellation
+        // https://docs.microsoft.com/en-us/dotnet/api/system.threading.cancellationtokensource.dispose?view=net-6.0
+    }
+}
+class OperationCanceledError extends Error {
+    constructor() {
+        super("The operation was canceled");
+        Object.setPrototypeOf(this, OperationCanceledError.prototype);
+    }
+}
+class Trampoline {
+    static get maxTrampolineCallCount() {
+        return 2000;
+    }
+    constructor() {
+        this.callCount = 0;
+    }
+    incrementAndCheck() {
+        return this.callCount++ > Trampoline.maxTrampolineCallCount;
+    }
+    hijack(f) {
+        this.callCount = 0;
+        setTimeout(f, 0);
+    }
+}
+function protectedCont(f) {
+    return (ctx) => {
+        if (ctx.cancelToken.isCancelled) {
+            ctx.onCancel(new OperationCanceledError());
+        }
+        else if (ctx.trampoline.incrementAndCheck()) {
+            ctx.trampoline.hijack(() => {
+                try {
+                    f(ctx);
+                }
+                catch (err) {
+                    ctx.onError(ensureErrorOrException(err));
+                }
+            });
+        }
+        else {
+            try {
+                f(ctx);
+            }
+            catch (err) {
+                ctx.onError(ensureErrorOrException(err));
+            }
+        }
+    };
+}
+function protectedBind(computation, binder) {
+    return protectedCont((ctx) => {
+        computation({
+            onSuccess: (x) => {
+                try {
+                    binder(x)(ctx);
+                }
+                catch (err) {
+                    ctx.onError(ensureErrorOrException(err));
+                }
+            },
+            onError: ctx.onError,
+            onCancel: ctx.onCancel,
+            cancelToken: ctx.cancelToken,
+            trampoline: ctx.trampoline,
+        });
+    });
+}
+function protectedReturn(value) {
+    return protectedCont((ctx) => ctx.onSuccess(value));
+}
+class AsyncBuilder {
+    Bind(computation, binder) {
+        return protectedBind(computation, binder);
+    }
+    Combine(computation1, computation2) {
+        return this.Bind(computation1, () => computation2);
+    }
+    Delay(generator) {
+        return protectedCont((ctx) => generator()(ctx));
+    }
+    For(sequence, body) {
+        const iter = sequence[Symbol.iterator]();
+        let cur = iter.next();
+        return this.While(() => !cur.done, this.Delay(() => {
+            const res = body(cur.value);
+            cur = iter.next();
+            return res;
+        }));
+    }
+    Return(value) {
+        return protectedReturn(value);
+    }
+    ReturnFrom(computation) {
+        return computation;
+    }
+    TryFinally(computation, compensation) {
+        return protectedCont((ctx) => {
+            computation({
+                onSuccess: (x) => {
+                    compensation();
+                    ctx.onSuccess(x);
+                },
+                onError: (x) => {
+                    compensation();
+                    ctx.onError(x);
+                },
+                onCancel: (x) => {
+                    compensation();
+                    ctx.onCancel(x);
+                },
+                cancelToken: ctx.cancelToken,
+                trampoline: ctx.trampoline,
+            });
+        });
+    }
+    TryWith(computation, catchHandler) {
+        return protectedCont((ctx) => {
+            computation({
+                onSuccess: ctx.onSuccess,
+                onCancel: ctx.onCancel,
+                cancelToken: ctx.cancelToken,
+                trampoline: ctx.trampoline,
+                onError: (ex) => {
+                    try {
+                        catchHandler(ex)(ctx);
+                    }
+                    catch (err) {
+                        ctx.onError(ensureErrorOrException(err));
+                    }
+                },
+            });
+        });
+    }
+    Using(resource, binder) {
+        return this.TryFinally(binder(resource), () => resource.Dispose());
+    }
+    While(guard, computation) {
+        if (guard()) {
+            return this.Bind(computation, () => this.While(guard, computation));
+        }
+        else {
+            return this.Return(void 0);
+        }
+    }
+    Zero() {
+        return protectedCont((ctx) => ctx.onSuccess(void 0));
+    }
+}
+const singleton = new AsyncBuilder();
+
+export { AsyncBuilder, CancellationToken, OperationCanceledError, Trampoline, protectedBind, protectedCont, protectedReturn, singleton };

package/dist/ts/node_modules/@fable-org/fable-library-js/BigInt.js

@@ -0,0 +1,8 @@
+BigInt.prototype.toJSON = function () {
+    return `${this.toString()}`;
+};
+function fromString(s) { return BigInt(s); }
+function toInt64(x) { return BigInt.asIntN(64, x); }
+function toUInt64(x) { return BigInt.asUintN(64, x); }
+
+export { fromString, toInt64, toUInt64 };

package/dist/ts/node_modules/@fable-org/fable-library-js/Boolean.js

@@ -0,0 +1,24 @@
+import { FSharpRef } from './Types.js';
+
+function tryParse(str, defValue) {
+    if (str != null && str.match(/^\s*true\s*$/i)) {
+        defValue.contents = true;
+        return true;
+    }
+    else if (str != null && str.match(/^\s*false\s*$/i)) {
+        defValue.contents = false;
+        return true;
+    }
+    return false;
+}
+function parse(str) {
+    const defValue = new FSharpRef(false);
+    if (tryParse(str, defValue)) {
+        return defValue.contents;
+    }
+    else {
+        throw new Error(`String '${str}' was not recognized as a valid Boolean.`);
+    }
+}
+
+export { parse, tryParse };