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

package/src/internal/console.ts

@@ -1,153 +0,0 @@
-import type * as Console from "../Console.js"
-import * as Context from "../Context.js"
-import type * as Effect from "../Effect.js"
-import { dual } from "../Function.js"
-import type * as Layer from "../Layer.js"
-import type * as Scope from "../Scope.js"
-import * as core from "./core.js"
-import * as defaultServices from "./defaultServices.js"
-import * as defaultConsole from "./defaultServices/console.js"
-import * as fiberRuntime from "./fiberRuntime.js"
-import * as layer from "./layer.js"
-
-/** @internal */
-export const console: Effect.Effect<Console.Console> = core.map(
-  core.fiberRefGet(defaultServices.currentServices),
-  Context.get(defaultConsole.consoleTag)
-)
-
-/** @internal */
-export const consoleWith = <A, E, R>(f: (console: Console.Console) => Effect.Effect<A, E, R>) =>
-  core.fiberRefGetWith(
-    defaultServices.currentServices,
-    (services) => f(Context.get(services, defaultConsole.consoleTag))
-  )
-
-/** @internal */
-export const withConsole = dual<
-  <C extends Console.Console>(console: C) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
-  <A, E, R, C extends Console.Console>(effect: Effect.Effect<A, E, R>, console: C) => Effect.Effect<A, E, R>
->(2, (effect, value) =>
-  core.fiberRefLocallyWith(
-    effect,
-    defaultServices.currentServices,
-    Context.add(defaultConsole.consoleTag, value)
-  ))
-
-/** @internal */
-export const withConsoleScoped = <A extends Console.Console>(console: A): Effect.Effect<void, never, Scope.Scope> =>
-  fiberRuntime.fiberRefLocallyScopedWith(
-    defaultServices.currentServices,
-    Context.add(defaultConsole.consoleTag, console)
-  )
-
-/** @internal */
-export const setConsole = <A extends Console.Console>(console: A): Layer.Layer<never> =>
-  layer.scopedDiscard(
-    fiberRuntime.fiberRefLocallyScopedWith(
-      defaultServices.currentServices,
-      Context.add(defaultConsole.consoleTag, console)
-    )
-  )
-
-/** @internal */
-export const assert = (condition: boolean, ...args: ReadonlyArray<any>) =>
-  consoleWith((_) => _.assert(condition, ...args))
-
-/** @internal */
-export const clear = consoleWith((_) => _.clear)
-
-/** @internal */
-export const count = (label?: string) => consoleWith((_) => _.count(label))
-
-/** @internal */
-export const countReset = (label?: string) => consoleWith((_) => _.countReset(label))
-
-/** @internal */
-export const debug = (...args: ReadonlyArray<any>) => consoleWith((_) => _.debug(...args))
-
-/** @internal */
-export const dir = (item: any, options?: any) => consoleWith((_) => _.dir(item, options))
-
-/** @internal */
-export const dirxml = (...args: ReadonlyArray<any>) => consoleWith((_) => _.dirxml(...args))
-
-/** @internal */
-export const error = (...args: ReadonlyArray<any>) => consoleWith((_) => _.error(...args))
-
-/** @internal */
-export const group = (options?: {
-  label?: string | undefined
-  collapsed?: boolean | undefined
-}) =>
-  consoleWith((_) =>
-    fiberRuntime.acquireRelease(
-      _.group(options),
-      () => _.groupEnd
-    )
-  )
-
-/** @internal */
-export const info = (...args: ReadonlyArray<any>) => consoleWith((_) => _.info(...args))
-
-/** @internal */
-export const log = (...args: ReadonlyArray<any>) => consoleWith((_) => _.log(...args))
-
-/** @internal */
-export const table = (tabularData: any, properties?: ReadonlyArray<string>) =>
-  consoleWith((_) => _.table(tabularData, properties))
-
-/** @internal */
-export const time = (label?: string) =>
-  consoleWith((_) =>
-    fiberRuntime.acquireRelease(
-      _.time(label),
-      () => _.timeEnd(label)
-    )
-  )
-
-/** @internal */
-export const timeLog = (label?: string, ...args: ReadonlyArray<any>) => consoleWith((_) => _.timeLog(label, ...args))
-
-/** @internal */
-export const trace = (...args: ReadonlyArray<any>) => consoleWith((_) => _.trace(...args))
-
-/** @internal */
-export const warn = (...args: ReadonlyArray<any>) => consoleWith((_) => _.warn(...args))
-
-/** @internal */
-export const withGroup = dual<
-  (
-    options?: {
-      readonly label?: string | undefined
-      readonly collapsed?: boolean | undefined
-    }
-  ) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
-  <A, E, R>(
-    self: Effect.Effect<A, E, R>,
-    options?: {
-      readonly label?: string | undefined
-      readonly collapsed?: boolean | undefined
-    }
-  ) => Effect.Effect<A, E, R>
->((args) => core.isEffect(args[0]), (self, options) =>
-  consoleWith((_) =>
-    core.acquireUseRelease(
-      _.group(options),
-      () => self,
-      () => _.groupEnd
-    )
-  ))
-
-/** @internal */
-export const withTime = dual<
-  (label?: string) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
-  <A, E, R>(self: Effect.Effect<A, E, R>, label?: string) => Effect.Effect<A, E, R>
->((args) => core.isEffect(args[0]), (self, label) =>
-  consoleWith((_) =>
-    core.acquireUseRelease(
-      _.time(label),
-      () => self,
-      () => _.timeEnd(label)
-    )
-  ))

package/src/internal/context.ts

@@ -1,337 +0,0 @@
-import type * as C from "../Context.js"
-import * as Equal from "../Equal.js"
-import type { LazyArg } from "../Function.js"
-import { dual } from "../Function.js"
-import { globalValue } from "../GlobalValue.js"
-import * as Hash from "../Hash.js"
-import { format, NodeInspectSymbol, toJSON } from "../Inspectable.js"
-import type * as O from "../Option.js"
-import { pipeArguments } from "../Pipeable.js"
-import { hasProperty } from "../Predicate.js"
-import type * as STM from "../STM.js"
-import type { NoInfer } from "../Types.js"
-import { EffectPrototype, effectVariance } from "./effectable.js"
-import * as option from "./option.js"
-
-/** @internal */
-export const TagTypeId: C.TagTypeId = Symbol.for("effect/Context/Tag") as C.TagTypeId
-
-/** @internal */
-export const ReferenceTypeId: C.ReferenceTypeId = Symbol.for("effect/Context/Reference") as C.ReferenceTypeId
-
-/** @internal */
-const STMSymbolKey = "effect/STM"
-
-/** @internal */
-export const STMTypeId: STM.STMTypeId = Symbol.for(
-  STMSymbolKey
-) as STM.STMTypeId
-
-/** @internal */
-export const TagProto: any = {
-  ...EffectPrototype,
-  _op: "Tag",
-  [STMTypeId]: effectVariance,
-  [TagTypeId]: {
-    _Service: (_: unknown) => _,
-    _Identifier: (_: unknown) => _
-  },
-  toString() {
-    return format(this.toJSON())
-  },
-  toJSON<I, A>(this: C.Tag<I, A>) {
-    return {
-      _id: "Tag",
-      key: this.key,
-      stack: this.stack
-    }
-  },
-  [NodeInspectSymbol]() {
-    return this.toJSON()
-  },
-  of<Service>(self: Service): Service {
-    return self
-  },
-  context<Identifier, Service>(
-    this: C.Tag<Identifier, Service>,
-    self: Service
-  ): C.Context<Identifier> {
-    return make(this, self)
-  }
-}
-
-export const ReferenceProto: any = {
-  ...TagProto,
-  [ReferenceTypeId]: ReferenceTypeId
-}
-
-/** @internal */
-export const makeGenericTag = <Identifier, Service = Identifier>(key: string): C.Tag<Identifier, Service> => {
-  const limit = Error.stackTraceLimit
-  Error.stackTraceLimit = 2
-  const creationError = new Error()
-  Error.stackTraceLimit = limit
-  const tag = Object.create(TagProto)
-  Object.defineProperty(tag, "stack", {
-    get() {
-      return creationError.stack
-    }
-  })
-  tag.key = key
-  return tag
-}
-
-/** @internal */
-export const Tag = <const Id extends string>(id: Id) => <Self, Shape>(): C.TagClass<Self, Id, Shape> => {
-  const limit = Error.stackTraceLimit
-  Error.stackTraceLimit = 2
-  const creationError = new Error()
-  Error.stackTraceLimit = limit
-
-  function TagClass() {}
-  Object.setPrototypeOf(TagClass, TagProto)
-  TagClass.key = id
-  Object.defineProperty(TagClass, "stack", {
-    get() {
-      return creationError.stack
-    }
-  })
-  return TagClass as any
-}
-
-/** @internal */
-export const Reference = <Self>() =>
-<const Id extends string, Service>(id: Id, options: {
-  readonly defaultValue: () => Service
-}): C.ReferenceClass<Self, Id, Service> => {
-  const limit = Error.stackTraceLimit
-  Error.stackTraceLimit = 2
-  const creationError = new Error()
-  Error.stackTraceLimit = limit
-
-  function ReferenceClass() {}
-  Object.setPrototypeOf(ReferenceClass, ReferenceProto)
-  ReferenceClass.key = id
-  ReferenceClass.defaultValue = options.defaultValue
-  Object.defineProperty(ReferenceClass, "stack", {
-    get() {
-      return creationError.stack
-    }
-  })
-  return ReferenceClass as any
-}
-
-/** @internal */
-export const TypeId: C.TypeId = Symbol.for("effect/Context") as C.TypeId
-
-/** @internal */
-export const ContextProto: Omit<C.Context<unknown>, "unsafeMap"> = {
-  [TypeId]: {
-    _Services: (_: unknown) => _
-  },
-  [Equal.symbol]<A>(this: C.Context<A>, that: unknown): boolean {
-    if (isContext(that)) {
-      if (this.unsafeMap.size === that.unsafeMap.size) {
-        for (const k of this.unsafeMap.keys()) {
-          if (!that.unsafeMap.has(k) || !Equal.equals(this.unsafeMap.get(k), that.unsafeMap.get(k))) {
-            return false
-          }
-        }
-        return true
-      }
-    }
-    return false
-  },
-  [Hash.symbol]<A>(this: C.Context<A>): number {
-    return Hash.cached(this, Hash.number(this.unsafeMap.size))
-  },
-  pipe<A>(this: C.Context<A>) {
-    return pipeArguments(this, arguments)
-  },
-  toString() {
-    return format(this.toJSON())
-  },
-  toJSON<A>(this: C.Context<A>) {
-    return {
-      _id: "Context",
-      services: Array.from(this.unsafeMap).map(toJSON)
-    }
-  },
-  [NodeInspectSymbol]() {
-    return (this as any).toJSON()
-  }
-}
-
-/** @internal */
-export const makeContext = <Services>(unsafeMap: Map<string, any>): C.Context<Services> => {
-  const context = Object.create(ContextProto)
-  context.unsafeMap = unsafeMap
-  return context
-}
-
-const serviceNotFoundError = (tag: C.Tag<any, any>) => {
-  const error = new Error(`Service not found${tag.key ? `: ${String(tag.key)}` : ""}`)
-  if (tag.stack) {
-    const lines = tag.stack.split("\n")
-    if (lines.length > 2) {
-      const afterAt = lines[2].match(/at (.*)/)
-      if (afterAt) {
-        error.message = error.message + ` (defined at ${afterAt[1]})`
-      }
-    }
-  }
-  if (error.stack) {
-    const lines = error.stack.split("\n")
-    lines.splice(1, 3)
-    error.stack = lines.join("\n")
-  }
-  return error
-}
-
-/** @internal */
-export const isContext = (u: unknown): u is C.Context<never> => hasProperty(u, TypeId)
-
-/** @internal */
-export const isTag = (u: unknown): u is C.Tag<any, any> => hasProperty(u, TagTypeId)
-
-/** @internal */
-export const isReference = (u: unknown): u is C.Reference<any, any> => hasProperty(u, ReferenceTypeId)
-
-const _empty = makeContext(new Map())
-
-/** @internal */
-export const empty = (): C.Context<never> => _empty
-
-/** @internal */
-export const make = <I, S>(tag: C.Tag<I, S>, service: NoInfer<S>): C.Context<I> =>
-  makeContext(new Map([[tag.key, service]]))
-
-/** @internal */
-export const add = dual<
-  <I, S>(
-    tag: C.Tag<I, S>,
-    service: NoInfer<S>
-  ) => <Services>(
-    self: C.Context<Services>
-  ) => C.Context<Services | I>,
-  <Services, I, S>(
-    self: C.Context<Services>,
-    tag: C.Tag<I, S>,
-    service: NoInfer<S>
-  ) => C.Context<Services | I>
->(3, (self, tag, service) => {
-  const map = new Map(self.unsafeMap)
-  map.set(tag.key, service)
-  return makeContext(map)
-})
-
-const defaultValueCache = globalValue("effect/Context/defaultValueCache", () => new Map<string, any>())
-const getDefaultValue = (tag: C.Reference<any, any>) => {
-  if (defaultValueCache.has(tag.key)) {
-    return defaultValueCache.get(tag.key)
-  }
-  const value = tag.defaultValue()
-  defaultValueCache.set(tag.key, value)
-  return value
-}
-
-/** @internal */
-export const unsafeGetReference = <Services, I, S>(self: C.Context<Services>, tag: C.Reference<I, S>): S => {
-  return self.unsafeMap.has(tag.key) ? self.unsafeMap.get(tag.key) : getDefaultValue(tag)
-}
-
-/** @internal */
-export const unsafeGet = dual<
-  <S, I>(tag: C.Tag<I, S>) => <Services>(self: C.Context<Services>) => S,
-  <Services, S, I>(self: C.Context<Services>, tag: C.Tag<I, S>) => S
->(2, (self, tag) => {
-  if (!self.unsafeMap.has(tag.key)) {
-    if (ReferenceTypeId in tag) return getDefaultValue(tag as any)
-    throw serviceNotFoundError(tag)
-  }
-  return self.unsafeMap.get(tag.key)! as any
-})
-
-/** @internal */
-export const get: {
-  <I, S>(tag: C.Reference<I, S>): <Services>(self: C.Context<Services>) => S
-  <Services, I extends Services, S>(tag: C.Tag<I, S>): (self: C.Context<Services>) => S
-  <Services, I, S>(self: C.Context<Services>, tag: C.Reference<I, S>): S
-  <Services, I extends Services, S>(self: C.Context<Services>, tag: C.Tag<I, S>): S
-} = unsafeGet as any
-
-/** @internal */
-export const getOrElse = dual<
-  <S, I, B>(tag: C.Tag<I, S>, orElse: LazyArg<B>) => <Services>(self: C.Context<Services>) => S | B,
-  <Services, S, I, B>(self: C.Context<Services>, tag: C.Tag<I, S>, orElse: LazyArg<B>) => S | B
->(3, (self, tag, orElse) => {
-  if (!self.unsafeMap.has(tag.key)) {
-    return isReference(tag) ? getDefaultValue(tag) : orElse()
-  }
-  return self.unsafeMap.get(tag.key)! as any
-})
-
-/** @internal */
-export const getOption = dual<
-  <S, I>(tag: C.Tag<I, S>) => <Services>(self: C.Context<Services>) => O.Option<S>,
-  <Services, S, I>(self: C.Context<Services>, tag: C.Tag<I, S>) => O.Option<S>
->(2, (self, tag) => {
-  if (!self.unsafeMap.has(tag.key)) {
-    return isReference(tag) ? option.some(getDefaultValue(tag)) : option.none
-  }
-  return option.some(self.unsafeMap.get(tag.key)! as any)
-})
-
-/** @internal */
-export const merge = dual<
-  <R1>(that: C.Context<R1>) => <Services>(self: C.Context<Services>) => C.Context<Services | R1>,
-  <Services, R1>(self: C.Context<Services>, that: C.Context<R1>) => C.Context<Services | R1>
->(2, (self, that) => {
-  const map = new Map(self.unsafeMap)
-  for (const [tag, s] of that.unsafeMap) {
-    map.set(tag, s)
-  }
-  return makeContext(map)
-})
-
-/** @internal */
-export const mergeAll = <T extends Array<unknown>>(
-  ...ctxs: [...{ [K in keyof T]: C.Context<T[K]> }]
-): C.Context<T[number]> => {
-  const map = new Map()
-  for (let i = 0; i < ctxs.length; i++) {
-    ctxs[i].unsafeMap.forEach((value, key) => {
-      map.set(key, value)
-    })
-  }
-  return makeContext(map)
-}
-
-/** @internal */
-export const pick =
-  <Tags extends ReadonlyArray<C.Tag<any, any>>>(...tags: Tags) =>
-  <Services>(self: C.Context<Services>): C.Context<
-    Services & C.Tag.Identifier<Tags[number]>
-  > => {
-    const tagSet = new Set<string>(tags.map((_) => _.key))
-    const newEnv = new Map()
-    for (const [tag, s] of self.unsafeMap.entries()) {
-      if (tagSet.has(tag)) {
-        newEnv.set(tag, s)
-      }
-    }
-    return makeContext(newEnv)
-  }
-
-/** @internal */
-export const omit =
-  <Tags extends ReadonlyArray<C.Tag<any, any>>>(...tags: Tags) =>
-  <Services>(self: C.Context<Services>): C.Context<
-    Exclude<Services, C.Tag.Identifier<Tags[number]>>
-  > => {
-    const newEnv = new Map(self.unsafeMap)
-    for (const tag of tags) {
-      newEnv.delete(tag.key)
-    }
-    return makeContext(newEnv)
-  }