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

package/src/internal/scopedRef.ts

@@ -0,0 +1,118 @@
+import * as Context from "../Context.js"
+import type * as Effect from "../Effect.js"
+import type { LazyArg } from "../Function.js"
+import { dual, pipe } from "../Function.js"
+import type * as Scope from "../Scope.js"
+import type * as ScopedRef from "../ScopedRef.js"
+import * as core from "./core.js"
+import * as circular from "./effect/circular.js"
+import * as effectable from "./effectable.js"
+import * as fiberRuntime from "./fiberRuntime.js"
+import * as ref from "./ref.js"
+import * as synchronized from "./synchronizedRef.js"
+
+/** @internal */
+const ScopedRefSymbolKey = "effect/ScopedRef"
+
+/** @internal */
+export const ScopedRefTypeId: ScopedRef.ScopedRefTypeId = Symbol.for(
+  ScopedRefSymbolKey
+) as ScopedRef.ScopedRefTypeId
+
+/** @internal */
+const scopedRefVariance = {
+  /* c8 ignore next */
+  _A: (_: any) => _
+}
+
+/** @internal  */
+const proto: ThisType<ScopedRef.ScopedRef<any>> = {
+  ...effectable.CommitPrototype,
+  commit() {
+    return get(this)
+  },
+  [ScopedRefTypeId]: scopedRefVariance
+}
+
+/** @internal  */
+const close = <A>(self: ScopedRef.ScopedRef<A>): Effect.Effect<void> =>
+  core.flatMap(ref.get(self.ref), (tuple) => tuple[0].close(core.exitVoid))
+
+/** @internal */
+export const fromAcquire = <A, E, R>(
+  acquire: Effect.Effect<A, E, R>
+): Effect.Effect<ScopedRef.ScopedRef<A>, E, R | Scope.Scope> =>
+  core.uninterruptible(
+    fiberRuntime.scopeMake().pipe(core.flatMap((newScope) =>
+      acquire.pipe(
+        core.mapInputContext<R, Scope.Scope | R>(Context.add(fiberRuntime.scopeTag, newScope)),
+        core.onError((cause) => newScope.close(core.exitFail(cause))),
+        core.flatMap((value) =>
+          circular.makeSynchronized([newScope, value] as const).pipe(
+            core.flatMap((ref) => {
+              const scopedRef = Object.create(proto)
+              scopedRef.ref = ref
+              return pipe(
+                fiberRuntime.addFinalizer(() => close(scopedRef)),
+                core.as(scopedRef)
+              )
+            })
+          )
+        )
+      )
+    ))
+  )
+
+/** @internal */
+export const get = <A>(self: ScopedRef.ScopedRef<A>): Effect.Effect<A> =>
+  core.map(ref.get(self.ref), (tuple) => tuple[1])
+
+/** @internal */
+export const make = <A>(evaluate: LazyArg<A>): Effect.Effect<ScopedRef.ScopedRef<A>, never, Scope.Scope> =>
+  fromAcquire(core.sync(evaluate))
+
+/** @internal */
+export const set = dual<
+  <A, R, E>(
+    acquire: Effect.Effect<A, E, R>
+  ) => (self: ScopedRef.ScopedRef<A>) => Effect.Effect<void, E, Exclude<R, Scope.Scope>>,
+  <A, R, E>(
+    self: ScopedRef.ScopedRef<A>,
+    acquire: Effect.Effect<A, E, R>
+  ) => Effect.Effect<void, E, Exclude<R, Scope.Scope>>
+>(2, <A, R, E>(
+  self: ScopedRef.ScopedRef<A>,
+  acquire: Effect.Effect<A, E, R>
+) =>
+  core.flatten(
+    synchronized.modifyEffect(self.ref, ([oldScope, value]) =>
+      core.uninterruptible(
+        core.scopeClose(oldScope, core.exitVoid).pipe(
+          core.zipRight(fiberRuntime.scopeMake()),
+          core.flatMap((newScope) =>
+            core.exit(fiberRuntime.scopeExtend(acquire, newScope)).pipe(
+              core.flatMap((exit) =>
+                core.exitMatch(exit, {
+                  onFailure: (cause) =>
+                    core.scopeClose(newScope, core.exitVoid).pipe(
+                      core.as(
+                        [
+                          core.failCause(cause) as Effect.Effect<void, E>,
+                          [oldScope, value] as const
+                        ] as const
+                      )
+                    ),
+                  onSuccess: (value) =>
+                    core.succeed(
+                      [
+                        core.void as Effect.Effect<void, E>,
+                        [newScope, value] as const
+                      ] as const
+                    )
+                })
+              )
+            )
+          )
+        )
+      ))
+  ))

package/src/internal/secret.ts

@@ -0,0 +1,89 @@
+import * as Arr from "../Array.js"
+import { hasProperty } from "../Predicate.js"
+import type * as Secret from "../Secret.js"
+import * as redacted_ from "./redacted.js"
+
+/**
+ * @internal
+ * @deprecated
+ */
+const SecretSymbolKey = "effect/Secret"
+
+/**
+ * @internal
+ * @deprecated
+ */
+export const SecretTypeId: Secret.SecretTypeId = Symbol.for(
+  SecretSymbolKey
+) as Secret.SecretTypeId
+
+/**
+ * @internal
+ * @deprecated
+ */
+export const isSecret = (u: unknown): u is Secret.Secret => hasProperty(u, SecretTypeId)
+
+const SecretProto = {
+  ...redacted_.proto,
+  [SecretTypeId]: SecretTypeId
+}
+
+/**
+ * @internal
+ * @deprecated
+ */
+export const make = (bytes: Array<number>): Secret.Secret => {
+  const secret = Object.create(SecretProto)
+  Object.defineProperty(secret, "toString", {
+    enumerable: false,
+    value() {
+      return "Secret(<redacted>)"
+    }
+  })
+  Object.defineProperty(secret, "toJSON", {
+    enumerable: false,
+    value() {
+      return "<redacted>"
+    }
+  })
+  Object.defineProperty(secret, "raw", {
+    enumerable: false,
+    value: bytes
+  })
+  redacted_.redactedRegistry.set(secret, bytes.map((byte) => String.fromCharCode(byte)).join(""))
+  return secret
+}
+
+/**
+ * @internal
+ * @deprecated
+ */
+export const fromIterable = (iterable: Iterable<string>): Secret.Secret =>
+  make(Arr.fromIterable(iterable).map((char) => char.charCodeAt(0)))
+
+/**
+ * @internal
+ * @deprecated
+ */
+export const fromString = (text: string): Secret.Secret => {
+  return make(text.split("").map((char) => char.charCodeAt(0)))
+}
+
+/**
+ * @internal
+ * @deprecated
+ */
+export const value = (self: Secret.Secret): string => {
+  return self.raw.map((byte) => String.fromCharCode(byte)).join("")
+}
+
+/**
+ * @internal
+ * @deprecated
+ */
+export const unsafeWipe = (self: Secret.Secret): void => {
+  for (let i = 0; i < self.raw.length; i++) {
+    self.raw[i] = 0
+  }
+  redacted_.redactedRegistry.delete(self)
+}

package/src/internal/singleShotGen.ts

@@ -0,0 +1,35 @@
+/** @internal */
+export class SingleShotGen<T, A> implements Generator<T, A> {
+  called = false
+
+  constructor(readonly self: T) {
+  }
+
+  next(a: A): IteratorResult<T, A> {
+    return this.called ?
+      ({
+        value: a,
+        done: true
+      }) :
+      (this.called = true,
+        ({
+          value: this.self,
+          done: false
+        }))
+  }
+
+  return(a: A): IteratorResult<T, A> {
+    return ({
+      value: a,
+      done: true
+    })
+  }
+
+  throw(e: unknown): IteratorResult<T, A> {
+    throw e
+  }
+
+  [Symbol.iterator](): Generator<T, A> {
+    return new SingleShotGen<T, A>(this.self)
+  }
+}