liminal 0.5.2 → 0.5.4

package/types/AssertDiagnostics.ts

@@ -1,183 +0,0 @@
-import { assert } from "../util/assert.ts"
-import { isJSONValue } from "../util/isJSONValue.ts"
-import { jsonEquals } from "../util/jsonEquals.ts"
-import type { JSONKey } from "../util/JSONKey.ts"
-import type { JSONValue } from "../util/JSONValue.ts"
-import type { JSONType } from "./JSONType.ts"
-import type { Type } from "./Type.ts"
-import { TypeVisitor } from "./TypeVisitor.ts"
-
-export type AssertDiagnostics = Array<Diagnostic>
-
-export type Diagnostic = ReturnType<typeof Diagnostic>
-export function Diagnostic(path: AssertPath, type: Type, error: unknown) {
-  return {
-    path,
-    type,
-    error,
-    message,
-    formatPath,
-  }
-
-  function message() {
-    return error instanceof Error ? error.message : JSON.stringify(error)
-  }
-
-  function formatPath() {
-    let formatted = ""
-    for (let i = 0; i < path.length; i++) {
-      const key = path[i]!
-      if (typeof key === "string") {
-        try {
-          const int = parseInt(key)
-          if (Number.isInteger(int)) {
-            formatted += `[${int}]`
-          } else {
-            formatted += `.${key}`
-          }
-        } catch (_e: unknown) {
-          formatted += `.${key}`
-        }
-      } else {
-        formatted += `[${key}]`
-      }
-    }
-    return formatted
-  }
-}
-
-export type AssertPath = Array<JSONKey>
-
-// Possibly: `nullUnionFieldsAsOptional?: boolean`
-export interface AssertDiagnosticsConfig {}
-
-export function AssertDiagnostics<T extends JSONValue, J extends JSONType>(
-  config: AssertDiagnosticsConfig,
-  type: Type<T, J>,
-  value: unknown,
-): Array<Diagnostic> {
-  const state = ValueVisitorState()
-  visit([config, false], type)(value, state)
-  return state.diagnostics
-}
-
-type ValueVisitorState = ReturnType<typeof ValueVisitorState>
-function ValueVisitorState(
-  diagnostics: Array<Diagnostic> = [],
-  path: Array<number | string> = [],
-) {
-  return {
-    diagnostics,
-    path,
-    next,
-  }
-
-  function next(key?: JSONKey) {
-    return ValueVisitorState(diagnostics, [...path, ...key !== undefined ? [key] : []])
-  }
-}
-
-const visit: TypeVisitor<AssertDiagnosticsConfig, (value: unknown, vState: ValueVisitorState) => void> = TypeVisitor(
-  {
-    hook(next, tState, type) {
-      return (value, vState) => {
-        try {
-          next(tState, type)(value, vState)
-        } catch (error) {
-          vState.diagnostics.push(Diagnostic(vState.path, type, error))
-        }
-      }
-    },
-    null() {
-      return (value) => {
-        assert(value === null)
-      }
-    },
-    boolean() {
-      return (value) => {
-        assert(typeof value === "boolean")
-      }
-    },
-    integer() {
-      return (value) => {
-        assert(typeof value === "number" && Number.isInteger(value))
-      }
-    },
-    number() {
-      return (value) => {
-        assert(typeof value === "number")
-      }
-    },
-    string() {
-      return (value) => {
-        assert(typeof value === "string")
-      }
-    },
-    const(_tState, _type, _valueType, value_) {
-      return (value) => {
-        assert(isJSONValue(value) && jsonEquals(value_, value))
-      }
-    },
-    _array(tState, _type, element) {
-      const visitElement = visit(tState, element)
-      return (value, vState) => {
-        assert(Array.isArray(value))
-        value.forEach((e, i) => visitElement(e, vState.next(i)))
-      }
-    },
-    enum(_tState, _type, ...values) {
-      return (value) => {
-        assert(typeof value == "string")
-        assert(values.includes(value))
-      }
-    },
-    _union(tState, _type, ...members) {
-      return (value, vState) => {
-        assert(members.some((member) => {
-          const memberState = vState.next()
-          visit(tState, member)(value, memberState)
-          return !memberState.diagnostics.length
-        }))
-      }
-    },
-    _object(tState, _type, fields) {
-      return (value, vState) => {
-        assert(typeof value === "object" && value !== null)
-        if (Array.isArray(fields)) {
-          fields.forEach((v, i) => {
-            visitField(tState, vState, value, i, v)
-          })
-        } else {
-          Object.entries(fields).forEach(([k, v]) => {
-            visitField(tState, vState, value, k, v)
-          })
-        }
-      }
-    },
-    ref(tState, _type, getType) {
-      return (value, vState) => {
-        visit(tState, getType())(value, vState)
-      }
-    },
-  },
-)
-
-function visitField(
-  tState: AssertDiagnosticsConfig,
-  vState: ValueVisitorState,
-  value: object,
-  key: JSONKey,
-  type: Type,
-) {
-  assert(key in value)
-  const childValue = value[key as never]
-  assert(childValue !== undefined)
-  visit(tState, type)(childValue, vState.next(key))
-}
-
-// TODO: serialize signature
-export function formatAssertDiagnostics(diagnostics: AssertDiagnostics) {
-  return diagnostics
-    .map((diagnostic) => `Error "${diagnostic.message()}"; encountered at ${diagnostic.formatPath()}`)
-    .join("\n")
-}

package/types/JSONRootType.ts

@@ -1,8 +0,0 @@
-import type { JSONIdentifiedType, JSONType } from "./JSONType.ts"
-
-export const JSONSchema$schema = "http://json-schema.org/draft-07/schema#"
-
-export type JSONRootType<J extends JSONType> = J & {
-  $schema: typeof JSONSchema$schema
-  $defs: Record<string, JSONIdentifiedType | undefined>
-}

package/types/JSONType.ts

@@ -1,27 +0,0 @@
-import type { JSONArrayType } from "./array.ts"
-import type { JSONBooleanType } from "./boolean.ts"
-import type { JSONConstType } from "./const.ts"
-import type { JSONEnumType } from "./enum.ts"
-import type { JSONIntegerType } from "./integer.ts"
-import type { JSONNullType } from "./null.ts"
-import type { JSONNumberType } from "./number.ts"
-import type { JSONObjectType } from "./object.ts"
-import type { JSONRefType } from "./ref.ts"
-import type { JSONStringType } from "./string.ts"
-import type { JSONUnionType } from "./union.ts"
-
-export type JSONIdentifiedType = JSONArrayType | JSONObjectType | JSONUnionType
-
-export type JSONAnonymousType =
-  | JSONNullType
-  | JSONBooleanType
-  | JSONIntegerType
-  | JSONNumberType
-  | JSONStringType
-  | JSONEnumType
-
-export type ConstableType = JSONAnonymousType | JSONIdentifiedType
-
-export type JSONRootableType = ConstableType | JSONConstType
-
-export type JSONType = JSONRootableType | JSONRefType

package/types/JSONTypeBase.ts

@@ -1,3 +0,0 @@
-export interface JSONTypeBase {
-  description?: string
-}

package/types/Metatype/MetatypeDescriptor.ts

@@ -1,80 +0,0 @@
-import { array } from "../array.ts"
-import { enum as enum_ } from "../enum.ts"
-import { type JSONObjectType, object } from "../object.ts"
-import { ref } from "../ref.ts"
-import { string } from "../string.ts"
-import type { Type } from "../Type.ts"
-import { taggedUnion } from "../types_derived/taggedUnion.ts"
-import type { JSONUnionType } from "../union.ts"
-
-export type MetatypeRootDescriptor = {
-  type: "record"
-  value: {
-    description: string
-    fields: Array<{
-      description: string
-      key: string
-      value: MetatypeDescriptor
-    }>
-  }
-}
-
-const recordFields = {
-  description: string,
-  fields: array({
-    description: string,
-    key: string,
-    value: ref(() => MetatypeDescriptor),
-  }),
-}
-
-export const MetatypeRootDescriptor: Type<MetatypeRootDescriptor, JSONObjectType> = object({
-  type: "record",
-  value: recordFields,
-})
-
-export type MetatypeDescriptor = MetatypeRootDescriptor | {
-  type: "atom"
-  value: {
-    description: string
-    atomType: "boolean" | "integer" | "number" | "string"
-  }
-} | {
-  type: "enum"
-  value: {
-    description: string
-    variants: Array<string>
-  }
-} | {
-  type: "array"
-  value: {
-    description: string
-    items: MetatypeDescriptor
-  }
-} | {
-  type: "union"
-  value: {
-    description: string
-    members: Array<MetatypeDescriptor>
-  }
-}
-
-export const MetatypeDescriptor: Type<MetatypeDescriptor, JSONUnionType> = taggedUnion({
-  atom: {
-    description: string,
-    atomType: enum_("boolean", "integer", "number", "string"),
-  },
-  enum: {
-    description: string,
-    variants: array(string),
-  },
-  array: {
-    description: string,
-    items: ref(() => MetatypeDescriptor),
-  },
-  record: recordFields,
-  union: {
-    description: string,
-    members: array(ref(() => MetatypeDescriptor)),
-  },
-})

package/types/Metatype/fromMetatypeDescriptor.ts

@@ -1,52 +0,0 @@
-import type { JSONObject } from "../../util/JSONObject.ts"
-import { array } from "../array.ts"
-import { boolean } from "../boolean.ts"
-import { enum as enum_ } from "../enum.ts"
-import { integer } from "../integer.ts"
-import { number } from "../number.ts"
-import { type JSONObjectType, object } from "../object.ts"
-import { string } from "../string.ts"
-import type { Type } from "../Type.ts"
-import { union } from "../union.ts"
-import type { MetatypeDescriptor, MetatypeRootDescriptor } from "./MetatypeDescriptor.ts"
-
-export function fromMetatypeRootDescriptor(descriptor: MetatypeRootDescriptor): Type<JSONObject, JSONObjectType> {
-  return fromMetatypeDescriptor(descriptor) as never
-}
-
-export function fromMetatypeDescriptor(descriptor: MetatypeDescriptor): Type {
-  return make(descriptor)(descriptor.value.description)
-}
-
-function make(descriptor: MetatypeDescriptor): Type {
-  switch (descriptor.type) {
-    case "atom": {
-      switch (descriptor.value.atomType) {
-        case "boolean":
-          return boolean
-        case "integer":
-          return integer
-        case "number":
-          return number
-        case "string":
-          return string
-      }
-    }
-    case "array": {
-      return array(fromMetatypeDescriptor(descriptor.value.items))
-    }
-    case "enum": {
-      return enum_(...descriptor.value.variants)
-    }
-    case "record": {
-      return object(Object.fromEntries(descriptor.value.fields.map(({
-        key,
-        value,
-        description,
-      }) => [key, fromMetatypeDescriptor(value)(description)])))
-    }
-    case "union": {
-      return union(...descriptor.value.members.map(fromMetatypeDescriptor))
-    }
-  }
-}

package/types/Type.ts

@@ -1,47 +0,0 @@
-import type { StandardSchemaV1 } from "@standard-schema/spec"
-import type { Action } from "../Action.ts"
-import type { InferenceRequested } from "../events/InferenceRequested.ts"
-import type { Inferred } from "../events/Inferred.ts"
-import type { Spec } from "../Spec.ts"
-import type { Falsy } from "../util/Falsy.ts"
-import type { JSONValue } from "../util/JSONValue.ts"
-import type { Taggable } from "../util/Taggable.ts"
-import type { JSONRootType } from "./JSONRootType.ts"
-import type { JSONType } from "./JSONType.ts"
-import type { JSONObjectType } from "./object.ts"
-
-export interface Type<T extends JSONValue = JSONValue, J extends JSONType = JSONType>
-  extends Taggable<Array<string | Falsy>>, TypeMembers<T, J>
-{
-  T: T
-  J: J
-
-  [Symbol.iterator]: J extends JSONObjectType ? () => Iterator<
-      Action<
-        "infer",
-        Spec.Make<{
-          Event: InferenceRequested | Inferred
-        }>
-      >,
-      T
-    >
-    : never
-}
-
-export interface TypeMembers<T extends JSONValue, J extends JSONType> extends StandardSchemaV1<T> {
-  [TypeKey]: true
-  declaration: () => Type<T, J> | ((...args: any) => Type<T, J>)
-  args?: Array<any>
-  descriptions: Array<string>
-  trace: string | undefined
-  description(): string
-  toJSON(): JSONRootType<J>
-  assert(value: unknown): T
-}
-
-export type TypeKey = typeof TypeKey
-export const TypeKey = Symbol.for("Liminal/Type")
-
-export function isType(value: unknown): value is Type {
-  return typeof value === "function" && TypeKey in value
-}

package/types/TypeContext.ts

@@ -1,19 +0,0 @@
-import type { Type } from "./Type.js"
-
-export class TypeContext {
-  root: Type
-  ids: Map<Type, string>
-  constructor(root: Type, ids: Map<Type, string> = new Map()) {
-    this.root = root
-    this.ids = ids
-  }
-
-  id(type: Type): string {
-    let id = this.ids.get(type)
-    if (id === undefined) {
-      id = this.ids.size.toString()
-      this.ids.set(type, id)
-    }
-    return id
-  }
-}

package/types/TypeLike.ts

@@ -1,60 +0,0 @@
-import type { Falsy } from "../util/Falsy.ts"
-import type { JSONKey } from "../util/JSONKey.ts"
-import { const as const_, type JSONConstType } from "./const.ts"
-import { type JSONNullType, null as null_ } from "./null.ts"
-import { _object, type JSONObjectType } from "./object.ts"
-import { type JSONStringType, string } from "./string.ts"
-import { isType, type Type } from "./Type.ts"
-
-export type TypeLike = Type | TypeLikes | string | Falsy
-export type TypeLikes = TypeLikeArray | TypeLikeRecord
-
-export type TypeLikeArray = Array<TypeLike>
-export type TypeLikeRecord = {
-  [key: JSONKey]: TypeLike
-}
-
-export type NormalizeTypeLikesT<F extends TypeLikes> =
-  & {
-    -readonly [K in keyof F as F extends TypeLikeArray ? K extends `${number}` ? K : never : K]: NormalizeTypeLikeT<
-      Extract<F[K], TypeLike>
-    >
-  }
-  & {}
-
-export type NormalizeTypeLikeT<V extends TypeLike> = V extends TypeLikes ? NormalizeTypeLikesT<V>
-  : V extends string ? V
-  : V extends Type<infer T> ? T
-  : null
-
-export type NormalizeTypeLikesJ<F extends TypeLikes> =
-  & {
-    -readonly [K in keyof F as F extends TypeLikeArray ? K extends `${number}` ? K : never : K]: NormalizeTypeLikeJ<
-      Extract<F[K], TypeLike>
-    >
-  }
-  & {}
-
-export type NormalizeTypeLikeJ<V extends TypeLike> = V extends TypeLikes ? JSONObjectType<NormalizeTypeLikesJ<V>>
-  : V extends string ? JSONConstType<JSONStringType, V>
-  : V extends Type<any, infer J> ? J
-  : JSONNullType
-
-export function normalizeTypeLikes(fields: TypeLikes): Type {
-  return (Array.isArray(fields)
-    ? _object(fields.map(normalizeTypeLike))
-    : _object(Object.fromEntries(Object.entries(fields).map(([k, v]) => [k, normalizeTypeLike(v)]))))
-}
-
-export function normalizeTypeLike(value: TypeLike): Type {
-  if (!value) {
-    return null_
-  }
-  if (typeof value === "string") {
-    return const_(string, value)
-  }
-  if (isType(value)) {
-    return value
-  }
-  return normalizeTypeLikes(value)
-}

package/types/TypeVisitor.ts

@@ -1,49 +0,0 @@
-import type { Type } from "./Type.ts"
-import { type IntrinsicTypes, typeName } from "./type_common.ts"
-
-export type VisitorArms<S, R> =
-  & {
-    hook?: (
-      next: (state: S, type: Type) => R,
-      state: S,
-      type: Type,
-    ) => R
-  }
-  & (
-    | (
-      & IntrinsicVisitorArms<S, R>
-      & { fallback?: never }
-    )
-    | (
-      & Partial<IntrinsicVisitorArms<S, R>>
-      & { fallback: () => R }
-    )
-  )
-
-export type IntrinsicVisitorArms<S, R> = {
-  [K in keyof IntrinsicTypes]: (
-    state: S,
-    ...args: IntrinsicTypes[K] extends Type ? [IntrinsicTypes[K]]
-      : IntrinsicTypes[K] extends (...args: infer A) => infer T ? [T, ...A]
-      : never
-  ) => R
-}
-
-export type TypeVisitor<S, R> = (state: S, type: Type) => R
-
-export function TypeVisitor<S, R>(arms: VisitorArms<S, R>): (state: S, type: Type) => R {
-  const { hook } = arms
-  if (hook) {
-    return (state, type) => hook(next, state, type)
-  }
-
-  return next
-
-  function next(state: S, type: Type): R {
-    return (arms[typeName(type)] as any ?? arms.fallback)(
-      state,
-      type,
-      ...(type.args ?? []),
-    )
-  }
-}

package/types/array.ts

@@ -1,20 +0,0 @@
-import type { JSONType } from "./JSONType.ts"
-import type { JSONTypeBase } from "./JSONTypeBase.ts"
-import { makeType } from "./makeType.ts"
-import type { Type } from "./Type.ts"
-import { normalizeTypeLike, type NormalizeTypeLikeJ, type NormalizeTypeLikeT, type TypeLike } from "./TypeLike.ts"
-
-export function array<const F extends TypeLike>(
-  element: F,
-): Type<Array<NormalizeTypeLikeT<F>>, JSONArrayType<NormalizeTypeLikeJ<F>>> {
-  return _array(normalizeTypeLike(element)) as never
-}
-
-export function _array(element: Type): Type {
-  return makeType(() => _array, [element])
-}
-
-export interface JSONArrayType<E extends JSONType = any> extends JSONTypeBase {
-  type: "array"
-  items: E
-}

package/types/boolean.ts

@@ -1,9 +0,0 @@
-import type { JSONTypeBase } from "./JSONTypeBase.ts"
-import { makeType } from "./makeType.ts"
-import type { Type } from "./Type.ts"
-
-export const boolean: Type<boolean, JSONBooleanType> = makeType(() => boolean)
-
-export interface JSONBooleanType extends JSONTypeBase {
-  type: "boolean"
-}

package/types/const.ts

@@ -1,17 +0,0 @@
-import type { JSONValue } from "../util/JSONValue.ts"
-import type { ConstableType } from "./JSONType.ts"
-import { makeType } from "./makeType.ts"
-import type { Type } from "./Type.ts"
-
-function const_<T extends JSONValue, J extends ConstableType, const V extends T>(
-  type: Type<T, J>,
-  value: V,
-): Type<V, JSONConstType<J, V>> {
-  return makeType(() => const_<T, J, V>, [type, value])
-}
-Object.defineProperty(const_, "name", { value: "const" })
-export { const_ as const }
-
-export type JSONConstType<J extends ConstableType = any, V extends JSONValue = JSONValue> = J & {
-  const: V
-}

package/types/enum.ts

@@ -1,14 +0,0 @@
-import type { JSONTypeBase } from "./JSONTypeBase.ts"
-import { makeType } from "./makeType.ts"
-import type { Type } from "./Type.ts"
-
-export { enum_ as enum }
-function enum_<A extends Array<string>>(...values: A): Type<A[number], JSONEnumType<A[number]>> {
-  return makeType(() => enum_<A>, values)
-}
-Object.defineProperty(enum_, "name", { value: "enum" })
-
-export interface JSONEnumType<K extends string = string> extends JSONTypeBase {
-  type: "string"
-  enum: Array<K>
-}

package/types/factories.ts

@@ -1,8 +0,0 @@
-export { array } from "./array.ts"
-export { boolean, const, enum, integer, null, number, ref, string } from "./intrinsics.ts"
-export { MetatypeDescriptor, MetatypeRootDescriptor } from "./Metatype/MetatypeDescriptor.ts"
-export { object } from "./object.ts"
-export { option } from "./types_derived/option.ts"
-export { taggedUnion } from "./types_derived/taggedUnion.ts"
-export { wrapper } from "./types_derived/wrapper.ts"
-export { union } from "./union.ts"

package/types/index.ts

@@ -1,2 +0,0 @@
-export * from "./factories.ts"
-export * from "./non_factories.ts"

package/types/integer.ts

@@ -1,9 +0,0 @@
-import type { JSONTypeBase } from "./JSONTypeBase.ts"
-import { makeType } from "./makeType.ts"
-import type { Type } from "./Type.ts"
-
-export const integer: Type<number, JSONIntegerType> = makeType(() => integer)
-
-export interface JSONIntegerType extends JSONTypeBase {
-  type: "integer"
-}

package/types/intrinsics.ts

@@ -1,11 +0,0 @@
-export { _array } from "./array.ts"
-export { boolean } from "./boolean.ts"
-export { const } from "./const.ts"
-export { enum } from "./enum.ts"
-export { integer } from "./integer.ts"
-export { null } from "./null.ts"
-export { number } from "./number.ts"
-export { _object } from "./object.ts"
-export { ref } from "./ref.ts"
-export { string } from "./string.ts"
-export { _union } from "./union.ts"