@nmtjs/type 0.12.5 → 0.12.7

package/src/types/date.ts

@@ -1,20 +0,0 @@
-import * as zod from 'zod/v4-mini'
-import { CustomType, TransformType } from './custom.ts'
-
-export class DateType extends TransformType<
-  Date,
-  zod.ZodMiniUnion<[zod.iso.ZodMiniISODate, zod.iso.ZodMiniISODateTime]>
-> {
-  static factory() {
-    return CustomType.factory<
-      Date,
-      zod.ZodMiniUnion<[zod.iso.ZodMiniISODate, zod.iso.ZodMiniISODateTime]>
-    >({
-      decode: (value: string): Date => new Date(value),
-      encode: (value: Date): string => value.toISOString(),
-      type: zod.union([zod.iso.date(), zod.iso.datetime()]),
-    })
-  }
-}
-
-export const date = DateType.factory

package/src/types/enum.ts

@@ -1,21 +0,0 @@
-import * as zod from 'zod/v4-mini'
-import { BaseType } from './base.ts'
-
-export class EnumType<
-  T extends zod.core.util.EnumLike = zod.core.util.EnumLike,
-> extends BaseType<zod.ZodMiniEnum<T>, zod.ZodMiniEnum<T>, { values: T }> {
-  static factory<T extends zod.core.util.EnumLike>(values: T): EnumType<T>
-  static factory<T extends string[]>(
-    values: T,
-  ): EnumType<zod.core.util.ToEnum<T[number]>>
-  static factory<T extends zod.core.util.EnumLike | string[]>(values: T) {
-    return new EnumType({
-      encodedZodType: zod.enum(values as any),
-      props: { values },
-    })
-  }
-}
-
-const _enum = EnumType.factory
-
-export { _enum as enum }

package/src/types/literal.ts

@@ -1,15 +0,0 @@
-import * as zod from 'zod/v4-mini'
-import { BaseType, type PrimitiveValueType } from './base.ts'
-
-export class LiteralType<
-  T extends PrimitiveValueType = PrimitiveValueType,
-> extends BaseType<zod.ZodMiniLiteral<T>, zod.ZodMiniLiteral<T>, { value: T }> {
-  static factory<T extends PrimitiveValueType>(value: T) {
-    return new LiteralType<T>({
-      encodedZodType: zod.literal(value),
-      props: { value },
-    })
-  }
-}
-
-export const literal = LiteralType.factory

package/src/types/never.ts

@@ -1,12 +0,0 @@
-import * as zod from 'zod/v4-mini'
-import { BaseType } from './base.ts'
-
-export class NeverType extends BaseType<zod.ZodMiniNever> {
-  static factory() {
-    return new NeverType({
-      encodedZodType: zod.never(),
-    })
-  }
-}
-
-export const never = NeverType.factory

package/src/types/number.ts

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

package/src/types/object.ts

@@ -1,163 +0,0 @@
-import * as zod from 'zod/v4-mini'
-
-import { BaseType, type BaseTypeAny, type OptionalType } from './base.ts'
-import { EnumType } from './enum.ts'
-import type { LiteralType } from './literal.ts'
-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<
-  zod.ZodMiniObject<
-    { [K in keyof T]: T[K]['encodedZodType'] },
-    zod.core.$strict
-  >,
-  zod.ZodMiniObject<
-    { [K in keyof T]: T[K]['decodedZodType'] },
-    zod.core.$strict
-  >,
-  { properties: T }
-> {
-  static factory<T extends ObjectTypeProps = {}>(properties: T) {
-    const encodeProperties = {} as {
-      [K in keyof T]: T[K]['encodedZodType']
-    }
-    const decodeProperties = {} as {
-      [K in keyof T]: T[K]['decodedZodType']
-    }
-
-    for (const key in properties) {
-      encodeProperties[key] = properties[key].encodedZodType
-      decodeProperties[key] = properties[key].decodedZodType
-    }
-
-    return new ObjectType<T>({
-      encodedZodType: zod.object(encodeProperties),
-      decodedZodType: zod.object(decodeProperties),
-      props: { properties },
-    })
-  }
-}
-
-export class RecordType<
-  K extends LiteralType<string | number> | EnumType | StringType,
-  E extends BaseType,
-> extends BaseType<
-  zod.ZodMiniRecord<K['encodedZodType'], E['encodedZodType']>,
-  zod.ZodMiniRecord<K['decodedZodType'], E['decodedZodType']>
-> {
-  static factory<
-    K extends LiteralType<string | number> | EnumType | StringType,
-    E extends BaseType,
-  >(key: K, element: E) {
-    return new RecordType<K, E>({
-      encodedZodType: zod.record(
-        (key as any).encodedZodType,
-        element.encodedZodType,
-      ),
-      decodedZodType: zod.record(
-        (key as any).decodedZodType,
-        element.decodedZodType,
-      ),
-      props: { key, element },
-    })
-  }
-}
-
-export function keyof<T extends ObjectType>(
-  type: T,
-): EnumType<
-  zod.core.util.ToEnum<Extract<keyof T['props']['properties'], string>>
-> {
-  return EnumType.factory(Object.keys(type.props.properties) as any)
-}
-
-export function pick<
-  T extends AnyObjectType,
-  P extends { [K in keyof T['props']['properties']]?: true },
->(
-  source: T,
-  pick: P,
-): ObjectType<{
-  [K in keyof P]: P[K] extends true
-    ? K extends keyof T['props']['properties']
-      ? T['props']['properties'][K]
-      : never
-    : never
-}> {
-  const properties = Object.fromEntries(
-    Object.entries(source.props.properties).filter(([key]) => pick[key]),
-  )
-  return ObjectType.factory(properties) as any
-}
-
-export function omit<
-  T extends AnyObjectType,
-  P extends { [K in keyof T['props']['properties']]?: true },
->(
-  source: T,
-  omit: P,
-): ObjectType<{
-  [K in keyof T['props']['properties'] as K extends keyof P
-    ? never
-    : K]: T['props']['properties'][K]
-}> {
-  const properties = Object.fromEntries(
-    Object.entries(source.props.properties).filter(([key]) => !omit[key]),
-  )
-  return ObjectType.factory(properties) as any
-}
-
-export function extend<T extends AnyObjectType, P extends ObjectTypeProps>(
-  object1: T,
-  properties: P,
-): ObjectType<{
-  [K in keyof T['props']['properties'] | keyof P]: K extends keyof P
-    ? P[K]
-    : K extends keyof T['props']['properties']
-      ? T['props']['properties'][K]
-      : never
-}> {
-  return ObjectType.factory({
-    ...object1.props.properties,
-    ...properties,
-  }) as any
-}
-
-export function merge<T1 extends AnyObjectType, T2 extends AnyObjectType>(
-  object1: T1,
-  object2: T2,
-): ObjectType<{
-  [K in
-    | keyof T1['props']['properties']
-    | keyof T2['props']['properties']]: K extends keyof T2['props']['properties']
-    ? T2['props']['properties'][K]
-    : K extends keyof T1['props']['properties']
-      ? T1['props']['properties'][K]
-      : never
-}> {
-  return ObjectType.factory({
-    ...object1.props.properties,
-    ...object2.props.properties,
-  }) as any
-}
-
-export function partial<
-  T extends AnyObjectType,
-  P extends T extends ObjectType<infer Props> ? Props : never,
->(
-  object: T,
-): ObjectType<{
-  [K in keyof P]: OptionalType<P[K]>
-}> {
-  const properties = {} as any
-
-  for (const [key, value] of Object.entries(object.props.properties)) {
-    properties[key] = value.optional()
-  }
-
-  return ObjectType.factory(properties)
-}
-
-export const object = ObjectType.factory
-export const record = RecordType.factory

package/src/types/string.ts

@@ -1,78 +0,0 @@
-import * as zod from 'zod/v4-mini'
-
-import { BaseType } from './base.ts'
-
-type Check = zod.core.CheckFn<string> | zod.core.$ZodCheck<string>
-
-export class StringType extends BaseType<
-  zod.ZodMiniString<string>,
-  zod.ZodMiniString<string>
-> {
-  static factory(...checks: Check[]) {
-    return new StringType({
-      encodedZodType: zod.string().check(...checks),
-      params: { checks },
-    })
-  }
-
-  max(value: number) {
-    return StringType.factory(...this.params.checks, zod.maxLength(value))
-  }
-
-  min(value: number) {
-    return StringType.factory(...this.params.checks, zod.minLength(value))
-  }
-
-  pattern(pattern: string | RegExp) {
-    return StringType.factory(
-      ...this.params.checks,
-      zod.regex(typeof pattern === 'string' ? new RegExp(pattern) : pattern),
-    )
-  }
-
-  email(options?: zod.core.$ZodEmailParams) {
-    return StringType.factory(...this.params.checks, zod.email(options))
-  }
-
-  url(options?: zod.core.$ZodURLParams) {
-    return StringType.factory(...this.params.checks, zod.url(options))
-  }
-
-  ipv4(options?: zod.core.$ZodIPv4Params) {
-    return StringType.factory(...this.params.checks, zod.ipv4(options))
-  }
-
-  ipv6(options?: zod.core.$ZodIPv6Params) {
-    return StringType.factory(...this.params.checks, zod.ipv6(options))
-  }
-
-  uuid(options?: zod.core.$ZodUUIDParams) {
-    return StringType.factory(...this.params.checks, zod.uuid(options))
-  }
-
-  emoji(options?: zod.core.$ZodEmojiParams) {
-    return StringType.factory(...this.params.checks, zod.emoji(options))
-  }
-
-  nanoid(options?: zod.core.$ZodNanoIDParams) {
-    return StringType.factory(...this.params.checks, zod.nanoid(options))
-  }
-
-  cuid(options?: zod.core.$ZodCUIDParams) {
-    return StringType.factory(...this.params.checks, zod.cuid(options))
-  }
-
-  cuid2(options?: zod.core.$ZodCUID2Params) {
-    return StringType.factory(...this.params.checks, zod.cuid2(options))
-  }
-
-  e164(options?: zod.core.$ZodE164Params) {
-    return StringType.factory(...this.params.checks, zod.e164(options))
-  }
-
-  jwt(options?: zod.core.$ZodJWTParams) {
-    return StringType.factory(...this.params.checks, zod.jwt(options))
-  }
-}
-
-export const string = StringType.factory

package/src/types/temporal.ts

@@ -1,154 +0,0 @@
-import { Temporal } from 'temporal-polyfill'
-import { iso, regex, string, type ZodMiniString } from 'zod/v4-mini'
-import { CustomType, TransformType } from './custom.ts'
-
-type Types = Exclude<
-  keyof typeof Temporal,
-  'Now' | 'Instant' | 'Calendar' | 'TimeZone'
->
-
-type TemporalTransformer<T extends Types> = {
-  decode: (value: string) => ReturnType<(typeof Temporal)[T]['from']>
-  encode: (value: ReturnType<(typeof Temporal)[T]['from']>) => string
-}
-
-const createTemporalTransformer = <T extends Types>(
-  type: T,
-  decode = (value: string) => Temporal[type].from(value),
-) => {
-  const encode = (value: ReturnType<(typeof Temporal)[T]['from']>) =>
-    value.toString({
-      calendarName: 'never',
-      smallestUnit: 'microsecond',
-      timeZoneName: 'never',
-    })
-
-  return {
-    decode,
-    encode,
-  } as TemporalTransformer<T>
-}
-
-type EncodedType = ZodMiniString<string>
-
-export class PlainDateType extends TransformType<
-  Temporal.PlainDate,
-  EncodedType
-> {
-  static transformer = createTemporalTransformer('PlainDate')
-
-  static factory() {
-    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,
-  EncodedType
-> {
-  static transformer = createTemporalTransformer('PlainDateTime')
-
-  static factory() {
-    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,
-  EncodedType
-> {
-  static transformer = createTemporalTransformer('ZonedDateTime', (value) =>
-    Temporal.Instant.from(value).toZonedDateTimeISO('UTC'),
-  )
-
-  static factory() {
-    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,
-  EncodedType
-> {
-  static transformer = createTemporalTransformer('PlainTime')
-
-  static factory() {
-    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,
-  EncodedType
-> {
-  static transformer = createTemporalTransformer('Duration')
-
-  static factory() {
-    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,
-  EncodedType
-> {
-  static transformer = createTemporalTransformer('PlainYearMonth')
-
-  static factory() {
-    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,
-  EncodedType
-> {
-  static transformer = createTemporalTransformer('PlainMonthDay')
-
-  static factory() {
-    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',
-    })
-  }
-}
-
-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

package/src/types/tuple.ts

@@ -1,36 +0,0 @@
-import type { ArrayMap } from '@nmtjs/common'
-import * as zod from 'zod/v4-mini'
-import { BaseType } from './base.ts'
-
-export class TupleType<
-  T extends readonly [BaseType, ...BaseType[]] = readonly [
-    BaseType,
-    ...BaseType[],
-  ],
-  R extends BaseType | null = BaseType | null,
-> extends BaseType<
-  R extends BaseType
-    ? zod.ZodMiniTuple<ArrayMap<T, 'encodedZodType'>, R['encodedZodType']>
-    : zod.ZodMiniTuple<ArrayMap<T, 'encodedZodType'>, null>,
-  R extends BaseType
-    ? zod.ZodMiniTuple<ArrayMap<T, 'decodedZodType'>, R['decodedZodType']>
-    : zod.ZodMiniTuple<ArrayMap<T, 'decodedZodType'>, null>,
-  { elements: T; rest?: R }
-> {
-  static factory<
-    T extends readonly [BaseType, ...BaseType[]],
-    R extends BaseType | null = null,
-  >(elements: T, rest: R = null as R) {
-    const encoded = elements.map((el) => el.encodedZodType)
-    const decoded = elements.map((el) => el.decodedZodType)
-    return new TupleType<T, R>({
-      // @ts-expect-error
-      encodedZodType: zod.tuple(encoded, rest?.encodedZodType),
-      // @ts-expect-error
-      decodedZodType: zod.tuple(decoded, rest?.decodedZodType),
-      props: { elements, rest },
-    })
-  }
-}
-
-export const tuple = TupleType.factory

package/src/types/type.ts

@@ -1,31 +0,0 @@
-import type { BaseTypeAny } from './base.ts'
-
-export * from './any.ts'
-export * from './array.ts'
-export * from './boolean.ts'
-export * from './custom.ts'
-export * from './date.ts'
-export * from './enum.ts'
-export * from './literal.ts'
-export * from './never.ts'
-export * from './number.ts'
-export * from './object.ts'
-export * from './string.ts'
-export * from './tuple.ts'
-export * from './union.ts'
-
-export namespace infer {
-  export namespace decoded {
-    export type input<T extends BaseTypeAny> =
-      T['decodedZodType']['_zod']['input']
-    export type output<T extends BaseTypeAny> =
-      T['decodedZodType']['_zod']['output']
-  }
-
-  export namespace encoded {
-    export type input<T extends BaseTypeAny> =
-      T['encodedZodType']['_zod']['input']
-    export type output<T extends BaseTypeAny> =
-      T['encodedZodType']['_zod']['output']
-  }
-}