@fncts/io 0.0.31 → 0.0.33

package/_src/Stream/api.ts

@@ -247,7 +247,11 @@ export function asyncInterrupt<R, E, A>(
         IO.succeed(() =>
           register((k, cb) => {
             const effect = Take.fromPull(k).flatMap((a) => output.offer(a));
-            return runtime.unsafeRunAsyncWith(effect, cb || constVoid);
+            const fiber  = runtime.makeFiber(effect);
+            if (cb) {
+              fiber.addObserver(cb);
+            }
+            fiber.start(effect);
           }),
         ),
       );
@@ -317,12 +321,14 @@ export function asyncIO<R, E, A, R1 = R, E1 = E>(
         const output  = Δ(IO.acquireRelease(Queue.makeBounded<Take<E, A>>(outputBuffer), (_) => _.shutdown));
         const runtime = Δ(IO.runtime<R>());
         Δ(
-          register((k, cb) =>
-            runtime.unsafeRunAsyncWith(
-              Take.fromPull(k).flatMap((a) => output.offer(a)),
-              cb || constVoid,
-            ),
-          ),
+          register((k, cb) => {
+            const io    = Take.fromPull(k).flatMap((a) => output.offer(a));
+            const fiber = runtime.makeFiber(io);
+            if (cb) {
+              fiber.addObserver(cb);
+            }
+            fiber.start(io);
+          }),
         );
         const loop: Channel<never, unknown, unknown, unknown, E, Conc<A>, void> = Channel.unwrap(
           output.take
@@ -812,9 +818,10 @@ function combineChunksProducer<Err, Elem>(
 ): Channel<never, Err, Conc<Elem>, unknown, never, never, any> {
   return Channel.fromIO(latch.take).zipRight(
     Channel.readWithCause(
-      (chunk) => Channel.fromIO(handoff.offer(Take.chunk(chunk))).zipRight(combineChunksProducer(handoff, latch)),
+      (chunk: Conc<Elem>) =>
+        Channel.fromIO(handoff.offer(Take.chunk(chunk))).zipRight(combineChunksProducer(handoff, latch)),
       (cause) => Channel.fromIO(handoff.offer(Take.failCause(cause))),
-      () => Channel.fromIO(handoff.offer(Take.end)).zipRight(combineChunksProducer(handoff, latch)),
+      () => Channel.fromIO(handoff.offer(Take.end)),
     ),
   );
 }
@@ -991,6 +998,13 @@ export function debounce(duration: Lazy<Duration>, __tsplusTrace?: string) {
   };
 }
 
+/**
+ * @tsplus static fncts.io.StreamOps defer
+ */
+export function defer<R, E, A>(self: Lazy<Stream<R, E, A>>): Stream<R, E, A> {
+  return new Stream(Channel.defer(self().channel));
+}
+
 function defaultIfEmptyWriter<R, E, A, R1, E1, B>(
   fb: Stream<R1, E1, B>,
   __tsplusTrace?: string,
@@ -1149,7 +1163,7 @@ export function distributedWithDynamic<E, A>(
  *
  * @tsplus getter fncts.io.Stream drain
  */
-export function drain<R, E, A>(fa: Stream<R, E, A>, __tsplusTrace?: string): Stream<R, E, void> {
+export function drain<R, E, A>(fa: Stream<R, E, A>, __tsplusTrace?: string): Stream<R, E, never> {
   return new Stream(fa.channel.drain);
 }
 
@@ -1304,6 +1318,15 @@ export function environmentWithStream<R0, R, E, A>(
   return Stream.environment<R0>().flatMap(f);
 }
 
+/**
+ * Creates a stream that executes the specified effect but emits no elements.
+ *
+ * @tsplus static fncts.io.StreamOps execute
+ */
+export function execute<R, E>(io: IO<R, E, any>, __tsplusTrace?: string): Stream<R, E, never> {
+  return Stream.fromIO(io).drain;
+}
+
 /**
  * Halt a stream with the specified error
  *
@@ -1576,6 +1599,65 @@ export function scoped<R, E, A>(stream: Lazy<IO<R, E, A>>, __tsplusTrace?: strin
   return new Stream(Channel.scoped(stream().map(Conc.single)));
 }
 
+/**
+ * Emits a sliding window of n elements.
+ *
+ * @tsplus pipeable fncts.io.Stream sliding
+ */
+export function sliding(chunkSize: number, stepSize: number, __tsplusTrace?: string) {
+  return <R, E, A>(self: Stream<R, E, A>): Stream<R, E, Conc<A>> => {
+    return Stream.defer(() => {
+      function slidingChunk(chunk: Conc<A>, input: Conc<A>): [Conc<A>, Conc<Conc<A>>] {
+        const updatedChunk = chunk.concat(input);
+        const length       = updatedChunk.length;
+        if (length >= chunkSize) {
+          const array    = new Array<Conc<A>>((length - chunkSize) / stepSize + 1);
+          let arrayIndex = 0;
+          let chunkIndex = 0;
+          while (chunkIndex + chunkSize <= length) {
+            array[arrayIndex] = updatedChunk.slice(chunkIndex, chunkIndex + chunkSize);
+            arrayIndex       += 1;
+            chunkIndex       += stepSize;
+          }
+          return [updatedChunk.drop(chunkIndex), Conc.fromArray(array)];
+        } else {
+          return [updatedChunk, Conc.empty()];
+        }
+      }
+      function sliding(chunk: Conc<A>, written: boolean): Channel<never, E, Conc<A>, any, E, Conc<Conc<A>>, any> {
+        return Channel.readWithCause(
+          (input) => {
+            const [updatedChunk, out] = slidingChunk(chunk, input);
+            if (out.isEmpty) {
+              return sliding(updatedChunk, written);
+            } else {
+              return Channel.writeNow(out) > sliding(updatedChunk, true);
+            }
+          },
+          (err) => {
+            const index = written && chunkSize > stepSize ? chunkSize - stepSize : 0;
+            if (index >= chunk.length) {
+              return Channel.failCauseNow(err);
+            } else {
+              return Channel.writeNow(Conc.single(chunk)) > Channel.failCauseNow(err);
+            }
+          },
+          (done) => {
+            const index = written && chunkSize > stepSize ? chunkSize - stepSize : 0;
+            if (index >= chunk.length) {
+              return Channel.succeedNow(done);
+            } else {
+              return Channel.writeNow(Conc.single(chunk)) > Channel.succeedNow(done);
+            }
+          },
+        );
+      }
+
+      return new Stream(self.channel >>> sliding(Conc.empty(), false));
+    });
+  };
+}
+
 /**
  * Creates a stream from an effect producing a value of type `A`
  *
@@ -2189,14 +2271,105 @@ function mapIOLoop<R, E, A, R1, E1, B>(
  *
  * @note This combinator destroys the chunking structure. It's recommended to use chunkN afterwards.
  *
- * @tsplus pipeable fncts.io.Stream mapIOC
+ * @tsplus pipeable fncts.io.Stream mapIOConcurrently
  */
-export function mapIOC<A, R1, E1, B>(n: number, f: (a: A) => IO<R1, E1, B>, __tsplusTrace?: string) {
+export function mapIOConcurrently<A, R1, E1, B>(n: number, f: (a: A) => IO<R1, E1, B>, __tsplusTrace?: string) {
   return <R, E>(stream: Stream<R, E, A>): Stream<R | R1, E | E1, B> => {
     return new Stream(stream.channel.concatMap(Channel.writeChunk).mapOutConcurrentIO(n, f).mapOut(Conc.single));
   };
 }
 
+/**
+ * @tsplus pipeable fncts.io.Stream mapIOConcurrentlyUnordered
+ */
+export function mapIOConcurrentlyUnordered<A, R1, E1, B>(n: number, f: (a: A) => IO<R1, E1, B>) {
+  return <R, E>(self: Stream<R, E, A>): Stream<R | R1, E | E1, B> => {
+    return self.pipeThroughChannelOrFail(
+      Channel.id<never, Conc<A>, any>()
+        .concatMap((chunk) => Channel.writeChunk(chunk))
+        .mergeMap((inp) => Stream.fromIO(f(inp)).channel, n, 16),
+    );
+  };
+}
+
+/**
+ * Merges this stream and the specified stream together.
+ *
+ * New produced stream will terminate when both specified stream terminate if
+ * no termination strategy is specified.
+ *
+ * @tsplus pipeable fncts.io.Stream merge
+ */
+export function merge<R1, E1, B>(
+  that: Stream<R1, E1, B>,
+  strategy: TerminationStrategy = "Both",
+  __tsplusTrace?: string,
+) {
+  return <R, E, A>(self: Stream<R, E, A>): Stream<R | R1, E | E1, A | B> => {
+    return self.mergeWith(that, identity, identity, strategy);
+  };
+}
+
+/**
+ * Merges this stream and the specified stream together. New produced stream
+ * will terminate when either stream terminates.
+ *
+ * @tsplus pipeable fncts.io.Stream mergeHaltEither
+ */
+export function mergeHaltEither<R1, E1, B>(that: Stream<R1, E1, B>, __tsplusTrace?: string) {
+  return <R, E, A>(self: Stream<R, E, A>): Stream<R | R1, E | E1, A | B> => {
+    return self.merge(that, "Either");
+  };
+}
+
+/**
+ * Merges this stream and the specified stream together. New produced stream
+ * will terminate when this stream terminates.
+ *
+ * @tsplus pipeable fncts.io.Stream mergeHaltLeft
+ */
+export function mergeHaltLeft<R1, E1, B>(that: Stream<R1, E1, B>, __tsplusTrace?: string) {
+  return <R, E, A>(self: Stream<R, E, A>): Stream<R | R1, E | E1, A | B> => {
+    return self.merge(that, "Left");
+  };
+}
+
+/**
+ * Merges this stream and the specified stream together. New produced stream
+ * will terminate when the specified stream terminates.
+ *
+ * @tsplus pipeable fncts.io.Stream mergeHaltRight
+ */
+export function mergeHaltRight<R1, E1, B>(that: Stream<R1, E1, B>, __tsplusTrace?: string) {
+  return <R, E, A>(self: Stream<R, E, A>): Stream<R | R1, E | E1, A | B> => {
+    return self.merge(that, "Right");
+  };
+}
+
+/**
+ * Merges this stream and the specified stream together, discarding the values
+ * from the right stream.
+ *
+ * @tsplus pipeable fncts.io.Stream mergeLeft
+ */
+export function mergeLeft<R1, E1, B>(that: Stream<R1, E1, B>, __tsplusTrace?: string) {
+  return <R, E, A>(self: Stream<R, E, A>): Stream<R | R1, E | E1, A> => {
+    return self.merge(that.drain);
+  };
+}
+
+/**
+ * Merges this stream and the specified stream together, discarding the values
+ * from the left stream.
+ *
+ * @tsplus pipeable fncts.io.Stream mergeRight
+ */
+export function mergeRight<R1, E1, B>(that: Stream<R1, E1, B>, __tsplusTrace?: string) {
+  return <R, E, A>(self: Stream<R, E, A>): Stream<R | R1, E | E1, B> => {
+    return self.drain.merge(that);
+  };
+}
+
 /**
  * Maps each element of this stream to another stream and returns the
  * non-deterministic merge of those streams, executing up to `n` inner streams
@@ -2243,7 +2416,7 @@ export function mergeEither<R1, E1, B>(fb: Stream<R1, E1, B>, __tsplusTrace?: st
   };
 }
 
-export function mergeWithHandler<R, E>(
+function mergeWithHandler<R, E>(
   terminate: boolean,
   __tsplusTrace?: string,
 ): (exit: Exit<E, unknown>) => MergeDecision<R, E, unknown, E, unknown> {
@@ -2366,6 +2539,15 @@ export function pipeThrough<A, R1, E1, L, Z>(sa: Sink<R1, E1, A, L, Z>, __tsplus
   };
 }
 
+/**
+ * @tsplus pipeable fncts.io.Stream pipeThroughChannelOrFail
+ */
+export function pipeThroughChannelOrFail<A, R1, E1, B>(channel: Channel<R1, never, Conc<A>, any, E1, Conc<B>, any>) {
+  return <R, E>(self: Stream<R, E, A>): Stream<R | R1, E | E1, B> => {
+    return new Stream(self.channel >>> channel);
+  };
+}
+
 /**
  * Provides the stream with its required environment, which eliminates
  * its dependency on `R`.
@@ -2603,6 +2785,27 @@ export function runIntoQueueScoped<RA, RB, EA, EB, E1, A, B>(
   };
 }
 
+/**
+ * Like runIntoQueue, but provides the result as a scoped IO
+ * to allow for scope composition.
+ *
+ * @tsplus pipeable fncts.io.Stream runIntoQueueElementsScoped
+ */
+export function runIntoQueueElementsScoped<E, A>(queue: Lazy<Queue.Enqueue<Exit<Maybe<E>, A>>>) {
+  return <R>(self: Stream<R, E, A>): IO<R | Scope, never, void> => {
+    return IO.defer(() => {
+      const queue0 = queue();
+      const writer: Channel<R, E, Conc<A>, any, never, Exit<Maybe<E>, A>, any> = Channel.readWithCause(
+        (inp: Conc<A>) => Channel.fromIO(queue0.offerAll(inp.map((a) => Exit.succeed(a)))) > writer,
+        (cause) => Channel.fromIO(queue0.offer(Exit.failCause(cause.map((e) => Just(e))))),
+        () => Channel.fromIO(queue0.offer(Exit.fail(Nothing()))),
+      );
+
+      return (self.channel >>> writer).drain.runScoped.asUnit;
+    });
+  };
+}
+
 /**
  * Like `Stream#runIntoHub`, but provides the result as a `Managed` to allow for scope
  * composition.
@@ -2682,6 +2885,40 @@ export function scanReduceIO<A extends B, R1, E1, B>(f: (b: B, a: A) => IO<R1, E
   };
 }
 
+/**
+ * @tsplus pipeable fncts.io.Stream split
+ */
+export function split<A>(predicate: Predicate<A>, __tsplusTrace?: string) {
+  return <R, E>(self: Stream<R, E, A>): Stream<R, E, Conc<A>> => {
+    function split(leftovers: Conc<A>, input: Conc<A>): Channel<R, E, Conc<A>, any, E, Conc<Conc<A>>, any> {
+      const [chunk, remaining] = leftovers.concat(input).splitWhere(predicate);
+      if (chunk.isEmpty || remaining.isEmpty) {
+        return loop(chunk.concat(remaining.drop(1)));
+      } else {
+        return Channel.writeNow(Conc.single(chunk)) > split(Conc.empty(), remaining.drop(1));
+      }
+    }
+
+    function loop(leftovers: Conc<A>): Channel<R, E, Conc<A>, any, E, Conc<Conc<A>>, any> {
+      return Channel.readWith(
+        (input) => split(leftovers, input),
+        Channel.failNow,
+        (_) => {
+          if (leftovers.isEmpty) {
+            return Channel.unit;
+          } else if (leftovers.find(predicate).isNothing()) {
+            return Channel.writeNow(Conc.single(leftovers)) > Channel.unit;
+          } else {
+            return split(Conc.empty(), leftovers) > Channel.unit;
+          }
+        },
+      );
+    }
+
+    return new Stream(self.channel >>> loop(Conc.empty()));
+  };
+}
+
 /**
  * Creates a single-valued pure stream
  *
@@ -2805,6 +3042,70 @@ export function tap<A, R1, E1>(f: (a: A) => IO<R1, E1, any>, __tsplusTrace?: str
   };
 }
 
+/**
+ * Returns a stream that effectfully "peeks" at the failure and adds an effect
+ * to consumption of every element of the stream
+ *
+ * @tsplus pipeable fncts.io.Stream tapBoth
+ */
+export function tapBoth<E, A, R1, E1, R2, E2>(
+  f: (e: E) => IO<R1, E1, any>,
+  g: (a: A) => IO<R2, E2, any>,
+  __tsplusTrace?: string,
+) {
+  return <R>(self: Stream<R, E, A>): Stream<R | R1 | R2, E | E1 | E2, A> => {
+    return self.tapError(f).tap(g);
+  };
+}
+
+/**
+ * Returns a stream that effectfully "peeks" at the failure of the stream.
+ *
+ * @tsplus pipeable fncts.io.Stream tapError
+ */
+export function tapError<E, R1, E1>(f: (e: E) => IO<R1, E1, any>, __tsplusTrace?: string) {
+  return <R, A>(self: Stream<R, E, A>): Stream<R | R1, E | E1, A> => {
+    return self.catchAll((e) => Stream.fromIO(f(e)));
+  };
+}
+
+/**
+ * Returns a stream that effectfully "peeks" at the cause of failure of the
+ * stream.
+ *
+ * @tsplus pipeable fncts.io.Stream tapErrorCause
+ */
+export function tapErrorCause<E, R1, E1>(f: (cause: Cause<E>) => IO<R1, E1, any>, __tsplusTrace?: string) {
+  return <R, A>(self: Stream<R, E, A>): Stream<R | R1, E | E1, A> => {
+    return self.catchAllCause((e) => Stream.fromIO(f(e) > IO.refailCause(e)));
+  };
+}
+
+/**
+ * Sends all elements emitted by this stream to the specified sink in addition
+ * to emitting them.
+ *
+ * @tsplus pipeable fncts.io.Stream tapSink
+ */
+export function tapSink<A, R1, E1>(sink: Sink<R1, E1, A, any, any>, __tsplusTrace?: string) {
+  return <R, E>(self: Stream<R, E, A>): Stream<R | R1, E | E1, A> => {
+    return Stream.fromIO(Queue.makeBounded<Take<E | E1, A>>(1).zip(Future.make<never, void>())).flatMap(
+      ([queue, future]) => {
+        const right = Stream.fromQueue(queue, 1).flattenTake;
+        const loop: Channel<R | R1, E, Conc<A>, any, E1, Conc<A>, any> = Channel.readWithCause(
+          (chunk: Conc<A>) => Channel.fromIO(queue.offer(Take.chunk(chunk))) > Channel.writeNow(chunk) > loop,
+          (cause: Cause<E>) => Channel.fromIO(queue.offer(Take.failCause(cause))),
+          () => Channel.fromIO(queue.offer(Take.end)),
+        );
+        return new Stream((self.channel >>> loop).ensuring(queue.offer(Take.end).forkDaemon > future.await)).merge(
+          Stream.execute(right.run(sink).ensuring(future.succeed(undefined))),
+          "Both",
+        );
+      },
+    );
+  };
+}
+
 /**
  * Throttles the chunks of this stream according to the given bandwidth parameters using the token bucket
  * algorithm. Allows for burst in the processing of elements by allowing the token bucket to accumulate
@@ -2947,7 +3248,7 @@ export function toQueueOfElements(capacity = 2, __tsplusTrace?: string) {
   return <R, E, A>(stream: Stream<R, E, A>): IO<R | Scope, never, Queue.Dequeue<Exit<Maybe<E>, A>>> => {
     return Do((Δ) => {
       const queue = Δ(IO.acquireRelease(Queue.makeBounded<Exit<Maybe<E>, A>>(capacity), (_) => _.shutdown));
-      Δ(stream.runIntoElementsScoped(queue).fork);
+      Δ(stream.runIntoQueueElementsScoped(queue).forkScoped);
       return queue;
     });
   };

package/_src/Subject/Atomic.ts

@@ -1,4 +1,4 @@
-import type { Emitter} from "@fncts/io/Push/definition";
+import type { Emitter } from "@fncts/io/Push/definition";
 import type { Subject } from "@fncts/io/Subject/definition";
 
 import { Multicast, Push } from "@fncts/io/Push";

package/_src/global.ts

@@ -99,10 +99,6 @@ import { Random } from "@fncts/io/Random/definition";
  * @tsplus global
  */
 import { PRef, Ref } from "@fncts/io/Ref/definition";
-/**
- * @tsplus global
- */
-import { RuntimeConfig } from "@fncts/io/RuntimeConfig";
 /**
  * @tsplus global
  */

package/_src/index.ts

@@ -5,7 +5,6 @@ export type {} from "./Channel.js";
 export type {} from "./Clock.js";
 export type {} from "./Console.js";
 export type {} from "./CountdownLatch.js";
-export type {} from "./demo.js";
 export type {} from "./Fiber.js";
 export type {} from "./FiberDescriptor.js";
 export type {} from "./FiberRef.js";
@@ -22,18 +21,19 @@ export type {} from "./Layer.js";
 export type {} from "./Logger.js";
 export type {} from "./LogLevel.js";
 export type {} from "./LogSpan.js";
+export type {} from "./MVar.js";
 export type {} from "./Push.js";
 export type {} from "./Queue.js";
 export type {} from "./Random.js";
 export type {} from "./Ref.js";
 export type {} from "./RefSubject.js";
 export type {} from "./Reloadable.js";
-export type {} from "./RuntimeConfig.js";
 export type {} from "./RuntimeFlag.js";
 export type {} from "./RuntimeFlags.js";
 export type {} from "./Schedule.js";
 export type {} from "./Scope.js";
 export type {} from "./ScopedRef.js";
+export type {} from "./Semaphore.js";
 export type {} from "./Sink.js";
 export type {} from "./State.js";
 export type {} from "./STM.js";

package/global.d.ts

@@ -98,10 +98,6 @@ import { Random } from "@fncts/io/Random/definition";
  * @tsplus global
  */
 import { PRef, Ref } from "@fncts/io/Ref/definition";
-/**
- * @tsplus global
- */
-import { RuntimeConfig } from "@fncts/io/RuntimeConfig";
 /**
  * @tsplus global
  */

package/index.d.ts

@@ -4,7 +4,6 @@ export type {} from "./Channel.js";
 export type {} from "./Clock.js";
 export type {} from "./Console.js";
 export type {} from "./CountdownLatch.js";
-export type {} from "./demo.js";
 export type {} from "./Fiber.js";
 export type {} from "./FiberDescriptor.js";
 export type {} from "./FiberRef.js";
@@ -21,18 +20,19 @@ export type {} from "./Layer.js";
 export type {} from "./Logger.js";
 export type {} from "./LogLevel.js";
 export type {} from "./LogSpan.js";
+export type {} from "./MVar.js";
 export type {} from "./Push.js";
 export type {} from "./Queue.js";
 export type {} from "./Random.js";
 export type {} from "./Ref.js";
 export type {} from "./RefSubject.js";
 export type {} from "./Reloadable.js";
-export type {} from "./RuntimeConfig.js";
 export type {} from "./RuntimeFlag.js";
 export type {} from "./RuntimeFlags.js";
 export type {} from "./Schedule.js";
 export type {} from "./Scope.js";
 export type {} from "./ScopedRef.js";
+export type {} from "./Semaphore.js";
 export type {} from "./Sink.js";
 export type {} from "./State.js";
 export type {} from "./STM.js";

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@fncts/io",
-  "version": "0.0.31",
+  "version": "0.0.33",
   "dependencies": {
-    "@fncts/base": "0.0.26",
-    "@fncts/transformers": "0.0.4",
+    "@fncts/base": "0.0.28",
+    "@fncts/transformers": "0.0.5",
     "@fncts/typelevel": "0.0.15"
   },
   "exports": {

package/RuntimeConfig.d.ts

@@ -1,11 +0,0 @@
-import { CaseClass } from "@fncts/base/data/CaseClass";
-import { Cause } from "@fncts/base/data/Cause/definition";
-import { Supervisor } from "@fncts/io/Supervisor/definition";
-import { Logger } from "@fncts/io/Logger/definition";
-export declare class RuntimeConfig extends CaseClass<{
-    readonly reportFailure: (e: Cause<unknown>) => void;
-    readonly supervisor: Supervisor<any>;
-    readonly yieldOpCount: number;
-    readonly logger: Logger<string, any>;
-}> {
-}

package/_cjs/RuntimeConfig.cjs

@@ -1,12 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.RuntimeConfig = void 0;
-var tsplus_module_1 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/CaseClass"));
-function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
-function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
-class RuntimeConfig extends tsplus_module_1.CaseClass {}
-exports.RuntimeConfig = RuntimeConfig;
-//# sourceMappingURL=RuntimeConfig.cjs.map

package/_cjs/RuntimeConfig.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"RuntimeConfig.cjs","mappings":";;;;;;;;;AAAM,MAAOA,aAAc,SAAQC,yBAKjC;AAAG","names":["RuntimeConfig","tsplus_module_1"],"sourceRoot":"","sources":["../_src/RuntimeConfig.ts"],"sourcesContent":[null]}

package/_mjs/RuntimeConfig.mjs

@@ -1,3 +0,0 @@
-import * as tsplus_module_1 from "@fncts/base/data/CaseClass";
-export class RuntimeConfig extends tsplus_module_1.CaseClass {}
-//# sourceMappingURL=RuntimeConfig.mjs.map

package/_mjs/RuntimeConfig.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"RuntimeConfig.mjs","mappings":";AAAA,OAAM,MAAOA,aAAc,SAAQC,yBAKjC","names":["RuntimeConfig","tsplus_module_1"],"sourceRoot":"","sources":["../_src/RuntimeConfig.ts"],"sourcesContent":[null]}

package/_src/RuntimeConfig.ts

@@ -1,6 +0,0 @@
-export class RuntimeConfig extends CaseClass<{
-  readonly reportFailure: (e: Cause<unknown>) => void;
-  readonly supervisor: Supervisor<any>;
-  readonly yieldOpCount: number;
-  readonly logger: Logger<string, any>;
-}> {}