@fncts/io 0.0.30 → 0.0.31

package/_src/Channel/api/mergeAllWith.ts

@@ -35,7 +35,7 @@ export function mergeAllWith<OutDone>(
           const cancelers    = Δ(IO.acquireRelease(Queue.makeUnbounded<Future<never, void>>(), (queue) => queue.shutdown));
           const lastDone     = Δ(Ref.make<Maybe<OutDone>>(Nothing()));
           const errorSignal  = Δ(Future.make<never, void>());
-          const permits      = Δ(TSemaphore.make(n).commit);
+          const permits      = Δ(Semaphore(n));
           const pull         = Δ(channels.toPull);
           const evaluatePull = (pull: IO<Env | Env1, OutErr | OutErr1, Either<OutDone, OutElem>>) =>
             pull

package/_src/IO/api/blocking.ts

@@ -0,0 +1,9 @@
+import { backgroundScheduler } from "@fncts/io/internal/BackgroundScheduler";
+
+/**
+ * @tsplus static fncts.io.IOOps blocking
+ * @tsplus getter fncts.io.IO blocking
+ */
+export function blocking<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A> {
+  return FiberRef.currentScheduler.locally(backgroundScheduler)(IO.yieldNow) > self;
+}

package/_src/IO.ts

@@ -13,6 +13,7 @@ export * from "./IO/api/addFinalizer.js";
 export * from "./IO/api/addFinalizerExit.js";
 export * from "./IO/api/asyncInterrupt.js";
 export * from "./IO/api/asyncIO.js";
+export * from "./IO/api/blocking.js";
 export * from "./IO/api/bracket.js";
 export * from "./IO/api/bracketExit.js";
 export * from "./IO/api/clockWith.js";

package/_src/Ref/Synchronized/constructors.ts

@@ -5,7 +5,7 @@ import { PSynchronizedInternal } from "./definition.js";
  */
 export function unsafeMakeSynchronized<A>(a: A, __tsplusTrace?: string): Ref.Synchronized<A> {
   const ref       = Ref.unsafeMake(a);
-  const semaphore = TSemaphore.unsafeMake(1);
+  const semaphore = Semaphore.unsafeMake(1);
   return new PSynchronizedInternal(semaphore, ref.get, (a: A) => ref.set(a));
 }
 
@@ -15,7 +15,7 @@ export function unsafeMakeSynchronized<A>(a: A, __tsplusTrace?: string): Ref.Syn
 export function makeSynchronized<A>(a: Lazy<A>, __tsplusTrace?: string): UIO<Ref.Synchronized<A>> {
   return Do((_) => {
     const ref       = _(Ref.make(a));
-    const semaphore = _(TSemaphore.make(1).commit);
+    const semaphore = _(Semaphore(1));
     return new PSynchronizedInternal(semaphore, ref.get, (a: A) => ref.set(a));
   });
 }

package/_src/Ref/Synchronized/definition.ts

@@ -30,7 +30,7 @@ export const Synchronized: PSynchronizedOps = {};
 export class PSynchronizedInternal<RA, RB, EA, EB, A, B> extends RefInternal<RA, RB, EA, EB, A, B> {
   readonly [SynchronizedTypeId]: SynchronizedTypeId = SynchronizedTypeId;
   constructor(
-    readonly semaphore: TSemaphore,
+    readonly semaphore: Semaphore,
     readonly unsafeGet: IO<RB, EB, B>,
     readonly unsafeSet: (a: A) => IO<RA, EA, void>,
   ) {

package/_src/Semaphore.ts

@@ -0,0 +1,81 @@
+/**
+ * @tsplus type fncts.io.Semaphore
+ * @tsplus companion fncts.io.SemaphoreOps
+ */
+export class Semaphore {
+  constructor(readonly permits: number) {}
+
+  taken   = 0;
+  waiters = new Set<() => void>();
+
+  get free(): number {
+    return this.permits - this.taken;
+  }
+
+  runNext() {
+    const next = this.waiters.values().next();
+    if (!next.done) {
+      this.waiters.delete(next.value);
+      next.value();
+    }
+  }
+
+  take(n: number) {
+    return IO.asyncInterrupt<never, never, number>((cb) => {
+      if (this.free < n) {
+        const observer = () => {
+          if (this.free >= n) {
+            this.waiters.delete(observer);
+            this.taken += n;
+            cb(IO.succeedNow(n));
+          }
+        };
+        this.waiters.add(observer);
+        return Either.left(
+          IO(() => {
+            this.waiters.delete(observer);
+          }),
+        );
+      }
+      this.taken += n;
+      return Either.right(IO.succeedNow(n));
+    });
+  }
+
+  release(n: number) {
+    return IO.withFiberRuntime<never, never, void>((fiber) => {
+      this.taken -= n;
+      fiber.getFiberRef(FiberRef.currentScheduler).scheduleTask(() => {
+        this.waiters.forEach((wake) => wake());
+      });
+      return IO.unit;
+    });
+  }
+
+  withPermits(permits: number) {
+    return <R, E, A>(io: IO<R, E, A>): IO<R, E, A> => {
+      return IO.uninterruptibleMask((restore) =>
+        restore(this.take(permits)).flatMap((permits) => restore(io).ensuring(this.release(permits))),
+      );
+    };
+  }
+
+  withPermit<R, E, A>(io: IO<R, E, A>): IO<R, E, A> {
+    return this.withPermits(1)(io);
+  }
+}
+
+/**
+ * @tsplus static fncts.io.SemaphoreOps unsafeMake
+ */
+export function unsafeMakeSemaphore(permits: number): Semaphore {
+  return new Semaphore(permits);
+}
+
+/**
+ * @tsplus static fncts.io.SemaphoreOps make
+ * @tsplus static fncts.io.SemaphoreOps __call
+ */
+export function makeSemaphore(permits: number, __tsplusTrace?: string): UIO<Semaphore> {
+  return IO(Semaphore.unsafeMake(permits));
+}

package/_src/Stream/api.ts

@@ -1092,7 +1092,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((Δ) => {

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

@@ -119,6 +119,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/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

@@ -118,6 +118,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/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,8 +1,8 @@
 {
   "name": "@fncts/io",
-  "version": "0.0.30",
+  "version": "0.0.31",
   "dependencies": {
-    "@fncts/base": "0.0.25",
+    "@fncts/base": "0.0.26",
     "@fncts/transformers": "0.0.4",
     "@fncts/typelevel": "0.0.15"
   },