@nmtjs/type 0.15.0-beta.8 → 0.15.0

package/src/temporal/global.ts

@@ -1,7 +1,6 @@
-import 'temporal-spec/global'
-
 import {
   DurationType,
+  InstantType,
   PlainDateTimeType,
   PlainDateType,
   PlainMonthDayType,
@@ -12,21 +11,25 @@ import {
 
 export const plainDate: () => PlainDateType = PlainDateType.factory.bind(
   PlainDateType,
-  Temporal,
+  globalThis.Temporal,
 )
 export const plainDatetime: () => PlainDateTimeType =
-  PlainDateTimeType.factory.bind(PlainDateTimeType, Temporal)
+  PlainDateTimeType.factory.bind(PlainDateTimeType, globalThis.Temporal)
 export const plainTime: () => PlainTimeType = PlainTimeType.factory.bind(
   PlainTimeType,
-  Temporal,
+  globalThis.Temporal,
 )
 export const zonedDatetime: () => ZonedDateTimeType =
-  ZonedDateTimeType.factory.bind(ZonedDateTimeType, Temporal)
+  ZonedDateTimeType.factory.bind(ZonedDateTimeType, globalThis.Temporal)
+export const instant: () => InstantType = InstantType.factory.bind(
+  InstantType,
+  globalThis.Temporal,
+)
 export const duration: () => DurationType = DurationType.factory.bind(
   DurationType,
-  Temporal,
+  globalThis.Temporal,
 )
 export const plainYearMonth: () => PlainYearMonthType =
-  PlainYearMonthType.factory.bind(PlainYearMonthType, Temporal)
+  PlainYearMonthType.factory.bind(PlainYearMonthType, globalThis.Temporal)
 export const plainMonthDay: () => PlainMonthDayType =
-  PlainMonthDayType.factory.bind(PlainMonthDayType, Temporal)
+  PlainMonthDayType.factory.bind(PlainMonthDayType, globalThis.Temporal)

package/src/temporal/index.ts

@@ -0,0 +1,20 @@
+import {
+  DurationType,
+  InstantType,
+  PlainDateTimeType,
+  PlainDateType,
+  PlainMonthDayType,
+  PlainTimeType,
+  PlainYearMonthType,
+  ZonedDateTimeType,
+} from '../types/temporal.ts'
+
+export const plainDate = PlainDateType.factory.bind(PlainDateType)
+export const plainDatetime = PlainDateTimeType.factory.bind(PlainDateTimeType)
+export const plainTime = PlainTimeType.factory.bind(PlainTimeType)
+export const zonedDatetime = ZonedDateTimeType.factory.bind(ZonedDateTimeType)
+export const instant = InstantType.factory.bind(InstantType)
+export const duration = DurationType.factory.bind(DurationType)
+export const plainYearMonth =
+  PlainYearMonthType.factory.bind(PlainYearMonthType)
+export const plainMonthDay = PlainMonthDayType.factory.bind(PlainMonthDayType)

package/src/temporal/polyfill.ts

@@ -2,6 +2,7 @@ import { Temporal } from 'temporal-polyfill'
 
 import {
   DurationType,
+  InstantType,
   PlainDateTimeType,
   PlainDateType,
   PlainMonthDayType,
@@ -10,22 +11,74 @@ import {
   ZonedDateTimeType,
 } from '../types/temporal.ts'
 
-export const plainDate = PlainDateType.factory.bind(PlainDateType, Temporal)
+export const plainDate = PlainDateType.factory.bind(
+  PlainDateType,
+  // @ts-expect-error
+  Temporal,
+) as () => PlainDateType<
+  // @ts-expect-error
+  typeof Temporal
+>
+
 export const plainDatetime = PlainDateTimeType.factory.bind(
   PlainDateTimeType,
+  // @ts-expect-error
   Temporal,
-)
-export const plainTime = PlainTimeType.factory.bind(PlainTimeType, Temporal)
+) as () => PlainDateTimeType<
+  // @ts-expect-error
+  typeof Temporal
+>
+
+export const plainTime = PlainTimeType.factory.bind(
+  PlainTimeType,
+  // @ts-expect-error
+  Temporal,
+) as () => PlainTimeType<
+  // @ts-expect-error
+  typeof Temporal
+>
+
 export const zonedDatetime = ZonedDateTimeType.factory.bind(
   ZonedDateTimeType,
+  // @ts-expect-error
   Temporal,
-)
-export const duration = DurationType.factory.bind(DurationType, Temporal)
+) as () => ZonedDateTimeType<
+  // @ts-expect-error
+  typeof Temporal
+>
+
+export const instant = InstantType.factory.bind(
+  InstantType,
+  // @ts-expect-error
+  Temporal,
+) as () => InstantType<
+  // @ts-expect-error
+  typeof Temporal
+>
+
+export const duration = DurationType.factory.bind(
+  DurationType,
+  // @ts-expect-error
+  Temporal,
+) as () => DurationType<
+  // @ts-expect-error
+  typeof Temporal
+>
+
 export const plainYearMonth = PlainYearMonthType.factory.bind(
   PlainYearMonthType,
+  // @ts-expect-error
   Temporal,
-)
+) as () => PlainYearMonthType<
+  // @ts-expect-error
+  typeof Temporal
+>
+
 export const plainMonthDay = PlainMonthDayType.factory.bind(
   PlainMonthDayType,
+  // @ts-expect-error
   Temporal,
-)
+) as () => PlainMonthDayType<
+  // @ts-expect-error
+  typeof Temporal
+>

package/src/types/_metadata.ts

@@ -0,0 +1,12 @@
+import { registry } from 'zod/mini'
+
+export type TypeMetadata<T = any> = {
+  id?: string
+  description?: string
+  examples?: T[]
+  title?: string
+}
+
+export const typesRegistry = registry<TypeMetadata>()
+
+export type MetadataRegistry = typeof typesRegistry

package/src/types/_type.ts

@@ -2,6 +2,14 @@ import type { BaseTypeAny } from './base.ts'
 
 export * from './any.ts'
 export * from './array.ts'
+export {
+  BaseType,
+  type BaseTypeAny,
+  DefaultType,
+  NeemataTypeError,
+  NullableType,
+  OptionalType,
+} from './base.ts'
 export * from './boolean.ts'
 export * from './custom.ts'
 export * from './date.ts'
@@ -14,6 +22,7 @@ export * from './object.ts'
 export * from './string.ts'
 export * from './tuple.ts'
 export * from './union.ts'
+export * from './unknown.ts'
 
 export namespace infer {
   export namespace decode {

package/src/types/base.ts

@@ -16,7 +16,11 @@ import type {
   ZodMiniType,
   ZodMiniUnion,
 } from 'zod/mini'
-import { _default, core, nullable, optional, registry } from 'zod/mini'
+import { _default, core, nullable, optional } from 'zod/mini'
+
+import type { TypeMetadata } from './_metadata.ts'
+import { standard } from '../standart-schema.ts'
+import { typesRegistry } from './_metadata.ts'
 
 export type PrimitiveValueType = string | number | boolean | null
 
@@ -43,13 +47,6 @@ 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 = {
   encode?: (value: any) => any
   metadata?: TypeMetadata
@@ -66,8 +63,6 @@ export type BaseTypeAny<
   DecodedZodType extends ZodType = ZodMiniType,
 > = BaseType<EncodedZodType, DecodedZodType, TypeProps>
 
-export const typesRegistry = registry<TypeMetadata>()
-
 export const NeemataTypeError = core.$ZodError
 export type NeemataTypeError = core.$ZodError
 
@@ -77,13 +72,19 @@ export abstract class BaseType<
   Props extends TypeProps = TypeProps,
   RawEncodeZodType extends SimpleZodType = EncodeZodType,
   RawDecodeZodType extends ZodType = DecodeZodType,
-> {
+> implements standard.Schema<DecodeZodType>
+{
   readonly encodeZodType: EncodeZodType
   readonly decodeZodType: DecodeZodType
   readonly encodeRawZodType!: RawEncodeZodType
   readonly decodeRawZodType!: RawDecodeZodType
   readonly props: Props
   readonly params: TypeParams
+  readonly standard: {
+    encode: standard.Schema<EncodeZodType>
+    decode: standard.Schema<DecodeZodType>
+  }
+  readonly '~standard': standard.Props<DecodeZodType>
 
   constructor({
     encodeZodType,
@@ -101,6 +102,11 @@ export abstract class BaseType<
 
     this.props = props
     this.params = Object.assign({ checks: [] }, params)
+    this.standard = {
+      encode: standard.encode(this, typesRegistry),
+      decode: standard.decode(this, typesRegistry),
+    }
+    this['~standard'] = this.standard.decode['~standard']
   }
 
   optional(): OptionalType<this> {

package/src/types/custom.ts

@@ -1,4 +1,4 @@
-import type { Async } from '@nmtjs/common'
+import type { MaybePromise } from '@nmtjs/common'
 import type { core, ZodMiniType } from 'zod/mini'
 import {
   any,
@@ -50,20 +50,19 @@ export class CustomType<
     validation?:
       | ((
           value: EncodeType['_zod']['input'] | DecodeType['_zod']['output'],
-
           payload: core.$RefinementCtx<
             EncodeType['_zod']['output'] | DecodeType['_zod']['output']
           >,
-        ) => Async<void>)
+        ) => MaybePromise<void>)
       | {
           encode?: (
             value: EncodeType['_zod']['input'],
             payload: core.$RefinementCtx<EncodeType['_zod']['output']>,
-          ) => Async<void>
+          ) => MaybePromise<void>
           decode?: (
             value: DecodeType['_zod']['output'],
             payload: core.$RefinementCtx<DecodeType['_zod']['output']>,
-          ) => Async<void>
+          ) => MaybePromise<void>
         }
     error?: string | core.$ZodErrorMap<core.$ZodIssueBase>
     type?: EncodeType

package/src/types/string.ts

@@ -1,5 +1,7 @@
 import type { core, ZodMiniString } from 'zod/mini'
 import {
+  base64,
+  base64url,
   cuid,
   cuid2,
   e164,
@@ -90,6 +92,14 @@ export class StringType extends BaseType<
   jwt(options?: core.$ZodJWTParams) {
     return StringType.factory(...this.params.checks, jwt(options))
   }
+
+  base64(options?: core.$ZodBase64Params) {
+    return StringType.factory(...this.params.checks, base64(options))
+  }
+
+  base64URL(options?: core.$ZodBase64URLParams) {
+    return StringType.factory(...this.params.checks, base64url(options))
+  }
 }
 
 export const string = StringType.factory

package/src/types/temporal.ts

@@ -1,4 +1,3 @@
-import type { Temporal } from 'temporal-spec'
 import type { ZodMiniString } from 'zod/mini'
 import { iso, regex, string } from 'zod/mini'
 
@@ -9,34 +8,38 @@ type Types = Exclude<
   '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
+type TemporalTransformer<T extends typeof Temporal, U extends Types> = {
+  decode: (value: string) => InstanceType<T[U]>
+  encode: (value: InstanceType<T[U]>) => 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']>) =>
+const createTemporalTransformer = <T extends typeof Temporal, U extends Types>(
+  implementation: T,
+  type: U,
+  decode = (value: string | InstanceType<T[U]>) => {
+    if (typeof value === 'string') return implementation[type].from(value)
+    else return value
+  },
+  encode = (value: ReturnType<T[U]['from']>) =>
     value.toString({
       calendarName: 'never',
       smallestUnit: 'microsecond',
       timeZoneName: 'never',
     }),
 ) => {
-  return { decode, encode } as TemporalTransformer<T>
+  return { decode, encode } as TemporalTransformer<T, U>
 }
 
 type EncodeType = ZodMiniString<string>
 
-export class PlainDateType extends TransformType<
-  Temporal.PlainDate,
-  EncodeType
-> {
-  static factory(implementation: typeof Temporal): PlainDateType {
+export class PlainDateType<
+  T extends typeof Temporal = typeof Temporal,
+> extends TransformType<InstanceType<T['PlainDate']>, EncodeType> {
+  static factory<T extends typeof Temporal>(
+    implementation: T,
+  ): PlainDateType<T> {
     const transformer = createTemporalTransformer(implementation, 'PlainDate')
-    return CustomType.factory<Temporal.PlainDate, EncodeType>({
+    return CustomType.factory<InstanceType<T['PlainDate']>, EncodeType>({
       decode: transformer.decode,
       encode: transformer.encode,
       type: iso.date(),
@@ -45,16 +48,17 @@ export class PlainDateType extends TransformType<
   }
 }
 
-export class PlainDateTimeType extends TransformType<
-  Temporal.PlainDateTime,
-  EncodeType
-> {
-  static factory(implementation: typeof Temporal): PlainDateTimeType {
+export class PlainDateTimeType<
+  T extends typeof Temporal = typeof Temporal,
+> extends TransformType<InstanceType<T['PlainDateTime']>, EncodeType> {
+  static factory<T extends typeof Temporal>(
+    implementation: T,
+  ): PlainDateTimeType<T> {
     const transformer = createTemporalTransformer(
       implementation,
       'PlainDateTime',
     )
-    return CustomType.factory<Temporal.PlainDateTime, EncodeType>({
+    return CustomType.factory<InstanceType<T['PlainDateTime']>, EncodeType>({
       decode: transformer.decode,
       encode: transformer.encode,
       type: iso.datetime({ local: true }),
@@ -63,41 +67,52 @@ export class PlainDateTimeType extends TransformType<
   }
 }
 
-export class ZonedDateTimeType extends TransformType<
-  Temporal.ZonedDateTime,
-  EncodeType
-> {
-  static factory(implementation: typeof Temporal): ZonedDateTimeType {
+export class ZonedDateTimeType<
+  T extends typeof Temporal = typeof Temporal,
+> extends TransformType<InstanceType<T['ZonedDateTime']>, EncodeType> {
+  static factory<T extends typeof Temporal>(
+    implementation: T,
+  ): ZonedDateTimeType<T> {
     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',
+      (value) => implementation.ZonedDateTime.from(value),
+      (value) => value.toString({ smallestUnit: 'microsecond' }),
     )
-    return CustomType.factory<Temporal.ZonedDateTime, EncodeType>({
+    return CustomType.factory<InstanceType<T['ZonedDateTime']>, EncodeType>({
       decode: transformer.decode,
       encode: transformer.encode,
-      type: iso.datetime(),
-      error: 'Invalid datetime format',
+      type: string(),
+      error: 'Invalid zoned datetime format',
     })
   }
 }
 
-export class PlainTimeType extends TransformType<
-  Temporal.PlainTime,
-  EncodeType
-> {
-  static factory(implementation: typeof Temporal): PlainTimeType {
+export class InstantType<
+  T extends typeof Temporal = typeof Temporal,
+> extends TransformType<InstanceType<T['Instant']>, EncodeType> {
+  static factory<T extends typeof Temporal>(implementation: T): InstantType<T> {
+    const decode = (value: string) =>
+      implementation.Instant.from(value) as InstanceType<T['Instant']>
+    const encode = (value: InstanceType<T['Instant']>) => value.toJSON()
+
+    return CustomType.factory<InstanceType<T['Instant']>, EncodeType>({
+      decode,
+      encode,
+      type: iso.datetime(),
+      error: 'Invalid instant format',
+    }) as InstantType<T>
+  }
+}
+
+export class PlainTimeType<
+  T extends typeof Temporal = typeof Temporal,
+> extends TransformType<InstanceType<T['PlainTime']>, EncodeType> {
+  static factory<T extends typeof Temporal>(
+    implementation: T,
+  ): PlainTimeType<T> {
     const transformer = createTemporalTransformer(implementation, 'PlainTime')
-    return CustomType.factory<Temporal.PlainTime, EncodeType>({
+    return CustomType.factory<InstanceType<T['PlainTime']>, EncodeType>({
       decode: transformer.decode,
       encode: transformer.encode,
       type: iso.time(),
@@ -106,10 +121,14 @@ export class PlainTimeType extends TransformType<
   }
 }
 
-export class DurationType extends TransformType<Temporal.Duration, EncodeType> {
-  static factory(implementation: typeof Temporal): DurationType {
+export class DurationType<
+  T extends typeof Temporal = typeof Temporal,
+> extends TransformType<InstanceType<T['Duration']>, EncodeType> {
+  static factory<T extends typeof Temporal>(
+    implementation: T,
+  ): DurationType<T> {
     const transformer = createTemporalTransformer(implementation, 'Duration')
-    return CustomType.factory<Temporal.Duration, EncodeType>({
+    return CustomType.factory<InstanceType<T['Duration']>, EncodeType>({
       decode: transformer.decode,
       encode: transformer.encode,
       type: iso.duration(),
@@ -118,16 +137,17 @@ export class DurationType extends TransformType<Temporal.Duration, EncodeType> {
   }
 }
 
-export class PlainYearMonthType extends TransformType<
-  Temporal.PlainYearMonth,
-  EncodeType
-> {
-  static factory(implementation: typeof Temporal): PlainYearMonthType {
+export class PlainYearMonthType<
+  T extends typeof Temporal = typeof Temporal,
+> extends TransformType<InstanceType<T['PlainYearMonth']>, EncodeType> {
+  static factory<T extends typeof Temporal>(
+    implementation: T,
+  ): PlainYearMonthType<T> {
     const transformer = createTemporalTransformer(
       implementation,
       'PlainYearMonth',
     )
-    return CustomType.factory<Temporal.PlainYearMonth, EncodeType>({
+    return CustomType.factory<InstanceType<T['PlainYearMonth']>, EncodeType>({
       decode: transformer.decode,
       encode: transformer.encode,
       type: string().check(regex(/^\d{4}-\d{2}$/)),
@@ -136,16 +156,17 @@ export class PlainYearMonthType extends TransformType<
   }
 }
 
-export class PlainMonthDayType extends TransformType<
-  Temporal.PlainMonthDay,
-  EncodeType
-> {
-  static factory(implementation: typeof Temporal): PlainMonthDayType {
+export class PlainMonthDayType<
+  T extends typeof Temporal = typeof Temporal,
+> extends TransformType<InstanceType<T['PlainMonthDay']>, EncodeType> {
+  static factory<T extends typeof Temporal>(
+    implementation: T,
+  ): PlainMonthDayType<T> {
     const transformer = createTemporalTransformer(
       implementation,
       'PlainMonthDay',
     )
-    return CustomType.factory<Temporal.PlainMonthDay, EncodeType>({
+    return CustomType.factory<InstanceType<T['PlainMonthDay']>, EncodeType>({
       decode: transformer.decode,
       encode: transformer.encode,
       type: string().check(regex(/^\d{2}-\d{2}$/)),

package/src/types/unknown.ts

@@ -0,0 +1,12 @@
+import type { ZodMiniUnknown } from 'zod/mini'
+import { unknown as zodUnknown } from 'zod/mini'
+
+import { BaseType } from './base.ts'
+
+export class UnknownType extends BaseType<ZodMiniUnknown> {
+  static factory() {
+    return new UnknownType({ encodeZodType: zodUnknown() })
+  }
+}
+
+export const unknown = UnknownType.factory