@nmtjs/type 0.6.4 → 0.7.0

package/package.json

@@ -3,30 +3,18 @@
   "type": "module",
   "exports": {
     ".": {
-      "bun": "./src/index.ts",
-      "default": "./dist/index.js",
+      "import": "./dist/index.js",
       "types": "./src/index.ts"
     },
-    "./compiler": {
-      "bun": "./src/compiler.ts",
-      "default": "./dist/compiler.js",
-      "types": "./src/compiler.ts"
-    },
-    "./runtime": {
-      "bun": "./src/runtime.ts",
-      "default": "./dist/runtime.js",
-      "types": "./src/runtime.ts"
-    },
     "./temporal": {
-      "bun": "./src/temporal.ts",
-      "default": "./dist/temporal.js",
+      "import": "./dist/temporal.js",
       "types": "./src/temporal.ts"
     }
   },
   "dependencies": {
-    "@sinclair/typebox": "^0.34.13",
-    "temporal-polyfill": "^0.2.5",
-    "@nmtjs/common": "0.6.4"
+    "@zod/mini": "4.0.0-beta.0",
+    "temporal-polyfill": "^0.3.0",
+    "@nmtjs/common": "0.7.0"
   },
   "files": [
     "src",
@@ -34,9 +22,9 @@
     "LICENSE.md",
     "README.md"
   ],
-  "version": "0.6.4",
+  "version": "0.7.0",
   "scripts": {
-    "build": "neemata-build -p neutral --root=./src './**/*.ts'",
+    "build": "neemata-build --root=./src './**/*.ts'",
     "type-check": "tsc --noEmit"
   }
 }

package/src/index.ts

@@ -1,19 +1,17 @@
-import type {
-  StaticInputDecode,
-  StaticInputEncode,
-  StaticOutputDecode,
-  StaticOutputEncode,
-} from './inference.ts'
 import { AnyType } from './types/any.ts'
 import { ArrayType } from './types/array.ts'
 import type { BaseTypeAny } from './types/base.ts'
 import { BooleanType } from './types/boolean.ts'
 import { CustomType } from './types/custom.ts'
 import { DateType } from './types/date.ts'
-import { EnumType, ObjectEnumType } from './types/enum.ts'
+import { EnumType } from './types/enum.ts'
 import { LiteralType } from './types/literal.ts'
 import { NeverType } from './types/never.ts'
-import { BigIntType, IntegerType, NumberType } from './types/number.ts'
+import {
+  // BigIntType,
+  IntegerType,
+  NumberType,
+} from './types/number.ts'
 import {
   extend,
   keyof,
@@ -31,8 +29,7 @@ import {
   UnionType,
 } from './types/union.ts'
 
-export type { TSchema } from '@sinclair/typebox'
-export * from './schemas/nullable.ts'
+export { NeemataTypeError } from './types/base.ts'
 export { BaseType, type BaseTypeAny } from './types/base.ts'
 export {
   ArrayType,
@@ -49,23 +46,24 @@ export {
   UnionType,
   AnyType,
   NeverType,
+  DiscriminatedUnionType,
+  RecordType,
 }
 
 export namespace type {
   export namespace infer {
-    export type decoded<T extends BaseTypeAny<any>> = StaticOutputDecode<
-      T['schema']
-    >
-    export type encoded<T extends BaseTypeAny<any>> = StaticOutputEncode<
-      T['schema']
-    >
+    export type decoded<T extends BaseTypeAny<any>> =
+      T['decodedZodType']['_zod']['output']
+
+    export type encoded<T extends BaseTypeAny<any>> =
+      T['encodedZodType']['_zod']['output']
+
     export namespace input {
-      export type decoded<T extends BaseTypeAny<any>> = StaticInputDecode<
-        T['schema']
-      >
-      export type encoded<T extends BaseTypeAny<any>> = StaticInputEncode<
-        T['schema']
-      >
+      export type decoded<T extends BaseTypeAny<any>> =
+        T['decodedZodType']['_zod']['input']
+
+      export type encoded<T extends BaseTypeAny<any>> =
+        T['encodedZodType']['_zod']['input']
     }
   }
 
@@ -74,16 +72,17 @@ export namespace type {
   export const string = StringType.factory
   export const number = NumberType.factory
   export const integer = IntegerType.factory
-  export const bitint = BigIntType.factory
+  // export const bitint = BigIntType.factory
   export const literal = LiteralType.factory
-  export const objectEnum = ObjectEnumType.factory
-  export const arrayEnum = EnumType.factory
+  export const enumeration = EnumType.factory
   export const date = DateType.factory
   export const array = ArrayType.factory
   export const record = RecordType.factory
   export const any = AnyType.factory
   export const or = UnionType.factory
   export const and = IntersactionType.factory
+  export const union = UnionType.factory
+  export const intersaction = IntersactionType.factory
   export const discriminatedUnion = DiscriminatedUnionType.factory
   export const custom = CustomType.factory
   export const object = Object.assign(ObjectType.factory.bind(ObjectType), {

package/src/temporal.ts

@@ -8,15 +8,15 @@ import {
   ZonedDateTimeType,
 } from './types/temporal.ts'
 
-export const plainDate = PlainDateType.factory
-export const plainDatetime = PlainDateTimeType.factory
-export const plainTime = PlainTimeType.factory
-export const zonedDatetime = ZonedDateTimeType.factory
-export const duration = DurationType.factory
-export const plainYearMonth = PlainYearMonthType.factory
-export const plainMonthDay = PlainMonthDayType.factory
+export const plainDate = PlainDateType
+export const plainDatetime = PlainDateTimeType
+export const plainTime = PlainTimeType
+export const zonedDatetime = ZonedDateTimeType
+export const duration = DurationType
+export const plainYearMonth = PlainYearMonthType
+export const plainMonthDay = PlainMonthDayType
 
-export {
+export type {
   DurationType,
   PlainDateTimeType,
   PlainDateType,

package/src/types/any.ts

@@ -1,8 +1,10 @@
-import { type TAny, Type } from '@sinclair/typebox'
+import { any, type ZodMiniAny } from '@zod/mini'
 import { BaseType } from './base.ts'
 
-export class AnyType extends BaseType<TAny, {}, any> {
+export class AnyType extends BaseType<ZodMiniAny> {
   static factory() {
-    return new AnyType(Type.Any())
+    return new AnyType({
+      encodedZodType: any(),
+    })
   }
 }

package/src/types/array.ts

@@ -1,38 +1,40 @@
 import {
-  type ArrayOptions,
-  type StaticDecode,
-  type TArray,
-  Type,
-} from '@sinclair/typebox'
+  array,
+  type core,
+  length,
+  maxLength,
+  minLength,
+  type ZodMiniArray,
+} from '@zod/mini'
 import { BaseType } from './base.ts'
 
+type Check = core.CheckFn<any[]> | core.$ZodCheck<any[]>
+
 export class ArrayType<T extends BaseType = BaseType> extends BaseType<
-  TArray<T['schema']>,
-  { element: T; options: ArrayOptions }
+  ZodMiniArray<T['encodedZodType']>,
+  ZodMiniArray<T['decodedZodType']>,
+  { element: T; checks: Check[] }
 > {
-  static factory<T extends BaseType>(element: T, options: ArrayOptions = {}) {
-    return new ArrayType<T>(Type.Array(element.schema, options))
+  static factory<T extends BaseType>(element: T, ...checks: Check[]) {
+    return new ArrayType<T>({
+      encodedZodType: array(element.encodedZodType).check(...checks),
+      decodedZodType: array(element.decodedZodType).check(...checks),
+      props: { element, checks },
+    })
   }
 
   min(value: number) {
-    return ArrayType.factory(this.props.element, {
-      ...this.props.options,
-      minItems: value,
-    })
+    const check = minLength(value)
+    return ArrayType.factory<T>(this.props.element, ...this.props.checks, check)
   }
 
   max(value: number) {
-    return ArrayType.factory(this.props.element, {
-      ...this.props.options,
-      maxItems: value,
-    })
+    const check = maxLength(value)
+    return ArrayType.factory<T>(this.props.element, ...this.props.checks, check)
   }
 
   length(value: number) {
-    return ArrayType.factory(this.props.element, {
-      ...this.props.options,
-      minItems: value,
-      maxItems: value,
-    })
+    const check = length(value)
+    return ArrayType.factory<T>(this.props.element, ...this.props.checks, check)
   }
 }

package/src/types/base.ts

@@ -1,139 +1,206 @@
-import { Optional, type TOptional, type TSchema } from '@sinclair/typebox'
-import { Default, type TDefault } from '../schemas/default.ts'
-import { Nullable, type TNullable } from '../schemas/nullable.ts'
+import {
+  _default,
+  core,
+  nullable,
+  optional,
+  registry,
+  type ZodMiniAny,
+  type ZodMiniArray,
+  type ZodMiniBoolean,
+  type ZodMiniDefault,
+  type ZodMiniEnum,
+  type ZodMiniInterface,
+  type ZodMiniIntersection,
+  type ZodMiniLiteral,
+  type ZodMiniNever,
+  type ZodMiniNullable,
+  type ZodMiniNumber,
+  type ZodMiniObject,
+  type ZodMiniOptional,
+  type ZodMiniPipe,
+  type ZodMiniRecord,
+  type ZodMiniString,
+  type ZodMiniType,
+  type ZodMiniUnion,
+} from '@zod/mini'
+
+export type PrimitiveValueType = string | number | boolean | null
+
+export type SimpleZodType =
+  | ZodMiniNever
+  | ZodMiniDefault
+  | ZodMiniNullable
+  | ZodMiniOptional
+  | ZodMiniString
+  | ZodMiniObject
+  | ZodMiniAny
+  | ZodMiniArray
+  | ZodMiniBoolean
+  | ZodMiniNumber
+  | ZodMiniEnum<any>
+  | ZodMiniLiteral<PrimitiveValueType>
+  | ZodMiniUnion
+  | ZodMiniIntersection
+  | ZodMiniInterface
+  | ZodMiniRecord
+  | ZodMiniPipe
+
+export type ZodType = SimpleZodType | ZodMiniType
 
 export type TypeProps = Record<string, any>
 
+export type TypeMetadata<T = any> = {
+  id?: string
+  description?: string
+  examples?: T[]
+  title?: string
+}
+
 export type TypeParams = {
-  optional?: boolean
-  nullable?: boolean
-  hasDefault?: boolean
   encode?: (value: any) => any
+  metadata?: TypeMetadata
 }
 
 export type DefaultTypeParams = {
-  optional: false
-  nullable: false
-  hasDefault: false
   encode?: TypeParams['encode']
+  metadata?: TypeMetadata
 }
 
-export type BaseTypeAny<T extends TSchema = TSchema> = BaseType<
-  T,
-  TypeProps,
-  any
->
+export type BaseTypeAny<
+  EncodedZodType extends SimpleZodType = SimpleZodType,
+  DecodedZodType extends ZodType = ZodMiniType,
+> = BaseType<EncodedZodType, DecodedZodType, TypeProps>
+
+export const typesRegistry = registry<TypeMetadata>()
+
+export const NeemataTypeError = core.$ZodError
+export type NeemataTypeError = core.$ZodError
 
 export abstract class BaseType<
-  Schema extends TSchema = TSchema,
+  EncodedZodType extends SimpleZodType = SimpleZodType,
+  DecodedZodType extends ZodType = EncodedZodType,
   Props extends TypeProps = TypeProps,
-  ValueType = unknown,
 > {
-  readonly schema: Schema
+  readonly encodedZodType: EncodedZodType
+  readonly decodedZodType: DecodedZodType
   readonly props: Props
   readonly params: TypeParams
 
-  constructor(
-    schema: Schema,
-    props: Props = {} as Props,
-    params: TypeParams = {} as TypeParams,
-  ) {
-    const { hasDefault = false, nullable = false, optional = false } = params
-    this.schema = schema
+  constructor({
+    encodedZodType,
+    decodedZodType = encodedZodType as unknown as DecodedZodType,
+    props = {} as Props,
+    params = {} as TypeParams,
+  }: {
+    encodedZodType: EncodedZodType
+    decodedZodType?: DecodedZodType
+    props?: Props
+    params?: TypeParams
+  }) {
+    this.encodedZodType = encodedZodType
+    this.decodedZodType = decodedZodType
 
     this.props = props
-    this.params = {
-      hasDefault,
-      nullable,
-      optional,
-    } as TypeParams
+    this.params = params
   }
 
-  optional(): OptionalType<BaseType<Schema, Props>, ValueType> {
-    return OptionalType.factory(this) as any
+  optional(): OptionalType<this> {
+    return OptionalType.factory(this)
   }
 
-  nullable(): NullableType<BaseType<Schema, Props>, ValueType> {
-    return NullableType.factory(this) as any
+  nullable(): NullableType<this> {
+    return NullableType.factory(this)
   }
 
   nullish() {
     return this.nullable().optional()
   }
 
-  default(value: ValueType): DefaultType<BaseType<Schema, Props>, ValueType> {
-    return DefaultType.factory(
-      this,
-      this.params.encode?.(value) ?? value,
-    ) as any
+  default(value: this['encodedZodType']['_zod']['input']): DefaultType<this> {
+    return DefaultType.factory(this, value)
+  }
+
+  title(title: string): this {
+    return this.meta({ title })
+  }
+
+  description(description: string): this {
+    return this.meta({ description })
+  }
+
+  examples(...examples: this['decodedZodType']['_zod']['input'][]): this {
+    return this.meta({
+      examples: this.params.encode
+        ? examples.map(this.params.encode)
+        : examples,
+    })
   }
 
-  description(description: string): BaseType<Schema, Props, ValueType> {
-    const ThisConstructor = this.constructor as any
-    return new ThisConstructor(
-      {
-        ...this.schema,
-        description,
-      },
-      this.props,
-      this.params,
-    ) as any
+  meta(newMetadata: TypeMetadata): this {
+    const metadata = typesRegistry.get(this.encodedZodType) ?? {}
+    Object.assign(metadata, newMetadata)
+    typesRegistry.add(this.encodedZodType, metadata)
+    return this
   }
 
-  examples(...examples: ValueType[]): BaseType<Schema, Props, ValueType> {
-    const ThisConstructor = this.constructor as any
-    return new ThisConstructor(
-      {
-        ...this.schema,
-        examples,
-      },
-      this.props,
-      this.params,
-    ) as any
+  encode(
+    data: this['encodedZodType']['_zod']['input'],
+  ): this['encodedZodType']['_zod']['output'] {
+    return this.encodedZodType.parse(data, { reportInput: true })
+  }
+
+  decode(
+    data: this['decodedZodType']['_zod']['input'],
+  ): this['decodedZodType']['_zod']['output'] {
+    return this.decodedZodType.parse(data, { reportInput: true })
   }
 }
 
 export class OptionalType<
   Type extends BaseTypeAny = BaseTypeAny,
-  ValueType = unknown,
-> extends BaseType<TOptional<Type['schema']>, { inner: Type }, ValueType> {
+> extends BaseType<
+  ZodMiniOptional<Type['encodedZodType']>,
+  ZodMiniOptional<Type['decodedZodType']>,
+  { inner: Type }
+> {
   static factory<T extends BaseTypeAny>(type: T) {
-    return new OptionalType<T>(Optional(type.schema) as any, { inner: type }, {
-      ...type.params,
-      optional: true,
-    } as any)
+    return new OptionalType<T>({
+      encodedZodType: optional(type.encodedZodType) as any,
+      props: { inner: type },
+    })
   }
 }
 
 export class NullableType<
   Type extends BaseTypeAny<any> = BaseTypeAny<any>,
-  ValueType = unknown,
 > extends BaseType<
-  TNullable<Type['schema']>,
-  { inner: Type },
-  ValueType | null
+  ZodMiniNullable<Type['encodedZodType']>,
+  ZodMiniNullable<Type['decodedZodType']>,
+  { inner: Type }
 > {
   static factory<T extends BaseTypeAny<any>>(type: T) {
-    return new NullableType<T>(Nullable(type.schema), { inner: type }, {
-      ...type.params,
-      nullable: true,
-    } as any)
+    return new NullableType<T>({
+      encodedZodType: nullable(type.encodedZodType),
+      props: { inner: type },
+    })
   }
 }
 
 export class DefaultType<
   Type extends BaseTypeAny = BaseTypeAny,
-  ValueType = unknown,
 > extends BaseType<
-  TDefault<TOptional<Type['schema']>>,
-  { inner: Type },
-  ValueType
+  ZodMiniDefault<Type['encodedZodType']>,
+  ZodMiniDefault<Type['decodedZodType']>,
+  { inner: Type }
 > {
   static factory<T extends BaseTypeAny<any>>(type: T, defaultValue: any) {
-    return new DefaultType<T>(
-      Default(Optional(type.schema), defaultValue) as any,
-      { inner: type },
-      { ...type.params, hasDefault: true } as any,
-    )
+    return new DefaultType<T>({
+      encodedZodType: _default(
+        type.encodedZodType,
+        type.params.encode?.(defaultValue) ?? defaultValue,
+      ) as any,
+      decodedZodType: _default(type.decodedZodType, defaultValue) as any,
+      props: { inner: type },
+    })
   }
 }

package/src/types/boolean.ts

@@ -1,8 +1,10 @@
-import { type TBoolean, Type } from '@sinclair/typebox'
+import { boolean, type ZodMiniBoolean } from '@zod/mini'
 import { BaseType } from './base.ts'
 
-export class BooleanType extends BaseType<TBoolean, {}, boolean> {
+export class BooleanType extends BaseType<ZodMiniBoolean<boolean>> {
   static factory() {
-    return new BooleanType(Type.Boolean())
+    return new BooleanType({
+      encodedZodType: boolean(),
+    })
   }
 }

package/src/types/custom.ts

@@ -1,33 +1,52 @@
 import {
-  type TAny,
-  type TSchema,
-  type TTransform,
-  Type,
-} from '@sinclair/typebox'
-import type { StaticInputDecode, StaticOutputDecode } from '../inference.ts'
-import { BaseType } from './base.ts'
+  any,
+  custom,
+  overwrite,
+  pipe,
+  type ZodMiniAny,
+  type ZodMiniCustom,
+  type ZodMiniPipe,
+} from '@zod/mini'
+import { BaseType, type SimpleZodType, type ZodType } from './base.ts'
 
-export type CustomTypeDecode<T> = (value: any) => T
-export type CustomTypeEncode<T> = (value: T) => any
+export type CustomTypeDecode<I, O> = (value: I) => O
+export type CustomTypeEncode<I, O> = (value: I) => O
 
 export abstract class TransformType<
-  T,
-  S extends TSchema = TAny,
-> extends BaseType<TTransform<S, T>, {}, StaticInputDecode<TTransform<S, T>>> {}
+  Type,
+  EncodedType extends SimpleZodType = ZodMiniAny,
+  DecodedType extends ZodType = ZodMiniCustom<Type>,
+> extends BaseType<EncodedType, DecodedType> {}
 
-export class CustomType<T, S extends TSchema = TAny> extends TransformType<
-  T,
-  S
+export class CustomType<
+  Type,
+  EncodedType extends SimpleZodType = ZodMiniAny,
+  DecodedType extends ZodType = ZodMiniCustom<Type, Type>,
+> extends BaseType<
+  ZodMiniPipe<DecodedType, EncodedType>,
+  ZodMiniPipe<EncodedType, DecodedType>
 > {
-  static factory<T, S extends TSchema = TAny>(
-    decode: CustomTypeDecode<T>,
-    encode: CustomTypeEncode<T>,
-    schema: S = Type.Any() as S,
+  static factory<
+    Type,
+    EncodedType extends SimpleZodType = ZodMiniAny,
+    DecodedType extends ZodType = ZodMiniCustom<Type>,
+  >(
+    decode: CustomTypeDecode<
+      EncodedType['_zod']['output'],
+      DecodedType['_zod']['output']
+    >,
+    encode: CustomTypeEncode<
+      DecodedType['_zod']['output'],
+      EncodedType['_zod']['output']
+    >,
+    type: EncodedType = any() as unknown as EncodedType,
   ) {
-    return new CustomType<T, S>(
-      Type.Transform(schema).Decode(decode).Encode(encode),
-      {},
-      { encode } as any,
-    )
+    return new CustomType<Type, EncodedType, DecodedType>({
+      //@ts-expect-error
+      encodedZodType: pipe(custom().check(overwrite(encode)), type),
+      //@ts-expect-error
+      decodedZodType: pipe(type, custom().check(overwrite(decode))),
+      params: { encode },
+    })
   }
 }

package/src/types/date.ts

@@ -1,22 +1,23 @@
-import { type TString, Type } from '@sinclair/typebox'
+import {
+  date,
+  iso,
+  union,
+  type ZodMiniDate,
+  type ZodMiniUnion,
+} from '@zod/mini'
 import { CustomType, TransformType } from './custom.ts'
 
-const decode = (value: any): Date => new Date(value)
-const encode = (value: Date): any => value.toISOString()
+const decode = (value: string): Date => new Date(value)
+const encode = (value: Date): string => value.toISOString()
 
-export class DateType extends TransformType<Date> {
+export class DateType extends TransformType<
+  Date,
+  ZodMiniUnion<[iso.ZodMiniISODate, iso.ZodMiniISODateTime]>
+> {
   static factory() {
-    return CustomType.factory<Date, TString>(
-      decode,
-      encode,
-      Type.Union([
-        Type.String({
-          format: 'date',
-        }),
-        Type.String({
-          format: 'date-time',
-        }),
-      ]) as unknown as TString,
-    )
+    return CustomType.factory<
+      Date,
+      ZodMiniUnion<Array<iso.ZodMiniISODate | iso.ZodMiniISODateTime>>
+    >(decode, encode, union([iso.datetime(), iso.date()]))
   }
 }