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

package/src/internal/schema/errors.ts

@@ -0,0 +1,191 @@
+import * as array_ from "../../Array.js"
+import * as Inspectable from "../../Inspectable.js"
+import type * as AST from "../../SchemaAST.js"
+import * as util_ from "./util.js"
+
+const getErrorMessage = (
+  reason: string,
+  details?: string,
+  path?: ReadonlyArray<PropertyKey>,
+  ast?: AST.AST
+): string => {
+  let out = reason
+
+  if (path && array_.isNonEmptyReadonlyArray(path)) {
+    out += `\nat path: ${util_.formatPath(path)}`
+  }
+
+  if (details !== undefined) {
+    out += `\ndetails: ${details}`
+  }
+
+  if (ast) {
+    out += `\nschema (${ast._tag}): ${ast}`
+  }
+
+  return out
+}
+
+// ---------------------------------------------
+// generic
+// ---------------------------------------------
+
+/** @internal */
+export const getInvalidArgumentErrorMessage = (details: string) => getErrorMessage("Invalid Argument", details)
+
+const getUnsupportedSchemaErrorMessage = (details?: string, path?: ReadonlyArray<PropertyKey>, ast?: AST.AST): string =>
+  getErrorMessage("Unsupported schema", details, path, ast)
+
+const getMissingAnnotationErrorMessage = (details?: string, path?: ReadonlyArray<PropertyKey>, ast?: AST.AST): string =>
+  getErrorMessage("Missing annotation", details, path, ast)
+
+// ---------------------------------------------
+// Arbitrary
+// ---------------------------------------------
+
+/** @internal */
+export const getArbitraryUnsupportedErrorMessage = (path: ReadonlyArray<PropertyKey>, ast: AST.AST) =>
+  getUnsupportedSchemaErrorMessage("Cannot build an Arbitrary for this schema", path, ast)
+
+/** @internal */
+export const getArbitraryMissingAnnotationErrorMessage = (
+  path: ReadonlyArray<PropertyKey>,
+  ast: AST.AST
+) =>
+  getMissingAnnotationErrorMessage(
+    `Generating an Arbitrary for this schema requires an "arbitrary" annotation`,
+    path,
+    ast
+  )
+
+/** @internal */
+export const getArbitraryEmptyEnumErrorMessage = (path: ReadonlyArray<PropertyKey>) =>
+  getErrorMessage("Empty Enums schema", "Generating an Arbitrary for this schema requires at least one enum", path)
+
+// ---------------------------------------------
+// Equivalence
+// ---------------------------------------------
+
+/** @internal */
+export const getEquivalenceUnsupportedErrorMessage = (ast: AST.AST, path: ReadonlyArray<PropertyKey>) =>
+  getUnsupportedSchemaErrorMessage("Cannot build an Equivalence", path, ast)
+
+// ---------------------------------------------
+// JSON Schema
+// ---------------------------------------------
+
+/** @internal */
+export const getJSONSchemaMissingAnnotationErrorMessage = (
+  path: ReadonlyArray<PropertyKey>,
+  ast: AST.AST
+) =>
+  getMissingAnnotationErrorMessage(
+    `Generating a JSON Schema for this schema requires a "jsonSchema" annotation`,
+    path,
+    ast
+  )
+
+/** @internal */
+export const getJSONSchemaMissingIdentifierAnnotationErrorMessage = (
+  path: ReadonlyArray<PropertyKey>,
+  ast: AST.AST
+) =>
+  getMissingAnnotationErrorMessage(
+    `Generating a JSON Schema for this schema requires an "identifier" annotation`,
+    path,
+    ast
+  )
+
+/** @internal */
+export const getJSONSchemaUnsupportedPostRestElementsErrorMessage = (path: ReadonlyArray<PropertyKey>): string =>
+  getErrorMessage(
+    "Generating a JSON Schema for post-rest elements is not currently supported. You're welcome to contribute by submitting a Pull Request",
+    undefined,
+    path
+  )
+
+/** @internal */
+export const getJSONSchemaUnsupportedKeyErrorMessage = (key: PropertyKey, path: ReadonlyArray<PropertyKey>): string =>
+  getErrorMessage("Unsupported key", `Cannot encode ${Inspectable.formatPropertyKey(key)} key to JSON Schema`, path)
+
+// ---------------------------------------------
+// Pretty
+// ---------------------------------------------
+
+/** @internal */
+export const getPrettyMissingAnnotationErrorMessage = (
+  path: ReadonlyArray<PropertyKey>,
+  ast: AST.AST
+) => getMissingAnnotationErrorMessage(`Generating a Pretty for this schema requires a "pretty" annotation`, path, ast)
+
+/** @internal */
+export const getPrettyNeverErrorMessage = "Cannot pretty print a `never` value"
+
+/** @internal */
+export const getPrettyNoMatchingSchemaErrorMessage = (
+  actual: unknown,
+  path: ReadonlyArray<PropertyKey>,
+  ast: AST.AST
+) =>
+  getErrorMessage(
+    "Unexpected Error",
+    `Cannot find a matching schema for ${Inspectable.formatUnknown(actual)}`,
+    path,
+    ast
+  )
+
+// ---------------------------------------------
+// Schema
+// ---------------------------------------------
+
+/** @internal */
+export const getSchemaExtendErrorMessage = (x: AST.AST, y: AST.AST, path: ReadonlyArray<PropertyKey>) =>
+  getErrorMessage("Unsupported schema or overlapping types", `cannot extend ${x} with ${y}`, path)
+
+/** @internal */
+export const getSchemaUnsupportedLiteralSpanErrorMessage = (ast: AST.AST) =>
+  getErrorMessage("Unsupported template literal span", undefined, undefined, ast)
+
+// ---------------------------------------------
+// AST
+// ---------------------------------------------
+
+/** @internal */
+export const getASTUnsupportedSchemaErrorMessage = (ast: AST.AST) =>
+  getUnsupportedSchemaErrorMessage(undefined, undefined, ast)
+
+/** @internal */
+export const getASTUnsupportedKeySchemaErrorMessage = (ast: AST.AST) =>
+  getErrorMessage("Unsupported key schema", undefined, undefined, ast)
+
+/** @internal */
+export const getASTUnsupportedLiteralErrorMessage = (literal: AST.LiteralValue) =>
+  getErrorMessage("Unsupported literal", `literal value: ${Inspectable.formatUnknown(literal)}`)
+
+/** @internal */
+export const getASTDuplicateIndexSignatureErrorMessage = (type: "string" | "symbol"): string =>
+  getErrorMessage("Duplicate index signature", `${type} index signature`)
+
+/** @internal */
+export const getASTIndexSignatureParameterErrorMessage = getErrorMessage(
+  "Unsupported index signature parameter",
+  "An index signature parameter type must be `string`, `symbol`, a template literal type or a refinement of the previous types"
+)
+
+/** @internal */
+export const getASTRequiredElementFollowinAnOptionalElementErrorMessage = getErrorMessage(
+  "Invalid element",
+  "A required element cannot follow an optional element. ts(1257)"
+)
+
+/** @internal */
+export const getASTDuplicatePropertySignatureTransformationErrorMessage = (key: PropertyKey): string =>
+  getErrorMessage("Duplicate property signature transformation", `Duplicate key ${Inspectable.formatUnknown(key)}`)
+
+/** @internal */
+export const getASTUnsupportedRenameSchemaErrorMessage = (ast: AST.AST): string =>
+  getUnsupportedSchemaErrorMessage(undefined, undefined, ast)
+
+/** @internal */
+export const getASTDuplicatePropertySignatureErrorMessage = (key: PropertyKey): string =>
+  getErrorMessage("Duplicate property signature", `Duplicate key ${Inspectable.formatUnknown(key)}`)

package/src/internal/schema/schemaId.ts

@@ -0,0 +1,106 @@
+import type * as Schema from "../../Schema.js"
+
+/** @internal */
+export const DateFromSelfSchemaId: Schema.DateFromSelfSchemaId = Symbol.for(
+  "effect/SchemaId/DateFromSelf"
+) as Schema.DateFromSelfSchemaId
+
+/** @internal */
+export const GreaterThanSchemaId: Schema.GreaterThanSchemaId = Symbol.for(
+  "effect/SchemaId/GreaterThan"
+) as Schema.GreaterThanSchemaId
+
+/** @internal */
+export const GreaterThanOrEqualToSchemaId: Schema.GreaterThanOrEqualToSchemaId = Symbol.for(
+  "effect/SchemaId/GreaterThanOrEqualTo"
+) as Schema.GreaterThanOrEqualToSchemaId
+
+/** @internal */
+export const LessThanSchemaId: Schema.LessThanSchemaId = Symbol.for(
+  "effect/SchemaId/LessThan"
+) as Schema.LessThanSchemaId
+
+/** @internal */
+export const LessThanOrEqualToSchemaId: Schema.LessThanOrEqualToSchemaId = Symbol.for(
+  "effect/SchemaId/LessThanOrEqualTo"
+) as Schema.LessThanOrEqualToSchemaId
+
+/** @internal */
+export const IntSchemaId: Schema.IntSchemaId = Symbol.for(
+  "effect/SchemaId/Int"
+) as Schema.IntSchemaId
+
+/** @internal */
+export const NonNaNSchemaId: Schema.NonNaNSchemaId = Symbol.for(
+  "effect/SchemaId/NonNaN"
+) as Schema.NonNaNSchemaId
+
+/** @internal */
+export const FiniteSchemaId: Schema.FiniteSchemaId = Symbol.for(
+  "effect/SchemaId/Finite"
+) as Schema.FiniteSchemaId
+
+/** @internal */
+export const JsonNumberSchemaId: Schema.JsonNumberSchemaId = Symbol.for(
+  "effect/SchemaId/JsonNumber"
+) as Schema.JsonNumberSchemaId
+
+/** @internal */
+export const BetweenSchemaId: Schema.BetweenSchemaId = Symbol.for(
+  "effect/SchemaId/Between"
+) as Schema.BetweenSchemaId
+
+/** @internal */
+export const GreaterThanBigintSchemaId: Schema.GreaterThanBigIntSchemaId = Symbol.for(
+  "effect/SchemaId/GreaterThanBigint"
+) as Schema.GreaterThanBigIntSchemaId
+
+/** @internal */
+export const GreaterThanOrEqualToBigIntSchemaId: Schema.GreaterThanOrEqualToBigIntSchemaId = Symbol.for(
+  "effect/SchemaId/GreaterThanOrEqualToBigint"
+) as Schema.GreaterThanOrEqualToBigIntSchemaId
+
+/** @internal */
+export const LessThanBigIntSchemaId: Schema.LessThanBigIntSchemaId = Symbol.for(
+  "effect/SchemaId/LessThanBigint"
+) as Schema.LessThanBigIntSchemaId
+
+/** @internal */
+export const LessThanOrEqualToBigIntSchemaId: Schema.LessThanOrEqualToBigIntSchemaId = Symbol.for(
+  "effect/SchemaId/LessThanOrEqualToBigint"
+) as Schema.LessThanOrEqualToBigIntSchemaId
+
+/** @internal */
+export const BetweenBigintSchemaId: Schema.BetweenBigIntSchemaId = Symbol.for(
+  "effect/SchemaId/BetweenBigint"
+) as Schema.BetweenBigIntSchemaId
+
+/** @internal */
+export const MinLengthSchemaId: Schema.MinLengthSchemaId = Symbol.for(
+  "effect/SchemaId/MinLength"
+) as Schema.MinLengthSchemaId
+
+/** @internal */
+export const MaxLengthSchemaId: Schema.MaxLengthSchemaId = Symbol.for(
+  "effect/SchemaId/MaxLength"
+) as Schema.MaxLengthSchemaId
+
+/** @internal */
+export const LengthSchemaId: Schema.LengthSchemaId = Symbol.for(
+  "effect/SchemaId/Length"
+) as Schema.LengthSchemaId
+
+/** @internal */
+export const MinItemsSchemaId: Schema.MinItemsSchemaId = Symbol.for(
+  "effect/SchemaId/MinItems"
+) as Schema.MinItemsSchemaId
+
+/** @internal */
+export const MaxItemsSchemaId: Schema.MaxItemsSchemaId = Symbol.for(
+  "effect/SchemaId/MaxItems"
+) as Schema.MaxItemsSchemaId
+
+/** @internal */
+export const ItemsCountSchemaId: Schema.ItemsCountSchemaId = Symbol.for(
+  "effect/SchemaId/ItemsCount"
+) as Schema.ItemsCountSchemaId

package/src/internal/schema/util.ts

@@ -0,0 +1,50 @@
+import type { NonEmptyReadonlyArray } from "../../Array.js"
+import * as Inspectable from "../../Inspectable.js"
+import type * as ParseResult from "../../ParseResult.js"
+import type * as AST from "../../SchemaAST.js"
+
+/** @internal */
+export const getKeysForIndexSignature = (
+  input: { readonly [x: PropertyKey]: unknown },
+  parameter: AST.Parameter
+): ReadonlyArray<string> | ReadonlyArray<symbol> => {
+  switch (parameter._tag) {
+    case "StringKeyword":
+    case "TemplateLiteral":
+      return Object.keys(input)
+    case "SymbolKeyword":
+      return Object.getOwnPropertySymbols(input)
+    case "Refinement":
+      return getKeysForIndexSignature(input, parameter.from)
+  }
+}
+
+/** @internal */
+export const memoizeThunk = <A>(f: () => A): () => A => {
+  let done = false
+  let a: A
+  return () => {
+    if (done) {
+      return a
+    }
+    a = f()
+    done = true
+    return a
+  }
+}
+
+/** @internal */
+export type SingleOrArray<A> = A | ReadonlyArray<A>
+
+/** @internal */
+export const isNonEmpty = <A>(x: ParseResult.SingleOrNonEmpty<A>): x is NonEmptyReadonlyArray<A> => Array.isArray(x)
+
+/** @internal */
+export const isSingle = <A>(x: A | ReadonlyArray<A>): x is A => !Array.isArray(x)
+
+/** @internal */
+export const formatPathKey = (key: PropertyKey): string => `[${Inspectable.formatPropertyKey(key)}]`
+
+/** @internal */
+export const formatPath = (path: ParseResult.Path): string =>
+  isNonEmpty(path) ? path.map(formatPathKey).join("") : formatPathKey(path)