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

package/src/Pretty.ts

@@ -0,0 +1,205 @@
+/**
+ * @since 3.10.0
+ */
+import * as Arr from "./Array.js"
+import * as Inspectable from "./Inspectable.js"
+import * as errors_ from "./internal/schema/errors.js"
+import * as util_ from "./internal/schema/util.js"
+import * as Option from "./Option.js"
+import * as ParseResult from "./ParseResult.js"
+import type * as Schema from "./Schema.js"
+import * as AST from "./SchemaAST.js"
+
+/**
+ * @category model
+ * @since 3.10.0
+ */
+export interface Pretty<To> {
+  (a: To): string
+}
+
+/**
+ * @category annotations
+ * @since 3.10.0
+ */
+export type PrettyAnnotation<A, TypeParameters extends ReadonlyArray<any> = readonly []> = (
+  ...pretties: { readonly [K in keyof TypeParameters]: Pretty<TypeParameters[K]> }
+) => Pretty<A>
+
+/**
+ * @category prettify
+ * @since 3.10.0
+ */
+export const make = <A, I, R>(schema: Schema.Schema<A, I, R>): (a: A) => string => compile(schema.ast, [])
+
+const getPrettyAnnotation = AST.getAnnotation<PrettyAnnotation<any, any>>(AST.PrettyAnnotationId)
+
+const getMatcher = (defaultPretty: Pretty<any>) => (ast: AST.AST): Pretty<any> =>
+  Option.match(getPrettyAnnotation(ast), {
+    onNone: () => defaultPretty,
+    onSome: (handler) => handler()
+  })
+
+const toString = getMatcher((a) => String(a))
+
+const stringify = getMatcher((a) => JSON.stringify(a))
+
+const formatUnknown = getMatcher(Inspectable.formatUnknown)
+
+/**
+ * @since 3.10.0
+ */
+export const match: AST.Match<Pretty<any>> = {
+  "Declaration": (ast, go, path) => {
+    const annotation = getPrettyAnnotation(ast)
+    if (Option.isSome(annotation)) {
+      return annotation.value(...ast.typeParameters.map((tp) => go(tp, path)))
+    }
+    throw new Error(errors_.getPrettyMissingAnnotationErrorMessage(path, ast))
+  },
+  "VoidKeyword": getMatcher(() => "void(0)"),
+  "NeverKeyword": getMatcher(() => {
+    throw new Error(errors_.getPrettyNeverErrorMessage)
+  }),
+  "Literal": getMatcher((literal: AST.LiteralValue): string =>
+    typeof literal === "bigint" ?
+      `${String(literal)}n` :
+      JSON.stringify(literal)
+  ),
+  "SymbolKeyword": toString,
+  "UniqueSymbol": toString,
+  "TemplateLiteral": stringify,
+  "UndefinedKeyword": toString,
+  "UnknownKeyword": formatUnknown,
+  "AnyKeyword": formatUnknown,
+  "ObjectKeyword": formatUnknown,
+  "StringKeyword": stringify,
+  "NumberKeyword": toString,
+  "BooleanKeyword": toString,
+  "BigIntKeyword": getMatcher((a) => `${String(a)}n`),
+  "Enums": stringify,
+  "TupleType": (ast, go, path) => {
+    const hook = getPrettyAnnotation(ast)
+    if (Option.isSome(hook)) {
+      return hook.value()
+    }
+    const elements = ast.elements.map((e, i) => go(e.type, path.concat(i)))
+    const rest = ast.rest.map((annotatedAST) => go(annotatedAST.type, path))
+    return (input: ReadonlyArray<unknown>) => {
+      const output: Array<string> = []
+      let i = 0
+      // ---------------------------------------------
+      // handle elements
+      // ---------------------------------------------
+      for (; i < elements.length; i++) {
+        if (input.length < i + 1) {
+          if (ast.elements[i].isOptional) {
+            continue
+          }
+        } else {
+          output.push(elements[i](input[i]))
+        }
+      }
+      // ---------------------------------------------
+      // handle rest element
+      // ---------------------------------------------
+      if (Arr.isNonEmptyReadonlyArray(rest)) {
+        const [head, ...tail] = rest
+        for (; i < input.length - tail.length; i++) {
+          output.push(head(input[i]))
+        }
+        // ---------------------------------------------
+        // handle post rest elements
+        // ---------------------------------------------
+        for (let j = 0; j < tail.length; j++) {
+          i += j
+          output.push(tail[j](input[i]))
+        }
+      }
+
+      return "[" + output.join(", ") + "]"
+    }
+  },
+  "TypeLiteral": (ast, go, path) => {
+    const hook = getPrettyAnnotation(ast)
+    if (Option.isSome(hook)) {
+      return hook.value()
+    }
+    const propertySignaturesTypes = ast.propertySignatures.map((ps) => go(ps.type, path.concat(ps.name)))
+    const indexSignatureTypes = ast.indexSignatures.map((is) => go(is.type, path))
+    const expectedKeys: any = {}
+    for (let i = 0; i < propertySignaturesTypes.length; i++) {
+      expectedKeys[ast.propertySignatures[i].name] = null
+    }
+    return (input: { readonly [x: PropertyKey]: unknown }) => {
+      const output: Array<string> = []
+      // ---------------------------------------------
+      // handle property signatures
+      // ---------------------------------------------
+      for (let i = 0; i < propertySignaturesTypes.length; i++) {
+        const ps = ast.propertySignatures[i]
+        const name = ps.name
+        if (ps.isOptional && !Object.prototype.hasOwnProperty.call(input, name)) {
+          continue
+        }
+        output.push(
+          `${Inspectable.formatPropertyKey(name)}: ${propertySignaturesTypes[i](input[name])}`
+        )
+      }
+      // ---------------------------------------------
+      // handle index signatures
+      // ---------------------------------------------
+      if (indexSignatureTypes.length > 0) {
+        for (let i = 0; i < indexSignatureTypes.length; i++) {
+          const type = indexSignatureTypes[i]
+          const keys = util_.getKeysForIndexSignature(input, ast.indexSignatures[i].parameter)
+          for (const key of keys) {
+            if (Object.prototype.hasOwnProperty.call(expectedKeys, key)) {
+              continue
+            }
+            output.push(`${Inspectable.formatPropertyKey(key)}: ${type(input[key])}`)
+          }
+        }
+      }
+
+      return Arr.isNonEmptyReadonlyArray(output) ? "{ " + output.join(", ") + " }" : "{}"
+    }
+  },
+  "Union": (ast, go, path) => {
+    const hook = getPrettyAnnotation(ast)
+    if (Option.isSome(hook)) {
+      return hook.value()
+    }
+    const types = ast.types.map((ast) => [ParseResult.is({ ast } as any), go(ast, path)] as const)
+    return (a) => {
+      const index = types.findIndex(([is]) => is(a))
+      if (index === -1) {
+        throw new Error(errors_.getPrettyNoMatchingSchemaErrorMessage(a, path, ast))
+      }
+      return types[index][1](a)
+    }
+  },
+  "Suspend": (ast, go, path) => {
+    return Option.match(getPrettyAnnotation(ast), {
+      onNone: () => {
+        const get = util_.memoizeThunk(() => go(ast.f(), path))
+        return (a) => get()(a)
+      },
+      onSome: (handler) => handler()
+    })
+  },
+  "Refinement": (ast, go, path) => {
+    return Option.match(getPrettyAnnotation(ast), {
+      onNone: () => go(ast.from, path),
+      onSome: (handler) => handler()
+    })
+  },
+  "Transformation": (ast, go, path) => {
+    return Option.match(getPrettyAnnotation(ast), {
+      onNone: () => go(ast.to, path),
+      onSome: (handler) => handler()
+    })
+  }
+}
+
+const compile = AST.getCompiler(match)

package/src/PrimaryKey.ts

@@ -0,0 +1,23 @@
+/**
+ * @since 2.0.0
+ */
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export const symbol: unique symbol = Symbol.for("effect/PrimaryKey")
+
+/**
+ * @since 2.0.0
+ * @category models
+ */
+export interface PrimaryKey {
+  [symbol](): string
+}
+
+/**
+ * @since 2.0.0
+ * @category accessors
+ */
+export const value = (self: PrimaryKey): string => self[symbol]()

package/src/PubSub.ts

@@ -0,0 +1,182 @@
+/**
+ * @since 2.0.0
+ */
+import type * as Effect from "./Effect.js"
+import * as internal from "./internal/pubsub.js"
+import type { Pipeable } from "./Pipeable.js"
+import type * as Queue from "./Queue.js"
+import type * as Scope from "./Scope.js"
+
+/**
+ * A `PubSub<A>` is an asynchronous message hub into which publishers can publish
+ * messages of type `A` and subscribers can subscribe to take messages of type
+ * `A`.
+ *
+ * @since 2.0.0
+ * @category models
+ */
+export interface PubSub<in out A> extends Queue.Enqueue<A>, Pipeable {
+  /**
+   * Publishes a message to the `PubSub`, returning whether the message was published
+   * to the `PubSub`.
+   */
+  publish(value: A): Effect.Effect<boolean>
+
+  /**
+   * Publishes all of the specified messages to the `PubSub`, returning whether they
+   * were published to the `PubSub`.
+   */
+  publishAll(elements: Iterable<A>): Effect.Effect<boolean>
+
+  /**
+   * Subscribes to receive messages from the `PubSub`. The resulting subscription can
+   * be evaluated multiple times within the scope to take a message from the `PubSub`
+   * each time.
+   */
+  readonly subscribe: Effect.Effect<Queue.Dequeue<A>, never, Scope.Scope>
+}
+
+/**
+ * Creates a bounded `PubSub` with the back pressure strategy. The `PubSub` will retain
+ * messages until they have been taken by all subscribers, applying back
+ * pressure to publishers if the `PubSub` is at capacity.
+ *
+ * For best performance use capacities that are powers of two.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const bounded: <A>(
+  capacity: number | { readonly capacity: number; readonly replay?: number | undefined }
+) => Effect.Effect<PubSub<A>> = internal.bounded
+
+/**
+ * Creates a bounded `PubSub` with the dropping strategy. The `PubSub` will drop new
+ * messages if the `PubSub` is at capacity.
+ *
+ * For best performance use capacities that are powers of two.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const dropping: <A>(
+  capacity: number | { readonly capacity: number; readonly replay?: number | undefined }
+) => Effect.Effect<PubSub<A>> = internal.dropping
+
+/**
+ * Creates a bounded `PubSub` with the sliding strategy. The `PubSub` will add new
+ * messages and drop old messages if the `PubSub` is at capacity.
+ *
+ * For best performance use capacities that are powers of two.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const sliding: <A>(
+  capacity: number | { readonly capacity: number; readonly replay?: number | undefined }
+) => Effect.Effect<PubSub<A>> = internal.sliding
+
+/**
+ * Creates an unbounded `PubSub`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const unbounded: <A>(options?: { readonly replay?: number | undefined }) => Effect.Effect<PubSub<A>> =
+  internal.unbounded
+
+/**
+ *  Returns the number of elements the queue can hold.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+export const capacity: <A>(self: PubSub<A>) => number = internal.capacity
+
+/**
+ * Retrieves the size of the queue, which is equal to the number of elements
+ * in the queue. This may be negative if fibers are suspended waiting for
+ * elements to be added to the queue.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+export const size: <A>(self: PubSub<A>) => Effect.Effect<number> = internal.size
+
+/**
+ * Returns `true` if the `Queue` contains at least one element, `false`
+ * otherwise.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+export const isFull: <A>(self: PubSub<A>) => Effect.Effect<boolean> = internal.isFull
+
+/**
+ * Returns `true` if the `Queue` contains zero elements, `false` otherwise.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+export const isEmpty: <A>(self: PubSub<A>) => Effect.Effect<boolean> = internal.isEmpty
+
+/**
+ * Interrupts any fibers that are suspended on `offer` or `take`. Future calls
+ * to `offer*` and `take*` will be interrupted immediately.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+export const shutdown: <A>(self: PubSub<A>) => Effect.Effect<void> = internal.shutdown
+
+/**
+ * Returns `true` if `shutdown` has been called, otherwise returns `false`.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+export const isShutdown: <A>(self: PubSub<A>) => Effect.Effect<boolean> = internal.isShutdown
+
+/**
+ * Waits until the queue is shutdown. The `Effect` returned by this method will
+ * not resume until the queue has been shutdown. If the queue is already
+ * shutdown, the `Effect` will resume right away.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+export const awaitShutdown: <A>(self: PubSub<A>) => Effect.Effect<void> = internal.awaitShutdown
+
+/**
+ * Publishes a message to the `PubSub`, returning whether the message was published
+ * to the `PubSub`.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+export const publish: {
+  <A>(value: A): (self: PubSub<A>) => Effect.Effect<boolean>
+  <A>(self: PubSub<A>, value: A): Effect.Effect<boolean>
+} = internal.publish
+
+/**
+ * Publishes all of the specified messages to the `PubSub`, returning whether they
+ * were published to the `PubSub`.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+export const publishAll: {
+  <A>(elements: Iterable<A>): (self: PubSub<A>) => Effect.Effect<boolean>
+  <A>(self: PubSub<A>, elements: Iterable<A>): Effect.Effect<boolean>
+} = internal.publishAll
+
+/**
+ * Subscribes to receive messages from the `PubSub`. The resulting subscription can
+ * be evaluated multiple times within the scope to take a message from the `PubSub`
+ * each time.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+export const subscribe: <A>(self: PubSub<A>) => Effect.Effect<Queue.Dequeue<A>, never, Scope.Scope> = internal.subscribe