liminal 0.4.0 → 0.5.1

package/types/JSONType.ts

@@ -0,0 +1,27 @@
+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

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

package/types/Metatype/MetatypeDescriptor.ts

@@ -0,0 +1,80 @@
+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

@@ -0,0 +1,52 @@
+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

@@ -0,0 +1,46 @@
+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>
+  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

@@ -0,0 +1,19 @@
+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

@@ -0,0 +1,60 @@
+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

@@ -0,0 +1,49 @@
+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

@@ -0,0 +1,20 @@
+import { declareType } from "./declareType.ts"
+import type { JSONType } from "./JSONType.ts"
+import type { JSONTypeBase } from "./JSONTypeBase.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 declareType(() => _array, [element])
+}
+
+export interface JSONArrayType<E extends JSONType = any> extends JSONTypeBase {
+  type: "array"
+  items: E
+}

package/types/boolean.ts

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

package/types/const.ts

@@ -0,0 +1,17 @@
+import type { JSONValue } from "../util/JSONValue.ts"
+import { declareType } from "./declareType.ts"
+import type { ConstableType } from "./JSONType.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 declareType(() => 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/declareType.ts

@@ -0,0 +1,71 @@
+import type { StandardSchemaV1 } from "@standard-schema/spec"
+import { infer } from "../actions/infer.ts"
+import { LiminalAssertionError } from "../LiminalAssertionError.ts"
+import type { Falsy } from "../util/Falsy.ts"
+import { applyTemplateWithIndentation } from "../util/fixTemplateStrings.ts"
+import { isTemplateStringsArray } from "../util/isTemplateStringsArray.ts"
+import type { JSONObject } from "../util/JSONObject.ts"
+import { AssertDiagnostics, formatAssertDiagnostics } from "./AssertDiagnostics.ts"
+import type { JSONObjectType } from "./object.ts"
+import { toJSON } from "./toJSON.ts"
+import { type Type, TypeKey, type TypeMembers } from "./Type.ts"
+
+export function declareType<X extends Type>(
+  declaration: () => X | ((...args: any) => X),
+  args?: Array<unknown>,
+  descriptions: Array<string> = [],
+): X {
+  const type = Object.assign(
+    Type,
+    {
+      [TypeKey]: true,
+      declaration,
+      args,
+      descriptions,
+      description() {
+        return descriptions.join("\n")
+      },
+      "~standard": {
+        vendor: "liminal",
+        version: 1,
+        validate: (value) => {
+          const diagnostics = AssertDiagnostics({}, type as never, value)
+          if (diagnostics.length) {
+            return {
+              issues: diagnostics.map(({ path, error }): StandardSchemaV1.Issue => ({
+                path,
+                message: JSON.stringify(error),
+              })),
+            }
+          }
+          return { value: value as X["T"] }
+        },
+      },
+      toJSON,
+      assert: (value) => {
+        const diagnostics = AssertDiagnostics({}, type as never, value)
+        if (diagnostics.length) {
+          throw new LiminalAssertionError(formatAssertDiagnostics(diagnostics))
+        }
+        return value as never
+      },
+      ...{
+        *[Symbol.iterator](this: Type<JSONObject, JSONObjectType>) {
+          return yield* infer(this)
+        },
+      },
+    } satisfies TypeMembers<X["T"], X["J"]>,
+  ) as never as X
+  return type
+
+  function Type(template: TemplateStringsArray, ...substitutions: Array<string>): X
+  function Type(...values: Array<Falsy | string>): X
+  function Type(e0: TemplateStringsArray | Falsy | string, ...eRest: Array<Falsy | string>): X {
+    return declareType(declaration, args, [
+      ...descriptions,
+      ...isTemplateStringsArray(e0)
+        ? [applyTemplateWithIndentation(e0, ...eRest)]
+        : [e0, ...eRest].filter((v): v is string => !!v),
+    ])
+  }
+}

package/types/enum.ts

@@ -0,0 +1,14 @@
+import { declareType } from "./declareType.ts"
+import type { JSONTypeBase } from "./JSONTypeBase.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 declareType(() => 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

@@ -0,0 +1,8 @@
+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

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

package/types/integer.ts

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

package/types/intrinsics.ts

@@ -0,0 +1,11 @@
+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"

package/types/match.ts

@@ -0,0 +1,13 @@
+import type { JSONValue } from "../util/JSONValue.ts"
+import { AssertDiagnostics } from "./AssertDiagnostics.ts"
+import type { Type } from "./Type.ts"
+
+export function match(value: JSONValue, members: Array<Type>): Type | undefined {
+  for (const member of members) {
+    const diagnostics = AssertDiagnostics({}, member, value)
+    if (!diagnostics.length) {
+      return member
+    }
+  }
+  return
+}

package/types/non_factories.ts

@@ -0,0 +1,26 @@
+export type { JSONArrayType } from "./array.ts"
+export type { JSONBooleanType } from "./boolean.ts"
+export type { JSONConstType } from "./const.ts"
+export type { JSONEnumType } from "./enum.ts"
+export type { JSONIntegerType } from "./integer.ts"
+export * from "./JSONRootType.ts"
+export * from "./JSONType.ts"
+export { match } from "./match.ts"
+export * from "./Metatype/fromMetatypeDescriptor.ts"
+export type { MetatypeDescriptor, MetatypeRootDescriptor } from "./Metatype/MetatypeDescriptor.ts"
+export type { JSONNullType } from "./null.ts"
+export type { JSONNumberType } from "./number.ts"
+export type {
+  JSONObjectType,
+  ObjectFields as _ObjectFields,
+  RecordFields as _RecordFields,
+  TupleFields as _TupleFields,
+} from "./object.ts"
+export type { JSONRefType } from "./ref.ts"
+export type { JSONStringType } from "./string.ts"
+export * from "./Type.ts"
+export * from "./TypeContext.ts"
+export * from "./TypeLike.ts"
+export type { TaggedUnionMembers } from "./types_derived/taggedUnion.ts"
+export * from "./TypeVisitor.ts"
+export type { JSONUnionType } from "./union.ts"

package/types/null.ts

@@ -0,0 +1,10 @@
+import { declareType } from "./declareType.ts"
+import type { JSONTypeBase } from "./JSONTypeBase.ts"
+import type { Type } from "./Type.ts"
+
+const null_: Type<null, JSONNullType> = declareType(() => null_)
+export { null_ as null }
+
+export interface JSONNullType extends JSONTypeBase {
+  type: "null"
+}

package/types/number.ts

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

package/types/object.ts

@@ -0,0 +1,27 @@
+import type { JSONKey } from "../util/JSONKey.ts"
+import { declareType } from "./declareType.ts"
+import type { JSONType } from "./JSONType.ts"
+import type { JSONTypeBase } from "./JSONTypeBase.ts"
+import { type Type } from "./Type.ts"
+import { normalizeTypeLikes, type NormalizeTypeLikesJ, type NormalizeTypeLikesT, type TypeLikes } from "./TypeLike.ts"
+
+export function object<const F extends TypeLikes>(
+  fields: F,
+): Type<NormalizeTypeLikesT<F>, JSONObjectType<NormalizeTypeLikesJ<F>>> {
+  return normalizeTypeLikes(fields) as never
+}
+
+export function _object(fields: ObjectFields): Type {
+  return declareType(() => _object, [fields])
+}
+
+export interface JSONObjectType<F extends Record<JSONKey, JSONType> = any> extends JSONTypeBase {
+  type: "object"
+  properties: F
+  required: Array<keyof F>
+  additionalProperties: false
+}
+
+export type ObjectFields = TupleFields | RecordFields
+export type TupleFields = Array<Type>
+export type RecordFields = Record<JSONKey, Type>

package/types/ref.ts

@@ -0,0 +1,12 @@
+import type { JSONValue } from "../util/JSONValue.ts"
+import { declareType } from "./declareType.ts"
+import type { ConstableType } from "./JSONType.ts"
+import type { Type } from "./Type.ts"
+
+export function ref<T extends JSONValue, J extends ConstableType>(getType: () => Type<T, J>): Type<T, JSONRefType> {
+  return declareType(() => ref<T, J>, [getType])
+}
+
+export interface JSONRefType {
+  $ref: string
+}

package/types/string.ts

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