@fncts/io 0.0.30 → 0.0.32

package/_src/Stream/api.ts

@@ -812,9 +812,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 +992,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,
@@ -1092,7 +1100,7 @@ export function distributedWithDynamic<E, A>(
       );
       const add = Δ(
         Do((Δ) => {
-          const queuesLock = Δ(TSemaphore.make(1).commit);
+          const queuesLock = Δ(Semaphore(1));
           const newQueue   = Δ(
             Ref.make<UIO<readonly [symbol, Queue<Exit<Maybe<E>, A>>]>>(
               Do((Δ) => {
@@ -2189,14 +2197,27 @@ 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),
+    );
+  };
+}
+
 /**
  * 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 +2264,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 +2387,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 +2633,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.
@@ -2947,7 +2998,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/SubscriptionRef.ts

@@ -6,7 +6,7 @@ export type SubscriptionRefTypeId = typeof SubscriptionRefTypeId;
 
 export class SubscriptionRefInternal<A> extends PSynchronizedInternal<never, never, never, never, A, A> {
   readonly [SubscriptionRefTypeId]: SubscriptionRefTypeId = SubscriptionRefTypeId;
-  constructor(readonly semaphore: TSemaphore, readonly hub: Hub<A>, readonly ref: Ref<A>) {
+  constructor(readonly semaphore: Semaphore, readonly hub: Hub<A>, readonly ref: Ref<A>) {
     super(semaphore, ref.get, (a) => ref.set(a));
   }
   changes: Stream<never, never, A> = Stream.unwrapScoped(
@@ -50,7 +50,7 @@ export function concrete<A>(_: SubscriptionRef<A>): asserts _ is SubscriptionRef
  */
 export function make<A>(value: Lazy<A>): UIO<SubscriptionRef<A>> {
   return Do((Δ) => {
-    const semaphore = Δ(TSemaphore.make(1).commit);
+    const semaphore = Δ(Semaphore(1));
     const hub       = Δ(Hub.makeUnbounded<A>());
     const ref       = Δ(Ref.make(value));
     return new SubscriptionRefInternal(semaphore, hub, ref);

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
  */
@@ -119,6 +115,10 @@ import { Finalizer } from "@fncts/io/Scope/Finalizer";
  * @tsplus global
  */
 import { ScopedRef } from "@fncts/io/ScopedRef/definition";
+/**
+ * @tsplus global
+ */
+import { Semaphore } from "@fncts/io/Semaphore";
 /**
  * @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/_src/internal/BackgroundScheduler.ts

@@ -0,0 +1,276 @@
+import type { Scheduler } from "@fncts/io/internal/Scheduler";
+
+interface IdleDeadline {
+  timeRemaining(): number;
+  readonly didTimeout: boolean;
+}
+
+declare const requestIdleCallback: ((callback: (deadline: IdleDeadline) => void) => number) | undefined;
+declare const cancelIdleCallback: ((handle: number | undefined) => void) | undefined;
+declare const requestAnimationFrame: ((callback: (time: number) => void) => void) | undefined;
+interface Navigator {
+  scheduling:
+    | {
+        isInputPending: (() => boolean) | undefined;
+      }
+    | undefined;
+}
+declare const navigator: Navigator;
+
+interface WhenReady<T> {
+  promise: () => Promise<T>;
+  resolve: (value: T) => void;
+}
+
+function whenReady<T>(): WhenReady<T> {
+  const observers: Array<(value: T) => void> = [];
+
+  const promise = () => new Promise<T>((resolve) => observers.push(resolve));
+
+  return {
+    promise,
+    resolve: (value) => observers.forEach((observer) => observer(value)),
+  };
+}
+
+interface Task {
+  ready: () => Promise<void>;
+  resolve: () => void;
+}
+
+interface State {
+  tasks: Array<Task>;
+  frameTimeElapsed: boolean;
+  onIdleCallback: WhenReady<void>;
+  onAnimationFrame: WhenReady<void>;
+  frameWorkStartTime: number | undefined;
+  idleDeadline: IdleDeadline | undefined;
+}
+
+export class BackgroundScheduler implements Scheduler {
+  state: State = {
+    tasks: [],
+    idleDeadline: undefined,
+    frameTimeElapsed: false,
+    onIdleCallback: whenReady(),
+    onAnimationFrame: whenReady(),
+    frameWorkStartTime: undefined,
+  };
+
+  isTracking = false;
+  idleCallbackId: number | undefined;
+  lastCallTime = 0;
+  lastResult   = false;
+  globalId     = 0;
+  running      = new Set<number>();
+  callbacks: Array<() => void> = [];
+  promiseEscapeId: number | undefined;
+
+  scheduleTask(task: () => void) {
+    this.yieldBackgroundOrContinue().then(() => {
+      task();
+    });
+  }
+
+  createTask(): Task {
+    const wr   = whenReady<void>();
+    const item = { ready: wr.promise, resolve: wr.resolve };
+    this.state.tasks.push(item);
+    if (this.state.tasks.length === 1) {
+      this.startTracking();
+    }
+    return item;
+  }
+
+  startTracking(): void {
+    if (this.isTracking) {
+      return;
+    }
+
+    this.isTracking = true;
+
+    const reset = () => {
+      this.state.idleDeadline       = undefined;
+      this.state.frameTimeElapsed   = false;
+      this.state.frameWorkStartTime = undefined;
+    };
+
+    const loop = () => {
+      if (typeof requestIdleCallback !== "undefined") {
+        this.idleCallbackId = requestIdleCallback((deadline) => {
+          reset();
+          this.state.idleDeadline = deadline;
+          this.state.onIdleCallback.resolve();
+          this.state.onIdleCallback = whenReady();
+        });
+      }
+
+      const cb = () => {
+        reset();
+        this.state.onAnimationFrame.resolve();
+        this.state.onAnimationFrame = whenReady();
+        if (this.state.tasks.length === 0) {
+          this.isTracking = false;
+          if (typeof cancelIdleCallback !== "undefined") {
+            cancelIdleCallback(this.idleCallbackId);
+          }
+        } else {
+          loop();
+        }
+      };
+
+      if (typeof requestAnimationFrame !== "undefined") {
+        requestAnimationFrame(cb);
+      } else {
+        setTimeout(cb, 0);
+      }
+    };
+
+    loop();
+  }
+
+  removeTask(task: Task) {
+    const index = this.state.tasks.indexOf(task);
+    if (index !== -1) {
+      this.state.tasks.splice(index, 1);
+    }
+  }
+
+  nextTask() {
+    if (this.state.tasks.length > 0) {
+      this.state.tasks[0]!.resolve();
+    }
+  }
+
+  isTimeToYield(): boolean {
+    const now = Date.now();
+
+    if (!this.lastResult && now - this.lastCallTime === 0) {
+      return this.lastResult;
+    }
+
+    this.lastCallTime = now;
+    this.lastResult =
+      now >= this.calculateDeadline() ||
+      (typeof navigator !== "undefined" && navigator.scheduling?.isInputPending?.() === true);
+
+    if (this.lastResult) {
+      this.state.frameTimeElapsed = true;
+    }
+
+    return this.lastResult;
+  }
+
+  calculateDeadline(): number {
+    if (this.state.frameWorkStartTime === undefined) {
+      return -1;
+    }
+
+    const idleDeadline =
+      this.state.idleDeadline === undefined
+        ? Number.MAX_SAFE_INTEGER
+        : Date.now() + this.state.idleDeadline.timeRemaining();
+
+    return Math.min(this.state.frameWorkStartTime + 5, idleDeadline);
+  }
+
+  requestPromiseEscape(callback: () => void): number {
+    const id = this.globalId;
+
+    this.running.add(id);
+
+    Promise.resolve().then(() => {
+      Promise.resolve().then(() => {
+        if (this.running.has(id)) {
+          callback();
+          this.running.delete(id);
+        }
+      });
+    });
+
+    this.globalId += 1;
+
+    return id;
+  }
+
+  cancelPromiseEscape(id: number | undefined): void {
+    if (id !== undefined) {
+      this.running.delete(id);
+    }
+  }
+
+  requestNextTask(callback: () => void): void {
+    if (this.callbacks.length === 0) {
+      const channel = new MessageChannel();
+      channel.port2.postMessage(undefined);
+      // @ts-expect-error
+      channel.port1.onmessage = (): void => {
+        channel.port1.close();
+        channel.port2.close();
+
+        const callbacksCopy = this.callbacks;
+        this.callbacks      = [];
+        for (const callback of callbacksCopy) {
+          callback();
+        }
+      };
+    }
+
+    this.callbacks.push(callback);
+  }
+
+  async yieldControl(): Promise<void> {
+    this.cancelPromiseEscape(this.promiseEscapeId);
+
+    const task = this.createTask();
+
+    await this.schedule();
+
+    if (this.state.tasks[0] !== task) {
+      await task.ready();
+      if (this.isTimeToYield()) {
+        await this.schedule();
+      }
+    }
+
+    this.removeTask(task);
+
+    this.cancelPromiseEscape(this.promiseEscapeId);
+
+    this.promiseEscapeId = this.requestPromiseEscape(() => {
+      this.nextTask();
+    });
+  }
+
+  async schedule(): Promise<void> {
+    if (this.state.frameTimeElapsed) {
+      await this.state.onAnimationFrame.promise();
+    }
+
+    if (typeof requestIdleCallback === "undefined") {
+      await new Promise<void>((resolve) => this.requestNextTask(resolve));
+
+      if (typeof navigator !== "undefined" && navigator.scheduling?.isInputPending?.() === true) {
+        await this.schedule();
+      } else if (this.state.frameWorkStartTime === undefined) {
+        this.state.frameWorkStartTime = Date.now();
+      }
+    } else {
+      await this.state.onIdleCallback.promise();
+
+      if (this.state.frameWorkStartTime === undefined) {
+        this.state.frameWorkStartTime = Date.now();
+      }
+    }
+  }
+
+  yieldBackgroundOrContinue(): Promise<void> {
+    if (this.isTimeToYield()) {
+      return this.yieldControl();
+    }
+
+    return Promise.resolve();
+  }
+}
+
+export const backgroundScheduler = new BackgroundScheduler();

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
  */
@@ -118,6 +114,10 @@ import { Finalizer } from "@fncts/io/Scope/Finalizer";
  * @tsplus global
  */
 import { ScopedRef } from "@fncts/io/ScopedRef/definition";
+/**
+ * @tsplus global
+ */
+import { Semaphore } from "@fncts/io/Semaphore";
 /**
  * @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/internal/BackgroundScheduler.d.ts

@@ -0,0 +1,47 @@
+import type { Scheduler } from "@fncts/io/internal/Scheduler";
+interface IdleDeadline {
+    timeRemaining(): number;
+    readonly didTimeout: boolean;
+}
+interface WhenReady<T> {
+    promise: () => Promise<T>;
+    resolve: (value: T) => void;
+}
+interface Task {
+    ready: () => Promise<void>;
+    resolve: () => void;
+}
+interface State {
+    tasks: Array<Task>;
+    frameTimeElapsed: boolean;
+    onIdleCallback: WhenReady<void>;
+    onAnimationFrame: WhenReady<void>;
+    frameWorkStartTime: number | undefined;
+    idleDeadline: IdleDeadline | undefined;
+}
+export declare class BackgroundScheduler implements Scheduler {
+    state: State;
+    isTracking: boolean;
+    idleCallbackId: number | undefined;
+    lastCallTime: number;
+    lastResult: boolean;
+    globalId: number;
+    running: Set<number>;
+    callbacks: Array<() => void>;
+    promiseEscapeId: number | undefined;
+    scheduleTask(task: () => void): void;
+    createTask(): Task;
+    startTracking(): void;
+    removeTask(task: Task): void;
+    nextTask(): void;
+    isTimeToYield(): boolean;
+    calculateDeadline(): number;
+    requestPromiseEscape(callback: () => void): number;
+    cancelPromiseEscape(id: number | undefined): void;
+    requestNextTask(callback: () => void): void;
+    yieldControl(): Promise<void>;
+    schedule(): Promise<void>;
+    yieldBackgroundOrContinue(): Promise<void>;
+}
+export declare const backgroundScheduler: BackgroundScheduler;
+export {};

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@fncts/io",
-  "version": "0.0.30",
+  "version": "0.0.32",
   "dependencies": {
-    "@fncts/base": "0.0.25",
-    "@fncts/transformers": "0.0.4",
+    "@fncts/base": "0.0.27",
+    "@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.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>;
-}> {}