@typed/fx 1.17.4 → 1.18.0

package/src/Guard.ts

@@ -0,0 +1,159 @@
+/**
+ * @since 1.18.0
+ */
+
+import { Effect, Option } from "effect"
+import { dual } from "effect/Function"
+
+/**
+ * @since 1.18.0
+ */
+export type Guard<I, R, E, O> = (input: I) => Effect.Effect<R, E, Option.Option<O>>
+
+/**
+ * @since 1.18.0
+ */
+export namespace Guard {
+  /**
+   * @since 1.18.0
+   */
+  export type Input<T> = T extends Guard<infer I, infer _R, infer _E, infer _O> ? I : never
+  /**
+   * @since 1.18.0
+   */
+  export type Context<T> = T extends Guard<infer _I, infer R, infer _E, infer _O> ? R : never
+  /**
+   * @since 1.18.0
+   */
+  export type Error<T> = T extends Guard<infer _I, infer _R, infer E, infer _O> ? E : never
+  /**
+   * @since 1.18.0
+   */
+  export type Output<T> = T extends Guard<infer _I, infer _R, infer _E, infer O> ? O : never
+}
+
+/**
+ * @since 1.18.0
+ */
+export const compose: {
+  <O, R2, E2, B>(output: Guard<O, R2, E2, B>): <I, R, E>(input: Guard<I, R, E, O>) => Guard<I, R | R2, E | E2, B>
+  <I, R, E, O, R2, E2, B>(input: Guard<I, R, E, O>, output: Guard<O, R2, E2, B>): Guard<I, R | R2, E | E2, B>
+} = dual(2, function flatMap<I, R, E, O, R2, E2, B>(
+  input: Guard<I, R, E, O>,
+  output: Guard<O, R2, E2, B>
+): Guard<I, R | R2, E | E2, B> {
+  return (i) =>
+    Effect.flatMap(
+      input(i),
+      Option.match({
+        onNone: () => Effect.succeedNone,
+        onSome: output
+      })
+    )
+})
+
+/**
+ * @since 1.18.0
+ */
+export const mapEffect: {
+  <O, R2, E2, B>(
+    f: (o: O) => Effect.Effect<R2, E2, B>
+  ): <I, R, E>(guard: Guard<I, R, E, O>) => Guard<I, R | R2, E | E2, B>
+  <I, R, E, O, R2, E2, B>(guard: Guard<I, R, E, O>, f: (o: O) => Effect.Effect<R2, E2, B>): Guard<I, R | R2, E | E2, B>
+} = dual(2, function mapEffect<I, R, E, O, R2, E2, B>(
+  guard: Guard<I, R, E, O>,
+  f: (o: O) => Effect.Effect<R2, E2, B>
+): Guard<I, R | R2, E | E2, B> {
+  return compose(guard, (o) => Effect.asSome(f(o)))
+})
+
+/**
+ * @since 1.18.0
+ */
+export const map: {
+  <O, B>(f: (o: O) => B): <I, R, E>(guard: Guard<I, R, E, O>) => Guard<I, R, E, B>
+  <I, R, E, O, B>(guard: Guard<I, R, E, O>, f: (o: O) => B): Guard<I, R, E, B>
+} = dual(2, function map<I, R, E, O, B>(
+  guard: Guard<I, R, E, O>,
+  f: (o: O) => B
+): Guard<I, R, E, B> {
+  return mapEffect(guard, (o) => Effect.sync(() => f(o)))
+})
+
+/**
+ * @since 1.18.0
+ */
+export const tap: {
+  <O, R2, E2, B>(
+    f: (o: O) => Effect.Effect<R2, E2, B>
+  ): <I, R, E>(guard: Guard<I, R, E, O>) => Guard<I, R | R2, E | E2, O>
+  <I, R, E, O, R2, E2, B>(guard: Guard<I, R, E, O>, f: (o: O) => Effect.Effect<R2, E2, B>): Guard<I, R | R2, E | E2, O>
+} = dual(2, function tap<I, R, E, O, R2, E2, B>(
+  guard: Guard<I, R, E, O>,
+  f: (o: O) => Effect.Effect<R2, E2, B>
+): Guard<I, R | R2, E | E2, O> {
+  return compose(guard, (o) => Effect.as(f(o), Option.some(o)))
+})
+
+/**
+ * @since 1.18.0
+ */
+export const filterMap: {
+  <O, B>(f: (o: O) => Option.Option<B>): <I, R, E>(guard: Guard<I, R, E, O>) => Guard<I, R, E, B>
+  <I, R, E, O, B>(guard: Guard<I, R, E, O>, f: (o: O) => Option.Option<B>): Guard<I, R, E, B>
+} = dual(
+  2,
+  <I, R, E, O, B>(guard: Guard<I, R, E, O>, f: (o: O) => Option.Option<B>): Guard<I, R, E, B> => (i) =>
+    Effect.map(guard(i), Option.filterMap(f))
+)
+
+/**
+ * @since 1.18.0
+ */
+export const filter: {
+  <O, O2 extends O>(predicate: (o: O) => o is O2): <I, R, E>(guard: Guard<I, R, E, O>) => Guard<I, R, E, O2>
+  <O>(predicate: (o: O) => boolean): <I, R, E>(guard: Guard<I, R, E, O>) => Guard<I, R, E, O>
+  <I, R, E, O, O2 extends O>(guard: Guard<I, R, E, O>, predicate: (o: O) => o is O2): Guard<I, R, E, O2>
+  <I, R, E, O>(guard: Guard<I, R, E, O>, predicate: (o: O) => boolean): Guard<I, R, E, O>
+} = dual(
+  2,
+  <I, R, E, O>(guard: Guard<I, R, E, O>, predicate: (o: O) => boolean): Guard<I, R, E, O> => (i) =>
+    Effect.map(guard(i), Option.filter(predicate))
+)
+
+/**
+ * @since 1.18.0
+ */
+export function any<const GS extends Readonly<Record<string, Guard<any, any, any, any>>>>(
+  guards: GS
+): Guard<AnyInput<GS>, Guard.Context<GS[keyof GS]>, Guard.Context<GS[keyof GS]>, AnyOutput<GS>> {
+  const entries = Object.entries(guards)
+  return (i: AnyInput<GS>) =>
+    Effect.gen(function*(_) {
+      for (const [_tag, guard] of entries) {
+        const match = yield* _(guard(i))
+        if (Option.isSome(match)) {
+          return Option.some({ _tag, value: match.value } as AnyOutput<GS>)
+        }
+      }
+      return Option.none()
+    })
+}
+
+/**
+ * @since 1.18.0
+ */
+export type AnyInput<GS extends Readonly<Record<string, Guard<any, any, any, any>>>> = UnionToIntersection<
+  Guard.Input<GS[keyof GS]>
+>
+
+type UnionToIntersection<T> = (T extends any ? (x: T) => any : never) extends (x: infer R) => any ? R : never
+
+/**
+ * @since 1.18.0
+ */
+export type AnyOutput<GS extends Readonly<Record<string, Guard<any, any, any, any>>>> = [
+  {
+    [K in keyof GS]: { readonly _tag: K; readonly value: Guard.Output<GS[K]> }
+  }[keyof GS]
+] extends [infer R] ? R : never

package/src/Idle.ts

@@ -0,0 +1,284 @@
+/**
+ * Some Effect-based abstractions for utilizing requestIdleCallback to schedule work to be done when the event
+ * loops determines it is not busy with other higher-priority work.
+ * @since 1.18.0
+ */
+
+import type * as Context from "@typed/context"
+import { MutableHashMap, Option } from "effect"
+import * as Effect from "effect/Effect"
+import * as Fiber from "effect/Fiber"
+import { constant, constVoid } from "effect/Function"
+import { globalValue } from "effect/GlobalValue"
+import type { Hash } from "effect/Hash"
+import * as Layer from "effect/Layer"
+import type * as Queue from "effect/Queue"
+import * as Scheduler from "effect/Scheduler"
+import * as Scope from "effect/Scope"
+import { dequeueIsActive } from "./internal/fx"
+import { cancelIdleCallback, requestIdleCallback } from "./internal/requestIdleCallback"
+
+/**
+ * The IdleScheduler is an implementation of Effect's Scheduler interface, which utilizes a priority queue
+ * to order tasks to be run when the event loop is idle through the usage of requestIdleCallback.
+ *
+ * In the event requestIdleCallback is not available, setTimeout(task, 1) will be utilized as a fallback
+ * @since 1.18.0
+ * @category models
+ */
+export interface IdleScheduler extends Scheduler.Scheduler {
+  dispose(): void
+}
+
+class IdleSchedulerImpl implements IdleScheduler {
+  #id: number | undefined // ID for any requestIdleCallback calls
+  #running = false // If we currently have any schedule tasks to run
+  #tasks = new Scheduler.PriorityBuckets() // Priority queue of tasks that need to be run
+
+  constructor(readonly options?: IdleRequestOptions) {}
+
+  scheduleTask(task: Scheduler.Task, priority: number): void {
+    // Queue the task with the given priority
+    this.#tasks.scheduleTask(task, priority)
+
+    // If we're not running yet, schedule the next run
+    if (!this.#running) {
+      this.#running = true
+      this.scheduleNextRun()
+    }
+  }
+
+  shouldYield(fiber: Fiber.RuntimeFiber<unknown, unknown>): number | false {
+    return Scheduler.defaultShouldYield(fiber)
+  }
+
+  dispose() {
+    this.#running = false
+
+    if (this.#id === undefined) return
+
+    cancelIdleCallback(this.#id)
+    this.#id = undefined
+  }
+
+  private scheduleNextRun() {
+    this.#id = requestIdleCallback((deadline) => this.runTasks(deadline), this.options)
+  }
+
+  private runTasks(deadline: IdleDeadline) {
+    const buckets = this.#tasks.buckets
+    const length = buckets.length
+
+    let i = 0
+    for (; shouldContinue(deadline) && i < length; ++i) {
+      buckets[i][1].forEach((f) => f())
+    }
+
+    // Remove all the buckets we were able to complete
+    buckets.splice(0, i)
+
+    // If there are more tasks to run, schedule the next run
+    if (buckets.length > 0) {
+      this.scheduleNextRun()
+    } else {
+      // Otherwise we're done for now
+      this.#running = false
+      this.#id = undefined
+    }
+  }
+}
+
+/**
+ * Default instance of the IdleScheduler
+ * @since 1.18.0
+ * @category instances
+ */
+export const defaultIdleScheduler: IdleScheduler = globalValue(
+  Symbol("./Scheduler/Idle"),
+  () => new IdleSchedulerImpl()
+)
+
+/**
+ * Run an Effect using the IdleScheduler.
+ * @since 1.18.0
+ * @category combinators
+ */
+export const withIdleScheduler: <R, E, B>(self: Effect.Effect<R, E, B>) => Effect.Effect<R, E, B> = Effect
+  .withScheduler(defaultIdleScheduler)
+
+/**
+ * Provide the IdleScheduler using a Layer.
+ * @since 1.18.0
+ * @category layers
+ */
+export const setIdleScheduler: Layer.Layer<never, never, never> = Layer.setScheduler(defaultIdleScheduler)
+
+/**
+ * Request to run some work with requestIdleCallback returning an IdleDeadline
+ * @since 1.18.0
+ * @category scoped
+ */
+export const whenIdle = (options?: IdleRequestOptions): Effect.Effect<Scope.Scope, never, IdleDeadline> =>
+  Effect.asyncEffect((resume) => {
+    const id = requestIdleCallback((deadline) => resume(Effect.succeed(deadline)), options)
+
+    return Effect.addFinalizer(() => Effect.sync(() => cancelIdleCallback(id)))
+  })
+
+/**
+ * Check to see if an IdleDeadline timed out or has time remaining.
+ * @since 1.18.0
+ */
+export function shouldContinue(deadline: IdleDeadline): boolean {
+  return deadline.didTimeout === false && deadline.timeRemaining() > 0
+}
+
+/**
+ * The options provided to `whileIdle`
+ * @since 1.18.0
+ * @category params
+ */
+export interface WhileIdleRequestOptions<R, E, R2, E2> extends IdleRequestOptions {
+  readonly while: Effect.Effect<R, E, boolean>
+  readonly body: Effect.Effect<R2, E2, unknown>
+}
+
+/**
+ * Schedule a while-loop to run using requestIdleCallback.
+ * @since 1.18.0
+ */
+export const whileIdle = <R, E, R2, E2>(
+  options: WhileIdleRequestOptions<R, E, R2, E2>
+): Effect.Effect<Scope.Scope | R | R2, E | E2, void> =>
+  Effect.repeatWhileEffect(
+    Effect.flatMap(
+      whenIdle(options),
+      (deadline) =>
+        Effect.whileLoop({
+          while: () => shouldContinue(deadline),
+          body: constant(options.body),
+          step: constVoid
+        })
+    ),
+    constant(options.while)
+  )
+
+/**
+ * Dequeue values and perform an Effect while the event loop is not busy with any other work.
+ * @since 1.18.0
+ */
+export function dequeueWhileIdle<A, R2, E2, B>(
+  dequeue: Queue.Dequeue<A>,
+  f: (a: A) => Effect.Effect<R2, E2, B>,
+  options?: IdleRequestOptions
+): Effect.Effect<R2 | Scope.Scope, E2, void>
+
+export function dequeueWhileIdle<I, A, R2, E2, B>(
+  dequeue: Context.Dequeue<I, A>,
+  f: (a: A) => Effect.Effect<R2, E2, B>,
+  options?: IdleRequestOptions
+): Effect.Effect<I | R2 | Scope.Scope, E2, void>
+
+export function dequeueWhileIdle<I = never, A = unknown, R2 = never, E2 = never, B = unknown>(
+  dequeue: Context.Dequeue<I, A> | Queue.Dequeue<A>,
+  f: (a: A) => Effect.Effect<R2, E2, B>,
+  options?: IdleRequestOptions
+): Effect.Effect<I | R2 | Scope.Scope, E2, void>
+
+export function dequeueWhileIdle<I, A, R2, E2, B>(
+  dequeue: Context.Dequeue<I, A> | Queue.Dequeue<A>,
+  f: (a: A) => Effect.Effect<R2, E2, B>,
+  options?: IdleRequestOptions
+): Effect.Effect<I | R2 | Scope.Scope, E2, void> {
+  return whileIdle({
+    while: dequeueIsActive(dequeue),
+    body: Effect.flatMap(dequeue.take, f),
+    ...options
+  })
+}
+
+/**
+ * @since 1.18.0
+ */
+export interface IdleQueue<I extends Hash> {
+  readonly add: <R>(
+    part: I,
+    task: Effect.Effect<R, never, unknown>
+  ) => Effect.Effect<R | Scope.Scope, never, void>
+}
+
+/**
+ * @since 1.18.0
+ */
+export const makeIdleQueue = <I extends Hash>(
+  options?: IdleRequestOptions
+): Effect.Effect<Scope.Scope, never, IdleQueue<I>> =>
+  Effect.scopeWith((scope) => Effect.sync(() => new IdleQueueImpl<I>(scope, options)))
+
+class IdleQueueImpl<I extends Hash> implements IdleQueue<I> {
+  queue = MutableHashMap.empty<I, Effect.Effect<never, never, unknown>>()
+  scheduled = false
+
+  constructor(readonly scope: Scope.Scope, readonly options?: IdleRequestOptions) {}
+
+  add = <R>(part: I, task: Effect.Effect<R, never, unknown>) =>
+    Effect.contextWithEffect((ctx: Context.Context<R>) => {
+      const provided = Effect.provide(task, ctx)
+      MutableHashMap.set(this.queue, part, provided)
+
+      return Effect.zipRight(
+        Effect.addFinalizer(() =>
+          Effect.sync(() => {
+            const currentTask = MutableHashMap.get(this.queue, part)
+
+            // If the current task is still the same we'll delete it from the queue
+            if (Option.isSome(currentTask) && currentTask.value === provided) {
+              MutableHashMap.remove(this.queue, part)
+            }
+          })
+        ),
+        this.scheduleNextRun
+      )
+    })
+
+  scheduleNextRun = Effect.suspend(() => {
+    if (MutableHashMap.size(this.queue) === 0) return Effect.unit
+
+    this.scheduled = true
+
+    return Scope.addFinalizer(this.scope, Fiber.interrupt(Effect.runFork(this.run)))
+  })
+
+  run: Effect.Effect<never, never, void> = Effect.suspend(() =>
+    Effect.provideService(
+      Effect.flatMap(
+        whenIdle(this.options),
+        (deadline) =>
+          Effect.gen(this, function*(_) {
+            const iterator = this.queue[Symbol.iterator]()
+
+            while (shouldContinue(deadline)) {
+              const result = iterator.next()
+
+              if (result.done) break
+              else {
+                const [part, task] = result.value
+                MutableHashMap.remove(this.queue, part)
+                yield* _(task)
+              }
+            }
+
+            if (MutableHashMap.size(this.queue) > 0) {
+              return this.run
+            }
+
+            this.scheduled = false
+
+            return Effect.unit
+          })
+      ),
+      Scope.Scope,
+      this.scope
+    )
+  )
+}