@clayroach/effect 3.19.14-source-capture.6 → 3.19.14-source-capture.8

package/src/internal/string-utils.ts

@@ -1,107 +0,0 @@
-/**
- * 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

@@ -1,138 +0,0 @@
-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

@@ -1,190 +0,0 @@
-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
-})