@clayroach/effect 3.19.14-source-capture.8 → 3.19.14-source-trace.2

package/src/internal/string-utils.ts

@@ -0,0 +1,107 @@
+/**
+ * Adapted from the `change-case` library.
+ *
+ * Copyright (c) 2014 Blake Embrey (hello@blakeembrey.com)
+ */
+
+/** @internal */
+export const lowerCase = (str: string) => str.toLowerCase()
+
+/** @internal */
+export const upperCase = (str: string) => str.toUpperCase()
+
+interface Options {
+  splitRegexp?: RegExp | ReadonlyArray<RegExp>
+  stripRegexp?: RegExp | ReadonlyArray<RegExp>
+  delimiter?: string
+  transform?: (part: string, index: number, parts: ReadonlyArray<string>) => string
+}
+
+/**
+ * Replace `re` in the input string with the replacement value.
+ */
+const replace = (input: string, re: RegExp | ReadonlyArray<RegExp>, value: string): string =>
+  re instanceof RegExp
+    ? input.replace(re, value)
+    : re.reduce((input, re) => input.replace(re, value), input)
+
+// Support camel case ("camelCase" -> "camel Case" and "CAMELCase" -> "CAMEL Case").
+const DEFAULT_SPLIT_REGEXP = [/([a-z0-9])([A-Z])/g, /([A-Z])([A-Z][a-z])/g]
+
+// Remove all non-word characters.
+const DEFAULT_STRIP_REGEXP = /[^A-Z0-9]+/gi
+
+/**
+ * Normalize the string into something other libraries can manipulate easier.
+ */
+const noCase = (input: string, options: Options = {}): string => {
+  const {
+    delimiter = " ",
+    splitRegexp = DEFAULT_SPLIT_REGEXP,
+    stripRegexp = DEFAULT_STRIP_REGEXP,
+    transform = lowerCase
+  } = options
+  const result = replace(replace(input, splitRegexp, "$1\0$2"), stripRegexp, "\0")
+  let start = 0
+  let end = result.length
+  // Trim the delimiter from around the output string.
+  while (result.charAt(start) === "\0") {
+    start++
+  }
+  while (result.charAt(end - 1) === "\0") {
+    end--
+  }
+  // Transform each token independently.
+  return result.slice(start, end).split("\0").map(transform).join(delimiter)
+}
+
+const pascalCaseTransform = (input: string, index: number): string => {
+  const firstChar = input.charAt(0)
+  const lowerChars = input.substring(1).toLowerCase()
+  if (index > 0 && firstChar >= "0" && firstChar <= "9") {
+    return `_${firstChar}${lowerChars}`
+  }
+  return `${firstChar.toUpperCase()}${lowerChars}`
+}
+
+/** @internal */
+export const pascalCase = (input: string, options?: Options): string =>
+  noCase(input, {
+    delimiter: "",
+    transform: pascalCaseTransform,
+    ...options
+  })
+
+const camelCaseTransform = (input: string, index: number): string =>
+  index === 0
+    ? input.toLowerCase()
+    : pascalCaseTransform(input, index)
+
+/** @internal */
+export const camelCase = (input: string, options?: Options): string =>
+  pascalCase(input, {
+    transform: camelCaseTransform,
+    ...options
+  })
+
+/** @internal */
+export const constantCase = (input: string, options?: Options): string =>
+  noCase(input, {
+    delimiter: "_",
+    transform: upperCase,
+    ...options
+  })
+
+/** @internal */
+export const kebabCase = (input: string, options?: Options) =>
+  noCase(input, {
+    delimiter: "-",
+    ...options
+  })
+
+/** @internal */
+export const snakeCase = (input: string, options?: Options) =>
+  noCase(input, {
+    delimiter: "_",
+    ...options
+  })

package/src/internal/subscriptionRef.ts

@@ -0,0 +1,138 @@
+import * as Effect from "../Effect.js"
+import * as Effectable from "../Effectable.js"
+import { dual, pipe } from "../Function.js"
+import * as PubSub from "../PubSub.js"
+import * as Readable from "../Readable.js"
+import * as Ref from "../Ref.js"
+import type { Stream } from "../Stream.js"
+import * as Subscribable from "../Subscribable.js"
+import type * as SubscriptionRef from "../SubscriptionRef.js"
+import * as Synchronized from "../SynchronizedRef.js"
+import * as circular_ from "./effect/circular.js"
+import * as ref_ from "./ref.js"
+import * as stream from "./stream.js"
+
+/** @internal */
+const SubscriptionRefSymbolKey = "effect/SubscriptionRef"
+
+/** @internal */
+export const SubscriptionRefTypeId: SubscriptionRef.SubscriptionRefTypeId = Symbol.for(
+  SubscriptionRefSymbolKey
+) as SubscriptionRef.SubscriptionRefTypeId
+
+const subscriptionRefVariance = {
+  /* c8 ignore next */
+  _A: (_: any) => _
+}
+
+/** @internal */
+class SubscriptionRefImpl<in out A> extends Effectable.Class<A> implements SubscriptionRef.SubscriptionRef<A> {
+  readonly [Readable.TypeId]: Readable.TypeId = Readable.TypeId
+  readonly [Subscribable.TypeId]: Subscribable.TypeId = Subscribable.TypeId
+  readonly [Ref.RefTypeId] = ref_.refVariance
+  readonly [Synchronized.SynchronizedRefTypeId] = circular_.synchronizedVariance
+  readonly [SubscriptionRefTypeId] = subscriptionRefVariance
+  constructor(
+    readonly ref: Ref.Ref<A>,
+    readonly pubsub: PubSub.PubSub<A>,
+    readonly semaphore: Effect.Semaphore
+  ) {
+    super()
+    this.get = Ref.get(this.ref)
+  }
+  commit() {
+    return this.get
+  }
+  readonly get: Effect.Effect<A>
+  get changes(): Stream<A> {
+    return pipe(
+      Ref.get(this.ref),
+      Effect.flatMap((a) =>
+        Effect.map(
+          stream.fromPubSub(this.pubsub, { scoped: true }),
+          (s) =>
+            stream.concat(
+              stream.make(a),
+              s
+            )
+        )
+      ),
+      this.semaphore.withPermits(1),
+      stream.unwrapScoped
+    )
+  }
+  modify<B>(f: (a: A) => readonly [B, A]): Effect.Effect<B> {
+    return this.modifyEffect((a) => Effect.succeed(f(a)))
+  }
+  modifyEffect<B, E, R>(f: (a: A) => Effect.Effect<readonly [B, A], E, R>): Effect.Effect<B, E, R> {
+    return pipe(
+      Ref.get(this.ref),
+      Effect.flatMap(f),
+      Effect.flatMap(([b, a]) =>
+        pipe(
+          Ref.set(this.ref, a),
+          Effect.as(b),
+          Effect.zipLeft(PubSub.publish(this.pubsub, a))
+        )
+      ),
+      this.semaphore.withPermits(1)
+    )
+  }
+}
+
+/** @internal */
+export const get = <A>(self: SubscriptionRef.SubscriptionRef<A>): Effect.Effect<A> => Ref.get(self.ref)
+
+/** @internal */
+export const make = <A>(value: A): Effect.Effect<SubscriptionRef.SubscriptionRef<A>> =>
+  pipe(
+    Effect.all([
+      PubSub.unbounded<A>(),
+      Ref.make(value),
+      Effect.makeSemaphore(1)
+    ]),
+    Effect.map(([pubsub, ref, semaphore]) => new SubscriptionRefImpl(ref, pubsub, semaphore))
+  )
+
+/** @internal */
+export const modify = dual<
+  <A, B>(f: (a: A) => readonly [B, A]) => (self: SubscriptionRef.SubscriptionRef<A>) => Effect.Effect<B>,
+  <A, B>(
+    self: SubscriptionRef.SubscriptionRef<A>,
+    f: (a: A) => readonly [B, A]
+  ) => Effect.Effect<B>
+>(2, <A, B>(
+  self: SubscriptionRef.SubscriptionRef<A>,
+  f: (a: A) => readonly [B, A]
+): Effect.Effect<B> => self.modify(f))
+
+/** @internal */
+export const modifyEffect = dual<
+  <B, A, E, R>(
+    f: (a: A) => Effect.Effect<readonly [B, A], E, R>
+  ) => (self: SubscriptionRef.SubscriptionRef<A>) => Effect.Effect<B, E, R>,
+  <A, B, E, R>(
+    self: SubscriptionRef.SubscriptionRef<A>,
+    f: (a: A) => Effect.Effect<readonly [B, A], E, R>
+  ) => Effect.Effect<B, E, R>
+>(2, <A, B, E, R>(
+  self: SubscriptionRef.SubscriptionRef<A>,
+  f: (a: A) => Effect.Effect<readonly [B, A], E, R>
+): Effect.Effect<B, E, R> => self.modifyEffect(f))
+
+/** @internal */
+export const set = dual<
+  <A>(value: A) => (self: SubscriptionRef.SubscriptionRef<A>) => Effect.Effect<void>,
+  <A>(
+    self: SubscriptionRef.SubscriptionRef<A>,
+    value: A
+  ) => Effect.Effect<void>
+>(2, <A>(
+  self: SubscriptionRef.SubscriptionRef<A>,
+  value: A
+): Effect.Effect<void> =>
+  pipe(
+    Ref.set(self.ref, value),
+    Effect.zipLeft(PubSub.publish(self.pubsub, value)),
+    self.semaphore.withPermits(1)
+  ))

package/src/internal/supervisor/patch.ts

@@ -0,0 +1,190 @@
+import * as Chunk from "../../Chunk.js"
+import * as Differ from "../../Differ.js"
+import * as Equal from "../../Equal.js"
+import { pipe } from "../../Function.js"
+import * as HashSet from "../../HashSet.js"
+import type * as Supervisor from "../../Supervisor.js"
+import * as supervisor from "../supervisor.js"
+
+/** @internal */
+export type SupervisorPatch = Empty | AddSupervisor | RemoveSupervisor | AndThen
+
+/** @internal */
+export const OP_EMPTY = "Empty" as const
+
+/** @internal */
+export type OP_EMPTY = typeof OP_EMPTY
+
+/** @internal */
+export const OP_ADD_SUPERVISOR = "AddSupervisor" as const
+
+/** @internal */
+export type OP_ADD_SUPERVISOR = typeof OP_ADD_SUPERVISOR
+
+/** @internal */
+export const OP_REMOVE_SUPERVISOR = "RemoveSupervisor" as const
+
+/** @internal */
+export type OP_REMOVE_SUPERVISOR = typeof OP_REMOVE_SUPERVISOR
+
+/** @internal */
+export const OP_AND_THEN = "AndThen" as const
+
+/** @internal */
+export type OP_AND_THEN = typeof OP_AND_THEN
+
+/** @internal */
+export interface Empty {
+  readonly _tag: OP_EMPTY
+}
+
+/** @internal */
+export interface AddSupervisor {
+  readonly _tag: OP_ADD_SUPERVISOR
+  readonly supervisor: Supervisor.Supervisor<any>
+}
+
+/** @internal */
+export interface RemoveSupervisor {
+  readonly _tag: OP_REMOVE_SUPERVISOR
+  readonly supervisor: Supervisor.Supervisor<any>
+}
+
+/** @internal */
+export interface AndThen {
+  readonly _tag: OP_AND_THEN
+  readonly first: SupervisorPatch
+  readonly second: SupervisorPatch
+}
+
+/**
+ * The empty `SupervisorPatch`.
+ *
+ * @internal
+ */
+export const empty: SupervisorPatch = { _tag: OP_EMPTY }
+
+/**
+ * Combines two patches to produce a new patch that describes applying the
+ * updates from this patch and then the updates from the specified patch.
+ *
+ * @internal
+ */
+export const combine = (self: SupervisorPatch, that: SupervisorPatch): SupervisorPatch => {
+  return {
+    _tag: OP_AND_THEN,
+    first: self,
+    second: that
+  }
+}
+
+/**
+ * Applies a `SupervisorPatch` to a `Supervisor` to produce a new `Supervisor`.
+ *
+ * @internal
+ */
+export const patch = (
+  self: SupervisorPatch,
+  supervisor: Supervisor.Supervisor<any>
+): Supervisor.Supervisor<any> => {
+  return patchLoop(supervisor, Chunk.of(self))
+}
+
+/** @internal */
+const patchLoop = (
+  _supervisor: Supervisor.Supervisor<any>,
+  _patches: Chunk.Chunk<SupervisorPatch>
+): Supervisor.Supervisor<any> => {
+  let supervisor = _supervisor
+  let patches = _patches
+  while (Chunk.isNonEmpty(patches)) {
+    const head = Chunk.headNonEmpty(patches)
+    switch (head._tag) {
+      case OP_EMPTY: {
+        patches = Chunk.tailNonEmpty(patches)
+        break
+      }
+      case OP_ADD_SUPERVISOR: {
+        supervisor = supervisor.zip(head.supervisor)
+        patches = Chunk.tailNonEmpty(patches)
+        break
+      }
+      case OP_REMOVE_SUPERVISOR: {
+        supervisor = removeSupervisor(supervisor, head.supervisor)
+        patches = Chunk.tailNonEmpty(patches)
+        break
+      }
+      case OP_AND_THEN: {
+        patches = Chunk.prepend(head.first)(Chunk.prepend(head.second)(Chunk.tailNonEmpty(patches)))
+        break
+      }
+    }
+  }
+  return supervisor
+}
+
+/** @internal */
+const removeSupervisor = (
+  self: Supervisor.Supervisor<any>,
+  that: Supervisor.Supervisor<any>
+): Supervisor.Supervisor<any> => {
+  if (Equal.equals(self, that)) {
+    return supervisor.none
+  } else {
+    if (supervisor.isZip(self)) {
+      return removeSupervisor(self.left, that).zip(removeSupervisor(self.right, that))
+    } else {
+      return self
+    }
+  }
+}
+
+/** @internal */
+const toSet = (self: Supervisor.Supervisor<any>): HashSet.HashSet<Supervisor.Supervisor<any>> => {
+  if (Equal.equals(self, supervisor.none)) {
+    return HashSet.empty()
+  } else {
+    if (supervisor.isZip(self)) {
+      return pipe(toSet(self.left), HashSet.union(toSet(self.right)))
+    } else {
+      return HashSet.make(self)
+    }
+  }
+}
+
+/** @internal */
+export const diff = (
+  oldValue: Supervisor.Supervisor<any>,
+  newValue: Supervisor.Supervisor<any>
+): SupervisorPatch => {
+  if (Equal.equals(oldValue, newValue)) {
+    return empty
+  }
+  const oldSupervisors = toSet(oldValue)
+  const newSupervisors = toSet(newValue)
+  const added = pipe(
+    newSupervisors,
+    HashSet.difference(oldSupervisors),
+    HashSet.reduce(
+      empty as SupervisorPatch,
+      (patch, supervisor) => combine(patch, { _tag: OP_ADD_SUPERVISOR, supervisor })
+    )
+  )
+  const removed = pipe(
+    oldSupervisors,
+    HashSet.difference(newSupervisors),
+    HashSet.reduce(
+      empty as SupervisorPatch,
+      (patch, supervisor) => combine(patch, { _tag: OP_REMOVE_SUPERVISOR, supervisor })
+    )
+  )
+  return combine(added, removed)
+}
+
+/** @internal */
+export const differ = Differ.make<Supervisor.Supervisor<any>, SupervisorPatch>({
+  empty,
+  patch,
+  combine,
+  diff
+})