@nmtjs/type 0.14.5 → 0.15.0-beta.10

package/src/types/temporal.ts

@@ -0,0 +1,155 @@
+import type { Temporal } from 'temporal-spec'
+import type { ZodMiniString } from 'zod/mini'
+import { iso, regex, string } from 'zod/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>(
+  implementation: typeof Temporal,
+  type: T,
+  decode = (value: string) => implementation[type].from(value),
+  encode = (value: ReturnType<(typeof Temporal)[T]['from']>) =>
+    value.toString({
+      calendarName: 'never',
+      smallestUnit: 'microsecond',
+      timeZoneName: 'never',
+    }),
+) => {
+  return { decode, encode } as TemporalTransformer<T>
+}
+
+type EncodeType = ZodMiniString<string>
+
+export class PlainDateType extends TransformType<
+  Temporal.PlainDate,
+  EncodeType
+> {
+  static factory(implementation: typeof Temporal): PlainDateType {
+    const transformer = createTemporalTransformer(implementation, 'PlainDate')
+    return CustomType.factory<Temporal.PlainDate, EncodeType>({
+      decode: transformer.decode,
+      encode: transformer.encode,
+      type: iso.date(),
+      error: 'Invalid date format',
+    })
+  }
+}
+
+export class PlainDateTimeType extends TransformType<
+  Temporal.PlainDateTime,
+  EncodeType
+> {
+  static factory(implementation: typeof Temporal): PlainDateTimeType {
+    const transformer = createTemporalTransformer(
+      implementation,
+      'PlainDateTime',
+    )
+    return CustomType.factory<Temporal.PlainDateTime, EncodeType>({
+      decode: transformer.decode,
+      encode: transformer.encode,
+      type: iso.datetime({ local: true }),
+      error: 'Invalid datetime format',
+    })
+  }
+}
+
+export class ZonedDateTimeType extends TransformType<
+  Temporal.ZonedDateTime,
+  EncodeType
+> {
+  static factory(implementation: typeof Temporal): ZonedDateTimeType {
+    const transformer = createTemporalTransformer(
+      implementation,
+      'ZonedDateTime',
+      (value) => implementation.Instant.from(value).toZonedDateTimeISO('UTC'),
+      (value) =>
+        value
+          .withTimeZone('UTC')
+          .toString({
+            smallestUnit: 'milliseconds',
+            timeZoneName: 'never',
+            calendarName: 'never',
+            offset: 'never',
+          }) + 'Z',
+    )
+    return CustomType.factory<Temporal.ZonedDateTime, EncodeType>({
+      decode: transformer.decode,
+      encode: transformer.encode,
+      type: iso.datetime(),
+      error: 'Invalid datetime format',
+    })
+  }
+}
+
+export class PlainTimeType extends TransformType<
+  Temporal.PlainTime,
+  EncodeType
+> {
+  static factory(implementation: typeof Temporal): PlainTimeType {
+    const transformer = createTemporalTransformer(implementation, 'PlainTime')
+    return CustomType.factory<Temporal.PlainTime, EncodeType>({
+      decode: transformer.decode,
+      encode: transformer.encode,
+      type: iso.time(),
+      error: 'Invalid time format',
+    })
+  }
+}
+
+export class DurationType extends TransformType<Temporal.Duration, EncodeType> {
+  static factory(implementation: typeof Temporal): DurationType {
+    const transformer = createTemporalTransformer(implementation, 'Duration')
+    return CustomType.factory<Temporal.Duration, EncodeType>({
+      decode: transformer.decode,
+      encode: transformer.encode,
+      type: iso.duration(),
+      error: 'Invalid duration format',
+    })
+  }
+}
+
+export class PlainYearMonthType extends TransformType<
+  Temporal.PlainYearMonth,
+  EncodeType
+> {
+  static factory(implementation: typeof Temporal): PlainYearMonthType {
+    const transformer = createTemporalTransformer(
+      implementation,
+      'PlainYearMonth',
+    )
+    return CustomType.factory<Temporal.PlainYearMonth, EncodeType>({
+      decode: transformer.decode,
+      encode: transformer.encode,
+      type: string().check(regex(/^\d{4}-\d{2}$/)),
+      error: 'Invalid year-month format',
+    })
+  }
+}
+
+export class PlainMonthDayType extends TransformType<
+  Temporal.PlainMonthDay,
+  EncodeType
+> {
+  static factory(implementation: typeof Temporal): PlainMonthDayType {
+    const transformer = createTemporalTransformer(
+      implementation,
+      'PlainMonthDay',
+    )
+    return CustomType.factory<Temporal.PlainMonthDay, EncodeType>({
+      decode: transformer.decode,
+      encode: transformer.encode,
+      type: string().check(regex(/^\d{2}-\d{2}$/)),
+      error: 'Invalid month-day format',
+    })
+  }
+}

package/src/types/tuple.ts

@@ -0,0 +1,49 @@
+import type { ArrayMap } from '@nmtjs/common'
+import type { ZodMiniTuple } from 'zod/mini'
+import { tuple as zodTuple } from 'zod/mini'
+
+import type { ZodPlainType } from './_utils.ts'
+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
+    ? ZodMiniTuple<ArrayMap<T, 'encodeZodType'>, R['encodeZodType']>
+    : ZodMiniTuple<ArrayMap<T, 'encodeZodType'>, null>,
+  R extends BaseType
+    ? ZodMiniTuple<ArrayMap<T, 'decodeZodType'>, R['decodeZodType']>
+    : ZodMiniTuple<ArrayMap<T, 'decodeZodType'>, null>,
+  { elements: T; rest?: R },
+  R extends BaseType
+    ? ZodPlainType<
+        ZodMiniTuple<ArrayMap<T, 'encodeZodType'>, R['encodeZodType']>
+      >
+    : ZodPlainType<ZodMiniTuple<ArrayMap<T, 'encodeZodType'>, null>>,
+  R extends BaseType
+    ? ZodPlainType<
+        ZodMiniTuple<ArrayMap<T, 'decodeZodType'>, R['decodeZodType']>
+      >
+    : ZodPlainType<ZodMiniTuple<ArrayMap<T, 'decodeZodType'>, null>>
+> {
+  static factory<
+    T extends readonly [BaseType, ...BaseType[]],
+    R extends BaseType | null = null,
+  >(elements: T, rest: R = null as R) {
+    const encode = elements.map((el) => el.encodeZodType)
+    const decode = elements.map((el) => el.decodeZodType)
+    return new TupleType<T, R>({
+      // @ts-expect-error
+      encodeZodType: zodTuple(encode, rest?.encodeZodType),
+      // @ts-expect-error
+      decodeZodType: zodTuple(decode, rest?.decodeZodType),
+      props: { elements, rest },
+    })
+  }
+}
+
+export const tuple = TupleType.factory

package/src/types/union.ts

@@ -0,0 +1,120 @@
+import type { ArrayMap } from '@nmtjs/common'
+import type {
+  ZodMiniDiscriminatedUnion,
+  ZodMiniIntersection,
+  ZodMiniUnion,
+} from 'zod/mini'
+import {
+  discriminatedUnion as zodDiscriminatedUnion,
+  intersection as zodIntersection,
+  union as zodUnion,
+} from 'zod/mini'
+
+import type { ZodPlainType } from './_utils.ts'
+import type { BaseTypeAny } from './base.ts'
+import type { LiteralType } from './literal.ts'
+import type { ObjectType, ObjectTypeProps } from './object.ts'
+import { BaseType } from './base.ts'
+
+export class UnionType<
+  T extends readonly [BaseType, ...BaseType[]] = readonly [
+    BaseType,
+    ...BaseType[],
+  ],
+> extends BaseType<
+  ZodMiniUnion<ArrayMap<T, 'encodeZodType'>>,
+  ZodMiniUnion<ArrayMap<T, 'decodeZodType'>>,
+  { options: T },
+  ZodPlainType<ZodMiniUnion<ArrayMap<T, 'encodeZodType'>>>,
+  ZodPlainType<ZodMiniUnion<ArrayMap<T, 'decodeZodType'>>>
+> {
+  static factory<
+    T extends readonly [BaseType, ...BaseType[]] = readonly [
+      BaseType,
+      ...BaseType[],
+    ],
+  >(...options: T) {
+    const encode = options.map((t) => t.encodeZodType) as ArrayMap<
+      T,
+      'encodeZodType'
+    >
+    const decode = options.map((t) => t.decodeZodType) as ArrayMap<
+      T,
+      'decodeZodType'
+    >
+    return new UnionType<T>({
+      encodeZodType: zodUnion(encode),
+      decodeZodType: zodUnion(decode),
+      props: { options },
+    })
+  }
+}
+
+export class IntersactionType<
+  T extends readonly [BaseType, BaseType] = readonly [BaseType, BaseType],
+> extends BaseType<
+  ZodMiniIntersection<T[0]['encodeZodType'], T[1]['encodeZodType']>,
+  ZodMiniIntersection<T[0]['decodeZodType'], T[1]['decodeZodType']>,
+  { options: T }
+> {
+  static factory<
+    T extends readonly [BaseType, BaseType] = readonly [BaseType, BaseType],
+  >(...options: T) {
+    const [first, second] = options
+    return new IntersactionType<T>({
+      encodeZodType: zodIntersection(first.encodeZodType, second.encodeZodType),
+      decodeZodType: zodIntersection(first.decodeZodType, second.decodeZodType),
+      props: { options },
+    })
+  }
+}
+
+export type DiscriminatedUnionProperties<K extends string = string> = {
+  [OK in K]: LiteralType<string>
+} & {
+  [OK in string]: any
+}
+
+export type DiscriminatedUnionOptionType<K extends string> = ObjectType<
+  ObjectTypeProps & { [_ in K]: BaseTypeAny }
+>
+
+export class DiscriminatedUnionType<
+  K extends string = string,
+  T extends
+    readonly DiscriminatedUnionOptionType<K>[] = DiscriminatedUnionOptionType<K>[],
+> extends BaseType<
+  ZodMiniDiscriminatedUnion<ArrayMap<T, 'encodeZodType'>>,
+  ZodMiniDiscriminatedUnion<ArrayMap<T, 'decodeZodType'>>,
+  { key: K; options: T },
+  ZodPlainType<ZodMiniDiscriminatedUnion<ArrayMap<T, 'encodeZodType'>>>,
+  ZodPlainType<ZodMiniDiscriminatedUnion<ArrayMap<T, 'decodeZodType'>>>
+> {
+  static factory<
+    K extends string = string,
+    T extends
+      readonly DiscriminatedUnionOptionType<K>[] = DiscriminatedUnionOptionType<K>[],
+  >(key: K, ...options: T) {
+    const encode = options.map((t) => t.encodeZodType) as ArrayMap<
+      T,
+      'encodeZodType'
+    >
+    const decode = options.map((t) => t.decodeZodType) as ArrayMap<
+      T,
+      'decodeZodType'
+    >
+    return new DiscriminatedUnionType<K, T>({
+      // @ts-expect-error
+      encodeZodType: zodDiscriminatedUnion(key, encode),
+      // @ts-expect-error
+      decodeZodType: zodDiscriminatedUnion(key, decode),
+      props: { key, options },
+    })
+  }
+}
+
+export const union = UnionType.factory
+export const or = UnionType.factory
+export const intersection = IntersactionType.factory
+export const and = IntersactionType.factory
+export const discriminatedUnion = DiscriminatedUnionType.factory