@nfdi4plants/arctrl 3.1.1 → 3.2.0

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

@@ -0,0 +1,174 @@
+import { protectedBind, CancellationToken, protectedCont, protectedReturn, OperationCanceledException, Trampoline } from './AsyncBuilder.js';
+import { Choice_makeChoice2Of2, Choice_makeChoice1Of2 } from './Choice.js';
+import { TimeoutException_$ctor } from './System.js';
+import { Exception } from './Util.js';
+
+function emptyContinuation(_x) {
+}
+function makeAsync(body) {
+  return body;
+}
+function invoke(computation, ctx) {
+  return computation(ctx);
+}
+function callThenInvoke(ctx, result1, part2) {
+  return part2(result1)(ctx);
+}
+function bind(ctx, part1, part2) {
+  return protectedBind(part1, part2)(ctx);
+}
+function createCancellationToken(arg) {
+  const token = new CancellationToken(typeof arg === "boolean" ? arg : false);
+  if (typeof arg === "number") {
+    setTimeout(() => {
+      token.cancel();
+    }, arg);
+  }
+  return token;
+}
+function cancel(token) {
+  token.cancel();
+}
+function cancelAfter(token, ms) {
+  setTimeout(() => {
+    token.cancel();
+  }, ms);
+}
+function isCancellationRequested(token) {
+  return token != null && token.isCancelled;
+}
+function throwIfCancellationRequested(token) {
+  if (token != null && token.isCancelled) {
+    throw new Exception("Operation is cancelled");
+  }
+}
+function startChild(computation, ms) {
+  return protectedCont((ctx) => {
+    const promise = startAsPromise(computation, ctx.cancelToken);
+    let promiseToRun = promise;
+    if (ms) {
+      promiseToRun = new Promise((resolve, reject) => {
+        const timeoutId = setTimeout(() => reject(TimeoutException_$ctor()), ms);
+        promise.then(
+          (value) => {
+            clearTimeout(timeoutId);
+            resolve(value);
+          },
+          (error) => {
+            clearTimeout(timeoutId);
+            reject(error);
+          }
+        );
+      });
+    }
+    promiseToRun.catch(emptyContinuation);
+    protectedReturn(awaitPromise(promiseToRun))(ctx);
+  });
+}
+function awaitPromise(p) {
+  return fromContinuations((conts) => p.then(conts[0]).catch((err) => (err instanceof OperationCanceledException ? conts[2] : conts[1])(err)));
+}
+function awaitEvent(event, cancelAction) {
+  return protectedCont((ctx) => {
+    let tokenId;
+    const handler = (_sender, arg) => {
+      ctx.cancelToken.removeListener(tokenId);
+      event.RemoveHandler(handler);
+      ctx.onSuccess(arg);
+    };
+    tokenId = ctx.cancelToken.addListener(() => {
+      event.RemoveHandler(handler);
+      if (cancelAction != null) {
+        cancelAction();
+      }
+      ctx.onCancel(new OperationCanceledException());
+    });
+    event.AddHandler(handler);
+  });
+}
+function cancellationToken() {
+  return protectedCont((ctx) => ctx.onSuccess(ctx.cancelToken));
+}
+const defaultCancellationToken = new CancellationToken();
+function catchAsync(work) {
+  return protectedCont((ctx) => {
+    work({
+      onSuccess: (x) => ctx.onSuccess(Choice_makeChoice1Of2(x)),
+      onError: (ex) => ctx.onSuccess(Choice_makeChoice2Of2(ex)),
+      onCancel: ctx.onCancel,
+      cancelToken: ctx.cancelToken,
+      trampoline: ctx.trampoline
+    });
+  });
+}
+function fromContinuations(f) {
+  return protectedCont((ctx) => f([ctx.onSuccess, ctx.onError, ctx.onCancel]));
+}
+function ignore(computation) {
+  return protectedBind(computation, (_x) => protectedReturn(void 0));
+}
+function parallel(computations) {
+  return protectedCont((ctx) => awaitPromise(Promise.all(Array.from(computations, (w) => startAsPromise(w, ctx.cancelToken))))(ctx));
+}
+function sequential(computations) {
+  function _sequential(computations2, cancelToken) {
+    let pr = Promise.resolve([]);
+    for (const c of computations2) {
+      pr = pr.then((results) => startAsPromise(c, cancelToken).then((r) => results.concat([r])));
+    }
+    return pr;
+  }
+  return protectedCont((ctx) => awaitPromise(_sequential(computations, ctx.cancelToken))(ctx));
+}
+function sleep(millisecondsDueTime) {
+  return protectedCont((ctx) => {
+    let tokenId;
+    const timeoutId = setTimeout(() => {
+      ctx.cancelToken.removeListener(tokenId);
+      ctx.onSuccess(void 0);
+    }, millisecondsDueTime);
+    tokenId = ctx.cancelToken.addListener(() => {
+      clearTimeout(timeoutId);
+      ctx.onCancel(new OperationCanceledException());
+    });
+  });
+}
+function start(computation, cancellationToken2) {
+  return startWithContinuations(
+    computation,
+    emptyContinuation,
+    function(err) {
+      throw err;
+    },
+    emptyContinuation,
+    cancellationToken2
+  );
+}
+function startImmediate(computation, cancellationToken2) {
+  return start(computation, cancellationToken2);
+}
+function startWithContinuations(computation, continuation, exceptionContinuation, cancellationContinuation, cancelToken) {
+  const trampoline = new Trampoline();
+  const done = (cont) => (x) => {
+    trampoline.completed = true;
+    return cont(x);
+  };
+  computation({
+    onSuccess: done(continuation ? continuation : emptyContinuation),
+    onError: done(exceptionContinuation),
+    onCancel: done(cancellationContinuation),
+    cancelToken: cancelToken ? cancelToken : defaultCancellationToken,
+    trampoline
+  });
+}
+function startAsPromise(computation, cancellationToken2) {
+  return new Promise((resolve, reject) => startWithContinuations(
+    computation,
+    resolve,
+    reject,
+    reject,
+    cancellationToken2 ? cancellationToken2 : defaultCancellationToken
+  ));
+}
+
+export { awaitEvent, awaitPromise, bind, callThenInvoke, cancel, cancelAfter, cancellationToken, catchAsync, createCancellationToken, defaultCancellationToken, fromContinuations, ignore, invoke, isCancellationRequested, makeAsync, parallel, sequential, sleep, start, startAsPromise, startChild, startImmediate, startWithContinuations, throwIfCancellationRequested };

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

@@ -0,0 +1,190 @@
+import { Exception, ensureErrorOrException } from './Util.js';
+
+class CancellationToken {
+  constructor(cancelled = false) {
+    this._id = 0;
+    this._cancelled = cancelled;
+    this._listeners = /* @__PURE__ */ 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() {
+  }
+}
+class OperationCanceledException extends Exception {
+  constructor(msg) {
+    super(msg ?? "The operation was canceled");
+  }
+}
+class Trampoline {
+  static get maxTrampolineCallCount() {
+    return 2e3;
+  }
+  constructor() {
+    this.callCount = 0;
+    this.completed = false;
+  }
+  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 OperationCanceledException());
+    } else if (ctx.trampoline.incrementAndCheck()) {
+      ctx.trampoline.hijack(() => {
+        try {
+          f(ctx);
+        } catch (err) {
+          if (ctx.trampoline.completed) {
+            throw err;
+          }
+          ctx.onError(ensureErrorOrException(err));
+        }
+      });
+    } else {
+      try {
+        f(ctx);
+      } catch (err) {
+        if (ctx.trampoline.completed) {
+          throw err;
+        }
+        ctx.onError(ensureErrorOrException(err));
+      }
+    }
+  };
+}
+function protectedBind(computation, binder) {
+  return protectedCont((ctx) => {
+    computation({
+      onSuccess: (x) => {
+        let bound;
+        try {
+          bound = binder(x);
+        } catch (err) {
+          ctx.onError(ensureErrorOrException(err));
+          return;
+        }
+        bound(ctx);
+      },
+      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) => {
+          let handled;
+          try {
+            handled = catchHandler(ex);
+          } catch (err) {
+            ctx.onError(ensureErrorOrException(err));
+            return;
+          }
+          handled(ctx);
+        }
+      });
+    });
+  }
+  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, OperationCanceledException, Trampoline, protectedBind, protectedCont, protectedReturn, singleton };