@nmtjs/type 0.7.0 → 0.7.1

package/src/index.ts

@@ -1,3 +1,4 @@
+import * as zod from '@zod/mini'
 import { AnyType } from './types/any.ts'
 import { ArrayType } from './types/array.ts'
 import type { BaseTypeAny } from './types/base.ts'
@@ -7,11 +8,7 @@ import { DateType } from './types/date.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,
@@ -29,6 +26,8 @@ import {
   UnionType,
 } from './types/union.ts'
 
+zod.config(zod.core.locales.en())
+
 export { NeemataTypeError } from './types/base.ts'
 export { BaseType, type BaseTypeAny } from './types/base.ts'
 export {
@@ -52,17 +51,17 @@ export {
 
 export namespace type {
   export namespace infer {
-    export type decoded<T extends BaseTypeAny<any>> =
+    export type decoded<T extends BaseTypeAny> =
       T['decodedZodType']['_zod']['output']
 
-    export type encoded<T extends BaseTypeAny<any>> =
+    export type encoded<T extends BaseTypeAny> =
       T['encodedZodType']['_zod']['output']
 
     export namespace input {
-      export type decoded<T extends BaseTypeAny<any>> =
+      export type decoded<T extends BaseTypeAny> =
         T['decodedZodType']['_zod']['input']
 
-      export type encoded<T extends BaseTypeAny<any>> =
+      export type encoded<T extends BaseTypeAny> =
         T['encodedZodType']['_zod']['input']
     }
   }
@@ -72,7 +71,7 @@ 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 enumeration = EnumType.factory
   export const date = DateType.factory
@@ -95,4 +94,4 @@ export namespace type {
   })
 }
 
-export { type as t }
+export { type as t, zod }

package/src/temporal.ts

@@ -8,13 +8,13 @@ import {
   ZonedDateTimeType,
 } from './types/temporal.ts'
 
-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 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 type {
   DurationType,

package/src/types/array.ts

@@ -13,28 +13,41 @@ type Check = core.CheckFn<any[]> | core.$ZodCheck<any[]>
 export class ArrayType<T extends BaseType = BaseType> extends BaseType<
   ZodMiniArray<T['encodedZodType']>,
   ZodMiniArray<T['decodedZodType']>,
-  { element: T; checks: Check[] }
+  { element: T }
 > {
   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 },
+      params: { checks },
+      props: { element },
     })
   }
 
   min(value: number) {
     const check = minLength(value)
-    return ArrayType.factory<T>(this.props.element, ...this.props.checks, check)
+    return ArrayType.factory<T>(
+      this.props.element,
+      ...this.params.checks,
+      check,
+    )
   }
 
   max(value: number) {
     const check = maxLength(value)
-    return ArrayType.factory<T>(this.props.element, ...this.props.checks, check)
+    return ArrayType.factory<T>(
+      this.props.element,
+      ...this.params.checks,
+      check,
+    )
   }
 
   length(value: number) {
     const check = length(value)
-    return ArrayType.factory<T>(this.props.element, ...this.props.checks, check)
+    return ArrayType.factory<T>(
+      this.props.element,
+      ...this.params.checks,
+      check,
+    )
   }
 }

package/src/types/base.ts

@@ -59,6 +59,7 @@ export type TypeMetadata<T = any> = {
 export type TypeParams = {
   encode?: (value: any) => any
   metadata?: TypeMetadata
+  checks: Array<core.CheckFn<any> | core.$ZodCheck<any>>
 }
 
 export type DefaultTypeParams = {
@@ -90,18 +91,18 @@ export abstract class BaseType<
     encodedZodType,
     decodedZodType = encodedZodType as unknown as DecodedZodType,
     props = {} as Props,
-    params = {} as TypeParams,
+    params = {} as Partial<TypeParams>,
   }: {
     encodedZodType: EncodedZodType
     decodedZodType?: DecodedZodType
     props?: Props
-    params?: TypeParams
+    params?: Partial<TypeParams>
   }) {
     this.encodedZodType = encodedZodType
     this.decodedZodType = decodedZodType
 
     this.props = props
-    this.params = params
+    this.params = Object.assign({ checks: [] }, params)
   }
 
   optional(): OptionalType<this> {

package/src/types/custom.ts

@@ -1,5 +1,6 @@
 import {
   any,
+  type core,
   custom,
   overwrite,
   pipe,
@@ -15,37 +16,50 @@ export type CustomTypeEncode<I, O> = (value: I) => O
 export abstract class TransformType<
   Type,
   EncodedType extends SimpleZodType = ZodMiniAny,
-  DecodedType extends ZodType = ZodMiniCustom<Type>,
-> extends BaseType<EncodedType, DecodedType> {}
+  DecodedType extends ZodType = ZodMiniCustom<Type, Type>,
+> extends BaseType<
+  ZodMiniPipe<
+    ZodMiniCustom<DecodedType['_zod']['output'], DecodedType['_zod']['input']>,
+    EncodedType
+  >,
+  ZodMiniPipe<
+    EncodedType,
+    ZodMiniCustom<EncodedType['_zod']['output'], EncodedType['_zod']['input']>
+  >
+> {}
 
 export class CustomType<
   Type,
   EncodedType extends SimpleZodType = ZodMiniAny,
   DecodedType extends ZodType = ZodMiniCustom<Type, Type>,
-> extends BaseType<
-  ZodMiniPipe<DecodedType, EncodedType>,
-  ZodMiniPipe<EncodedType, DecodedType>
-> {
+> extends TransformType<Type, EncodedType, DecodedType> {
   static factory<
     Type,
     EncodedType extends SimpleZodType = ZodMiniAny,
-    DecodedType extends ZodType = ZodMiniCustom<Type>,
-  >(
+    DecodedType extends ZodType = ZodMiniCustom<Type, Type>,
+  >({
+    decode,
+    encode,
+    error,
+    type = any() as unknown as EncodedType,
+  }: {
     decode: CustomTypeDecode<
-      EncodedType['_zod']['output'],
+      EncodedType['_zod']['input'],
       DecodedType['_zod']['output']
-    >,
+    >
     encode: CustomTypeEncode<
-      DecodedType['_zod']['output'],
+      DecodedType['_zod']['input'],
       EncodedType['_zod']['output']
-    >,
-    type: EncodedType = any() as unknown as EncodedType,
-  ) {
+    >
+    error?: string | core.$ZodErrorMap<core.$ZodIssueBase>
+    type?: EncodedType
+  }) {
     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))),
+      decodedZodType: pipe(
+        type,
+        custom(undefined, { error }).check(overwrite(decode)),
+      ),
       params: { encode },
     })
   }

package/src/types/date.ts

@@ -1,15 +1,6 @@
-import {
-  date,
-  iso,
-  union,
-  type ZodMiniDate,
-  type ZodMiniUnion,
-} from '@zod/mini'
+import { iso, union, type ZodMiniUnion } from '@zod/mini'
 import { CustomType, TransformType } from './custom.ts'
 
-const decode = (value: string): Date => new Date(value)
-const encode = (value: Date): string => value.toISOString()
-
 export class DateType extends TransformType<
   Date,
   ZodMiniUnion<[iso.ZodMiniISODate, iso.ZodMiniISODateTime]>
@@ -18,6 +9,10 @@ export class DateType extends TransformType<
     return CustomType.factory<
       Date,
       ZodMiniUnion<Array<iso.ZodMiniISODate | iso.ZodMiniISODateTime>>
-    >(decode, encode, union([iso.datetime(), iso.date()]))
+    >({
+      decode: (value: string): Date => new Date(value),
+      encode: (value: Date): string => value.toISOString(),
+      type: union([iso.datetime(), iso.date()]),
+    })
   }
 }

package/src/types/number.ts

@@ -6,45 +6,49 @@ import {
   lt,
   lte,
   number,
+  regex,
+  string,
   type ZodMiniNumber,
+  type ZodMiniString,
 } from '@zod/mini'
 import { BaseType } from './base.ts'
+import { CustomType, TransformType } from './custom.ts'
 
 type Check = core.CheckFn<number> | core.$ZodCheck<number>
 
 export class NumberType extends BaseType<
   ZodMiniNumber<number>,
-  ZodMiniNumber<number>,
-  { checks: Check[] }
+  ZodMiniNumber<number>
 > {
   static factory(...checks: Check[]) {
     return new NumberType({
       encodedZodType: number().check(...checks),
+      params: { checks },
     })
   }
 
   positive() {
-    return NumberType.factory(...this.props.checks, gte(0))
+    return NumberType.factory(...this.params.checks, gte(0))
   }
 
   negative() {
-    return NumberType.factory(...this.props.checks, lte(0))
+    return NumberType.factory(...this.params.checks, lte(0))
   }
 
   lt(value: number) {
-    return NumberType.factory(...this.props.checks, lt(value))
+    return NumberType.factory(...this.params.checks, lt(value))
   }
 
   lte(value: number) {
-    return NumberType.factory(...this.props.checks, lte(value))
+    return NumberType.factory(...this.params.checks, lte(value))
   }
 
   gte(value: number) {
-    return NumberType.factory(...this.props.checks, gte(value))
+    return NumberType.factory(...this.params.checks, gte(value))
   }
 
   gt(value: number) {
-    return NumberType.factory(...this.props.checks, gt(value))
+    return NumberType.factory(...this.params.checks, gt(value))
   }
 }
 
@@ -53,3 +57,14 @@ export class IntegerType extends NumberType {
     return NumberType.factory(...checks, int())
   }
 }
+
+export class BigIntType extends TransformType<bigint, ZodMiniString<string>> {
+  static factory() {
+    return CustomType.factory<bigint, ZodMiniString<string>>({
+      decode: (value) => BigInt(value),
+      encode: (value) => value.toString(),
+      type: string().check(regex(/^-?\d+$/)),
+      error: 'Invalid bigint format',
+    })
+  }
+}

package/src/types/object.ts

@@ -2,6 +2,7 @@ import {
   type core,
   object,
   record,
+  strictObject,
   type ZodMiniObject,
   type ZodMiniRecord,
 } from '@zod/mini'
@@ -14,8 +15,8 @@ import type { StringType } from './string.ts'
 export type ObjectTypeProps = { [k: string]: BaseTypeAny }
 export type AnyObjectType = ObjectType<ObjectTypeProps>
 export class ObjectType<T extends ObjectTypeProps = {}> extends BaseType<
-  ZodMiniObject<{ [K in keyof T]: T[K]['encodedZodType'] }>,
-  ZodMiniObject<{ [K in keyof T]: T[K]['decodedZodType'] }>,
+  ZodMiniObject<{ [K in keyof T]: T[K]['encodedZodType'] }, {}>,
+  ZodMiniObject<{ [K in keyof T]: T[K]['decodedZodType'] }, {}>,
   { properties: T }
 > {
   static factory<T extends ObjectTypeProps = {}>(properties: T) {

package/src/types/string.ts

@@ -1,10 +1,16 @@
 import {
   type core,
+  cuid,
+  cuid2,
+  e164,
   email,
+  emoji,
   ipv4,
   ipv6,
+  jwt,
   maxLength,
   minLength,
+  nanoid,
   regex,
   string,
   url,
@@ -18,48 +24,71 @@ type Check = core.CheckFn<string> | core.$ZodCheck<string>
 
 export class StringType extends BaseType<
   ZodMiniString<string>,
-  ZodMiniString<string>,
-  { checks: Check[] }
+  ZodMiniString<string>
 > {
   static factory(...checks: Check[]) {
     return new StringType({
       encodedZodType: string().check(...checks),
-      props: { checks },
+      params: { checks },
     })
   }
 
   max(value: number) {
-    return StringType.factory(...this.props.checks, maxLength(value))
+    return StringType.factory(...this.params.checks, maxLength(value))
   }
 
   min(value: number) {
-    return StringType.factory(...this.props.checks, minLength(value))
+    return StringType.factory(...this.params.checks, minLength(value))
   }
 
   pattern(pattern: string | RegExp) {
     return StringType.factory(
-      ...this.props.checks,
+      ...this.params.checks,
       regex(typeof pattern === 'string' ? new RegExp(pattern) : pattern),
     )
   }
 
   email(options?: core.$ZodEmailParams) {
-    return StringType.factory(...this.props.checks, email(options))
+    return StringType.factory(...this.params.checks, email(options))
   }
 
   url(options?: core.$ZodURLParams) {
-    return StringType.factory(...this.props.checks, url(options))
+    return StringType.factory(...this.params.checks, url(options))
   }
 
   ipv4(options?: core.$ZodIPv4Params) {
-    return StringType.factory(...this.props.checks, ipv4(options))
+    return StringType.factory(...this.params.checks, ipv4(options))
   }
 
   ipv6(options?: core.$ZodIPv6Params) {
-    return StringType.factory(...this.props.checks, ipv6(options))
+    return StringType.factory(...this.params.checks, ipv6(options))
   }
 
   uuid(options?: core.$ZodUUIDParams) {
-    return StringType.factory(...this.props.checks, uuid(options))
+    return StringType.factory(...this.params.checks, uuid(options))
+  }
+
+  emoji(options?: core.$ZodEmojiParams) {
+    return StringType.factory(...this.params.checks, emoji(options))
+  }
+
+  nanoid(options?: core.$ZodNanoIDParams) {
+    return StringType.factory(...this.params.checks, nanoid(options))
+  }
+
+  cuid(options?: core.$ZodCUIDParams) {
+    return StringType.factory(...this.params.checks, cuid(options))
+  }
+
+  cuid2(options?: core.$ZodCUID2Params) {
+    return StringType.factory(...this.params.checks, cuid2(options))
+  }
+
+  e164(options?: core.$ZodE164Params) {
+    return StringType.factory(...this.params.checks, e164(options))
+  }
+
+  jwt(options?: core.$ZodJWTParams) {
+    return StringType.factory(...this.params.checks, jwt(options))
   }
 }

package/src/types/temporal.ts

@@ -1,9 +1,4 @@
-import {
-  custom,
-  string,
-  type ZodMiniCustom,
-  type ZodMiniString,
-} from '@zod/mini'
+import { iso, regex, string, type ZodMiniString } from '@zod/mini'
 import { Temporal } from 'temporal-polyfill'
 import { CustomType, TransformType } from './custom.ts'
 
@@ -34,137 +29,118 @@ const createTemporalTransformer = <T extends Types>(
   } as TemporalTransformer<T>
 }
 
+type EncodedType = ZodMiniString<string>
+
 export class PlainDateType extends TransformType<
   Temporal.PlainDate,
-  ZodMiniString
+  EncodedType
 > {
   static transformer = createTemporalTransformer('PlainDate')
 
   static factory() {
-    return CustomType.factory<
-      Temporal.PlainDate,
-      ZodMiniString,
-      ZodMiniCustom<Temporal.PlainDate, Temporal.PlainDate>
-    >(
-      PlainDateType.transformer.decode,
-      PlainDateType.transformer.encode,
-      string(),
-    )
+    return CustomType.factory<Temporal.PlainDate, EncodedType>({
+      decode: PlainDateType.transformer.decode,
+      encode: PlainDateType.transformer.encode,
+      type: iso.date(),
+      error: 'Invalid date format',
+    })
   }
 }
 
 export class PlainDateTimeType extends TransformType<
   Temporal.PlainDateTime,
-  ZodMiniString
+  EncodedType
 > {
   static transformer = createTemporalTransformer('PlainDateTime')
 
   static factory() {
-    return CustomType.factory<
-      Temporal.PlainDateTime,
-      ZodMiniString,
-      ZodMiniCustom<Temporal.PlainDateTime, Temporal.PlainDateTime>
-    >(
-      PlainDateTimeType.transformer.decode,
-      PlainDateTimeType.transformer.encode,
-      string(),
-    )
+    return CustomType.factory<Temporal.PlainDateTime, EncodedType>({
+      decode: PlainDateTimeType.transformer.decode,
+      encode: PlainDateTimeType.transformer.encode,
+      type: iso.datetime({ local: true }),
+      error: 'Invalid datetime format',
+    })
   }
 }
 
 export class ZonedDateTimeType extends TransformType<
   Temporal.ZonedDateTime,
-  ZodMiniString
+  EncodedType
 > {
   static transformer = createTemporalTransformer('ZonedDateTime', (value) =>
     Temporal.Instant.from(value).toZonedDateTimeISO('UTC'),
   )
 
   static factory() {
-    return CustomType.factory<
-      Temporal.ZonedDateTime,
-      ZodMiniString,
-      ZodMiniCustom<Temporal.ZonedDateTime, Temporal.ZonedDateTime>
-    >(
-      ZonedDateTimeType.transformer.decode,
-      ZonedDateTimeType.transformer.encode,
-      string(),
-    )
+    return CustomType.factory<Temporal.ZonedDateTime, EncodedType>({
+      decode: ZonedDateTimeType.transformer.decode,
+      encode: ZonedDateTimeType.transformer.encode,
+      type: iso.datetime({ local: true }),
+      error: 'Invalid datetime format',
+    })
   }
 }
 
 export class PlainTimeType extends TransformType<
   Temporal.PlainTime,
-  ZodMiniString
+  EncodedType
 > {
   static transformer = createTemporalTransformer('PlainTime')
 
   static factory() {
-    return CustomType.factory<
-      Temporal.PlainTime,
-      ZodMiniString,
-      ZodMiniCustom<Temporal.PlainTime, Temporal.PlainTime>
-    >(
-      PlainTimeType.transformer.decode,
-      PlainTimeType.transformer.encode,
-      string(),
-    )
+    return CustomType.factory<Temporal.PlainTime, EncodedType>({
+      decode: PlainTimeType.transformer.decode,
+      encode: PlainTimeType.transformer.encode,
+      type: iso.time(),
+      error: 'Invalid time format',
+    })
   }
 }
 
 export class DurationType extends TransformType<
   Temporal.Duration,
-  ZodMiniString
+  EncodedType
 > {
   static transformer = createTemporalTransformer('Duration')
 
   static factory() {
-    return CustomType.factory<
-      Temporal.Duration,
-      ZodMiniString,
-      ZodMiniCustom<Temporal.Duration, Temporal.Duration>
-    >(
-      DurationType.transformer.decode,
-      DurationType.transformer.encode,
-      string(),
-    )
+    return CustomType.factory<Temporal.Duration, EncodedType>({
+      decode: DurationType.transformer.decode,
+      encode: DurationType.transformer.encode,
+      type: iso.duration(),
+      error: 'Invalid duration format',
+    })
   }
 }
 
 export class PlainYearMonthType extends TransformType<
   Temporal.PlainYearMonth,
-  ZodMiniString
+  EncodedType
 > {
   static transformer = createTemporalTransformer('PlainYearMonth')
 
   static factory() {
-    return CustomType.factory<
-      Temporal.PlainYearMonth,
-      ZodMiniString,
-      ZodMiniCustom<Temporal.PlainYearMonth, Temporal.PlainYearMonth>
-    >(
-      PlainYearMonthType.transformer.decode,
-      PlainYearMonthType.transformer.encode,
-      string(),
-    )
+    return CustomType.factory<Temporal.PlainYearMonth, EncodedType>({
+      decode: PlainYearMonthType.transformer.decode,
+      encode: PlainYearMonthType.transformer.encode,
+      type: string().check(regex(/^\d{4}-\d{2}$/)),
+      error: 'Invalid year-month format',
+    })
   }
 }
 
 export class PlainMonthDayType extends TransformType<
   Temporal.PlainMonthDay,
-  ZodMiniString
+  EncodedType
 > {
   static transformer = createTemporalTransformer('PlainMonthDay')
 
   static factory() {
-    return CustomType.factory<
-      Temporal.PlainMonthDay,
-      ZodMiniString,
-      ZodMiniCustom<Temporal.PlainMonthDay, Temporal.PlainMonthDay>
-    >(
-      PlainMonthDayType.transformer.decode,
-      PlainMonthDayType.transformer.encode,
-      string(),
-    )
+    return CustomType.factory<Temporal.PlainMonthDay, EncodedType>({
+      decode: PlainMonthDayType.transformer.decode,
+      encode: PlainMonthDayType.transformer.encode,
+      type: string().check(regex(/^\d{2}-\d{2}$/)),
+      error: 'Invalid month-day format',
+    })
   }
 }

package/src/types/union.ts

@@ -39,15 +39,10 @@ export class IntersactionType<
   static factory<
     T extends readonly [BaseType, BaseType] = readonly [BaseType, BaseType],
   >(...options: T) {
+    const [first, second] = options
     return new IntersactionType<T>({
-      encodedZodType: intersection(
-        options[0].encodedZodType,
-        options[1].encodedZodType,
-      ),
-      decodedZodType: intersection(
-        options[0].decodedZodType,
-        options[1].decodedZodType,
-      ),
+      encodedZodType: intersection(first.encodedZodType, second.encodedZodType),
+      decodedZodType: intersection(first.decodedZodType, second.decodedZodType),
       props: { options },
     })
   }