@nmtjs/type 0.6.4 → 0.7.0

package/src/parse.ts

@@ -1,217 +0,0 @@
-// --------------------------------------------------------------------------
-// Iterators
-// --------------------------------------------------------------------------
-
-/** Returns true if this value is an async iterator */
-export function IsAsyncIterator(value) {
-  return IsObject(value) && Symbol.asyncIterator in value
-}
-/** Returns true if this value is an iterator */
-export function IsIterator(value) {
-  return IsObject(value) && Symbol.iterator in value
-}
-// --------------------------------------------------------------------------
-// Object Instances
-// --------------------------------------------------------------------------
-/** Returns true if this value is not an instance of a class */
-export function IsStandardObject(value) {
-  return (
-    IsObject(value) &&
-    (Object.getPrototypeOf(value) === Object.prototype ||
-      Object.getPrototypeOf(value) === null)
-  )
-}
-/** Returns true if this value is an instance of a class */
-export function IsInstanceObject(value) {
-  return (
-    IsObject(value) &&
-    !IsArray(value) &&
-    IsFunction(value.constructor) &&
-    value.constructor.name !== 'Object'
-  )
-}
-// --------------------------------------------------------------------------
-// JavaScript
-// --------------------------------------------------------------------------
-/** Returns true if this value is a Promise */
-export function IsPromise(value) {
-  return value instanceof Promise
-}
-/** Returns true if this value is a Date */
-export function IsDate(value) {
-  return value instanceof Date && Number.isFinite(value.getTime())
-}
-/** Returns true if this value is an instance of Map<K, T> */
-export function IsMap(value) {
-  return value instanceof globalThis.Map
-}
-/** Returns true if this value is an instance of Set<T> */
-export function IsSet(value) {
-  return value instanceof globalThis.Set
-}
-/** Returns true if this value is RegExp */
-export function IsRegExp(value) {
-  return value instanceof globalThis.RegExp
-}
-/** Returns true if this value is a typed array */
-export function IsTypedArray(value) {
-  return ArrayBuffer.isView(value)
-}
-/** Returns true if the value is a Int8Array */
-export function IsInt8Array(value) {
-  return value instanceof globalThis.Int8Array
-}
-/** Returns true if the value is a Uint8Array */
-export function IsUint8Array(value) {
-  return value instanceof globalThis.Uint8Array
-}
-/** Returns true if the value is a Uint8ClampedArray */
-export function IsUint8ClampedArray(value) {
-  return value instanceof globalThis.Uint8ClampedArray
-}
-/** Returns true if the value is a Int16Array */
-export function IsInt16Array(value) {
-  return value instanceof globalThis.Int16Array
-}
-/** Returns true if the value is a Uint16Array */
-export function IsUint16Array(value) {
-  return value instanceof globalThis.Uint16Array
-}
-/** Returns true if the value is a Int32Array */
-export function IsInt32Array(value) {
-  return value instanceof globalThis.Int32Array
-}
-/** Returns true if the value is a Uint32Array */
-export function IsUint32Array(value) {
-  return value instanceof globalThis.Uint32Array
-}
-/** Returns true if the value is a Float32Array */
-export function IsFloat32Array(value) {
-  return value instanceof globalThis.Float32Array
-}
-/** Returns true if the value is a Float64Array */
-export function IsFloat64Array(value) {
-  return value instanceof globalThis.Float64Array
-}
-/** Returns true if the value is a BigInt64Array */
-export function IsBigInt64Array(value) {
-  return value instanceof globalThis.BigInt64Array
-}
-/** Returns true if the value is a BigUint64Array */
-export function IsBigUint64Array(value) {
-  return value instanceof globalThis.BigUint64Array
-}
-// --------------------------------------------------------------------------
-// PropertyKey
-// --------------------------------------------------------------------------
-/** Returns true if this value has this property key */
-export function HasPropertyKey(value, key) {
-  return key in value
-}
-// --------------------------------------------------------------------------
-// Standard
-// --------------------------------------------------------------------------
-/** Returns true of this value is an object type */
-export function IsObject(value) {
-  return value !== null && typeof value === 'object'
-}
-/** Returns true if this value is an array, but not a typed array */
-export function IsArray(value) {
-  return Array.isArray(value) && !ArrayBuffer.isView(value)
-}
-/** Returns true if this value is an undefined */
-export function IsUndefined(value) {
-  return value === undefined
-}
-/** Returns true if this value is an null */
-export function IsNull(value) {
-  return value === null
-}
-/** Returns true if this value is an boolean */
-export function IsBoolean(value) {
-  return typeof value === 'boolean'
-}
-/** Returns true if this value is an number */
-export function IsNumber(value) {
-  return typeof value === 'number'
-}
-/** Returns true if this value is an integer */
-export function IsInteger(value) {
-  return Number.isInteger(value)
-}
-/** Returns true if this value is bigint */
-export function IsBigInt(value) {
-  return typeof value === 'bigint'
-}
-/** Returns true if this value is string */
-export function IsString(value) {
-  return typeof value === 'string'
-}
-/** Returns true if this value is a function */
-export function IsFunction(value) {
-  return typeof value === 'function'
-}
-/** Returns true if this value is a symbol */
-export function IsSymbol(value) {
-  return typeof value === 'symbol'
-}
-/** Returns true if this value is a value type such as number, string, boolean */
-export function IsValueType(value) {
-  // prettier-ignore
-  return (
-    IsBigInt(value) ||
-    IsBoolean(value) ||
-    IsNull(value) ||
-    IsNumber(value) ||
-    IsString(value) ||
-    IsSymbol(value) ||
-    IsUndefined(value)
-  )
-}
-
-// ------------------------------------------------------------------
-// Clonable
-// ------------------------------------------------------------------
-function FromObject(value, exclude) {
-  const Acc = {}
-  for (const key of Object.getOwnPropertyNames(value)) {
-    Acc[key] = Clone(value[key], exclude)
-  }
-  for (const key of Object.getOwnPropertySymbols(value)) {
-    Acc[key] = Clone(value[key], exclude)
-  }
-  return Acc
-}
-function FromArray(value, exclude) {
-  return value.map((element) => Clone(element, exclude))
-}
-function FromTypedArray(value) {
-  return value.slice()
-}
-function FromMap(value, exclude) {
-  return new Map(Clone([...value.entries()], exclude))
-}
-function FromSet(value, exclude) {
-  return new Set(Clone([...value.entries()], exclude))
-}
-function FromDate(value) {
-  return new Date(value.toISOString())
-}
-function FromValue(value) {
-  return value
-}
-// ------------------------------------------------------------------
-// Clone
-// ------------------------------------------------------------------
-/** Returns a clone of the given value */
-export function Clone(value, exclude?: Set<any>) {
-  if (IsArray(value)) return FromArray(value, exclude)
-  if (IsDate(value)) return FromDate(value)
-  if (IsTypedArray(value)) return FromTypedArray(value)
-  if (IsMap(value)) return FromMap(value, exclude)
-  if (IsSet(value)) return FromSet(value, exclude)
-  if (IsObject(value)) return FromObject(value, exclude)
-  if (IsValueType(value)) return FromValue(value)
-  if (exclude?.has(value.constructor)) return value
-  throw new Error('Cannot clone value')
-}

package/src/runtime.ts

@@ -1,137 +0,0 @@
-import type { ClassConstructor } from '@nmtjs/common'
-import type { TSchema } from '@sinclair/typebox'
-import type { ValueErrorIterator } from '@sinclair/typebox/compiler'
-import {
-  TransformDecode,
-  TransformEncode,
-  Value,
-} from '@sinclair/typebox/value'
-import { register } from './formats.ts'
-import type {
-  StaticInputEncode,
-  StaticOutputDecode,
-  StaticOutputEncode,
-} from './inference.ts'
-import { Clone } from './parse.ts'
-import { IsDiscriminatedUnion } from './schemas/discriminated-union.ts'
-import type { BaseType } from './types/base.ts'
-
-// register ajv formats
-register()
-
-export type CloneOptions = {
-  clone?: boolean
-  exclude?: Set<any>
-}
-
-export type ValidationError = {
-  path: string
-  message: string
-  value: unknown
-}
-
-// TODO: this one is very slow
-export function _applyDefaults(schema: TSchema, value: any) {
-  return Value.Default(schema, value)
-}
-
-// TODO: this one is very slow
-// Clone -> Clean -> Convert
-export function _parse(
-  schema: TSchema,
-  value: any,
-  cloneOptions?: CloneOptions,
-) {
-  if (cloneOptions?.clone !== false) {
-    value = Clone(value, cloneOptions?.exclude)
-  }
-  return Value.Clean(schema, Value.Convert(schema, value))
-}
-
-export function _traversErrors(errors: ValueErrorIterator) {
-  const result: ValidationError[] = []
-
-  for (const error of errors) {
-    if (IsDiscriminatedUnion(error.schema)) {
-      const discriminator = error.schema.discriminator
-      const discriminatorValue = error.value?.[discriminator]
-      if (discriminatorValue !== undefined) {
-        const variantSchema = error.schema.anyOf.find(
-          (schema) =>
-            schema.properties[discriminator].const === discriminatorValue,
-        )
-        if (variantSchema) {
-          const propertiesSchemas: TSchema[] = []
-          for (const element in variantSchema.properties) {
-            const propertySchema = variantSchema.properties[element]
-            if (propertySchema !== variantSchema.properties[discriminator]) {
-              propertiesSchemas.push(propertySchema)
-            }
-          }
-
-          for (const iter of error.errors) {
-            for (const err of iter) {
-              if (!propertiesSchemas.includes(err.schema)) continue
-              result.push({
-                path: err.path,
-                message: err.message,
-                value: err.value,
-              })
-            }
-          }
-
-          continue
-        }
-      }
-    }
-
-    result.push({
-      path: error.path,
-      message: error.message,
-      value: error.value,
-    })
-
-    for (const nestedError of error.errors) {
-      result.push(..._traversErrors(nestedError))
-    }
-  }
-
-  return result
-}
-
-export function applyDefaults(type: BaseType, value: unknown) {
-  return _applyDefaults(type.schema, value)
-}
-
-export function parse(
-  type: BaseType,
-  value: unknown,
-  cloneOptions?: CloneOptions,
-) {
-  return _parse(type.schema, value, cloneOptions)
-}
-
-export function errors(type: BaseType, value: unknown): ValidationError[] {
-  return _traversErrors(Value.Errors(type.schema, value))
-}
-
-export function check<T extends BaseType>(
-  type: T,
-  value: unknown,
-): value is StaticInputEncode<T['schema']> {
-  return Value.Check(type.schema, value)
-}
-
-export function decode<T extends BaseType>(
-  type: T,
-  value: unknown,
-): StaticOutputDecode<T['schema']> {
-  return TransformDecode(type.schema, [], value)
-}
-
-export function encode<T extends BaseType>(
-  type: T,
-  value: unknown,
-): StaticOutputEncode<T['schema']> {
-  return TransformEncode(type.schema, [], value)
-}

package/src/schemas/default.ts

@@ -1,12 +0,0 @@
-import type { TSchema } from '@sinclair/typebox'
-
-export type TDefault<Type extends TSchema, Default = unknown> = Type & {
-  default: Default
-}
-
-export function Default<Type extends TSchema, const Default>(
-  type: Type,
-  default_: Default,
-): TDefault<Type, Default> {
-  return { ...type, default: default_ } as never
-}

package/src/schemas/discriminated-union.ts

@@ -1,49 +0,0 @@
-import {
-  KindGuard,
-  type TLiteral,
-  type TObject,
-  type TPropertyKey,
-  type TSchema,
-  type TUnion,
-  Type,
-  TypeGuard,
-  ValueGuard,
-} from '@sinclair/typebox'
-
-export function IsDiscriminatedUnion(
-  schema: TSchema,
-): schema is TDiscriminatedUnion {
-  return (
-    TypeGuard.IsUnion(schema) &&
-    'discriminator' in schema &&
-    ValueGuard.IsString(schema.discriminator) &&
-    schema.anyOf.every(
-      (variant) =>
-        KindGuard.IsObject(variant) &&
-        KindGuard.IsLiteralString(variant.properties[schema.discriminator]),
-    )
-  )
-}
-
-export type DiscriminatedUnionProperties<K extends string = string> = {
-  [OK in K]: TLiteral<any>
-} & {
-  [OK in TPropertyKey]: any
-}
-
-export interface TDiscriminatedUnion<
-  K extends string = string,
-  T extends TObject<DiscriminatedUnionProperties<K>>[] = TObject<
-    DiscriminatedUnionProperties<K>
-  >[],
-> extends TUnion<T> {
-  discriminator: K
-  anyOf: T
-}
-
-export function DiscriminatedUnion<
-  K extends string,
-  T extends TObject<DiscriminatedUnionProperties<K>>[],
->(key: K, types: T): TDiscriminatedUnion<K, T> {
-  return Type.Union(types, { discriminator: key }) as any
-}

package/src/schemas/nullable.ts

@@ -1,20 +0,0 @@
-import {
-  type SchemaOptions,
-  type TNull,
-  type TSchema,
-  type TUnion,
-  Type,
-} from '@sinclair/typebox/type'
-
-export type TNullable<T extends TSchema> = TUnion<[T, TNull]>
-export const Nullable = <T extends TSchema>(
-  schema: T,
-  options: SchemaOptions = {},
-) => {
-  const { default: _default } = schema
-
-  return Type.Union([schema, Type.Null()], {
-    default: _default,
-    ...options,
-  })
-}