Revision 0.8.0 (#9)

- Rename to TypeMap

src/compile/compile.ts

@@ -0,0 +1,120 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typemap
+
+The MIT License (MIT)
+
+Copyright (c) 2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import { TypeCompiler, TypeCheck, ValueErrorIterator } from '@sinclair/typebox/compiler'
+import { Value } from '@sinclair/typebox/value'
+import { TypeBox, TTypeBox } from '../typebox/typebox'
+import { StandardSchemaV1 } from './standard'
+import { IsEvalSupported } from './environment'
+import * as t from '@sinclair/typebox'
+
+// ------------------------------------------------------------------
+// StandardSchemaProps
+// ------------------------------------------------------------------
+export class StandardSchemaProps<Type extends t.TSchema> implements StandardSchemaV1.Props<Type, t.Static<Type>> {
+  readonly #check: TypeCheck<Type>
+  constructor(check: TypeCheck<Type>) {
+    this.#check = check
+  }
+  // ----------------------------------------------------------------
+  // StandardSchemaV1.Props<Type, t.Static<Type>>
+  // ----------------------------------------------------------------
+  public get vendor(): '@sinclair/typemap' {
+    return '@sinclair/typemap'
+  }
+  public get version(): 1 {
+    return 1
+  }
+  public get types(): { input: Type; output: t.Static<Type> } {
+    return { input: this.#check.Schema(), output: null }
+  }
+  public validate(value: unknown): StandardSchemaV1.Result<t.Static<Type>> {
+    return this.#check.Check(value) ? this.#createValue(value) : this.#createIssues(value)
+  }
+  // ----------------------------------------------------------------
+  // Internal
+  // ----------------------------------------------------------------
+  #createIssues(value: unknown) {
+    const errors = [...Value.Errors(this.#check.Schema(), value)]
+    const issues: StandardSchemaV1.Issue[] = errors.map((error) => ({ ...error, path: [error.path] }))
+    return { issues }
+  }
+  #createValue(value: unknown) {
+    return { value }
+  }
+}
+// ------------------------------------------------------------------
+// Validator<TSchema>
+// ------------------------------------------------------------------
+export class Validator<Type extends t.TSchema> implements StandardSchemaV1<Type, t.Static<Type>> {
+  readonly #standard: StandardSchemaProps<Type>
+  readonly #check: TypeCheck<Type>
+  constructor(check: TypeCheck<Type>) {
+    this.#standard = new StandardSchemaProps<Type>(check)
+    this.#check = check
+  }
+  /** Standard Schema Interface */
+  public get ['~standard'](): StandardSchemaProps<Type> {
+    return this.#standard
+  }
+  /** Parses this value. Do not use this function for high throughput validation */
+  public Parse(value: unknown): t.StaticDecode<Type> {
+    return Value.Parse(this.#check.Schema(), value)
+  }
+  /** Checks if this value matches the type */
+  public Check(value: unknown): value is t.Static<Type> {
+    return this.#check.Check(value)
+  }
+  /** Returns errors for this value */
+  public Errors(value: unknown): ValueErrorIterator {
+    return this.#check.Errors(value)
+  }
+}
+// ------------------------------------------------------------------
+// CompileDynamic
+// ------------------------------------------------------------------
+// prettier-ignore
+function CompileDynamic<Type extends t.TSchema>(type: Type, references: t.TSchema[] = []): TypeCheck<Type> {
+  return new TypeCheck(type, references, value => Value.Check(type, references, value), TypeCompiler.Code(type, references))  
+}
+// ------------------------------------------------------------------
+// Compile
+// ------------------------------------------------------------------
+/** Compiles a type for high performance validation */
+// prettier-ignore
+type TCompile<Type extends object | string,
+  Schema extends t.TSchema = TTypeBox<Type>,
+  Result extends Validator<Schema> = Validator<Schema>
+> = Result
+/** Compiles a type for high performance validation */
+// prettier-ignore
+export function Compile<Type extends object | string>(type: Type): TCompile<Type> {
+  const schema = TypeBox(type)
+  const check = IsEvalSupported() ? TypeCompiler.Compile(schema) : CompileDynamic(schema)
+  return new Validator(check)
+}