@nmtjs/type 0.14.2 → 0.14.4

package/dist/temporal/global.d.ts

@@ -0,0 +1,8 @@
+import 'temporal-spec/global';
+export declare const plainDate: () => import("../types/custom.ts").CustomType<import("temporal-spec").Temporal.PlainDate, import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniType<import("temporal-spec").Temporal.PlainDate, import("temporal-spec").Temporal.PlainDate, import("zod/v4/core").$ZodTypeInternals<import("temporal-spec").Temporal.PlainDate, import("temporal-spec").Temporal.PlainDate>>>;
+export declare const plainDatetime: () => import("../types/custom.ts").CustomType<import("temporal-spec").Temporal.PlainDateTime, import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniType<import("temporal-spec").Temporal.PlainDateTime, import("temporal-spec").Temporal.PlainDateTime, import("zod/v4/core").$ZodTypeInternals<import("temporal-spec").Temporal.PlainDateTime, import("temporal-spec").Temporal.PlainDateTime>>>;
+export declare const plainTime: () => import("../types/custom.ts").CustomType<import("temporal-spec").Temporal.PlainTime, import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniType<import("temporal-spec").Temporal.PlainTime, import("temporal-spec").Temporal.PlainTime, import("zod/v4/core").$ZodTypeInternals<import("temporal-spec").Temporal.PlainTime, import("temporal-spec").Temporal.PlainTime>>>;
+export declare const zonedDatetime: () => import("../types/custom.ts").CustomType<import("temporal-spec").Temporal.ZonedDateTime, import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniType<import("temporal-spec").Temporal.ZonedDateTime, import("temporal-spec").Temporal.ZonedDateTime, import("zod/v4/core").$ZodTypeInternals<import("temporal-spec").Temporal.ZonedDateTime, import("temporal-spec").Temporal.ZonedDateTime>>>;
+export declare const duration: () => import("../types/custom.ts").CustomType<import("temporal-spec").Temporal.Duration, import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniType<import("temporal-spec").Temporal.Duration, import("temporal-spec").Temporal.Duration, import("zod/v4/core").$ZodTypeInternals<import("temporal-spec").Temporal.Duration, import("temporal-spec").Temporal.Duration>>>;
+export declare const plainYearMonth: () => import("../types/custom.ts").CustomType<import("temporal-spec").Temporal.PlainYearMonth, import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniType<import("temporal-spec").Temporal.PlainYearMonth, import("temporal-spec").Temporal.PlainYearMonth, import("zod/v4/core").$ZodTypeInternals<import("temporal-spec").Temporal.PlainYearMonth, import("temporal-spec").Temporal.PlainYearMonth>>>;
+export declare const plainMonthDay: () => import("../types/custom.ts").CustomType<import("temporal-spec").Temporal.PlainMonthDay, import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniType<import("temporal-spec").Temporal.PlainMonthDay, import("temporal-spec").Temporal.PlainMonthDay, import("zod/v4/core").$ZodTypeInternals<import("temporal-spec").Temporal.PlainMonthDay, import("temporal-spec").Temporal.PlainMonthDay>>>;

package/dist/temporal/global.js

@@ -0,0 +1,9 @@
+import 'temporal-spec/global';
+import { DurationType, PlainDateTimeType, PlainDateType, PlainMonthDayType, PlainTimeType, PlainYearMonthType, ZonedDateTimeType, } from "../types/temporal.js";
+export const plainDate = PlainDateType.factory.bind(PlainDateType, Temporal);
+export const plainDatetime = PlainDateTimeType.factory.bind(PlainDateTimeType, Temporal);
+export const plainTime = PlainTimeType.factory.bind(PlainTimeType, Temporal);
+export const zonedDatetime = ZonedDateTimeType.factory.bind(ZonedDateTimeType, Temporal);
+export const duration = DurationType.factory.bind(DurationType, Temporal);
+export const plainYearMonth = PlainYearMonthType.factory.bind(PlainYearMonthType, Temporal);
+export const plainMonthDay = PlainMonthDayType.factory.bind(PlainMonthDayType, Temporal);

package/dist/temporal/polyfill.d.ts

@@ -0,0 +1,8 @@
+import { Temporal } from 'temporal-polyfill';
+export declare const plainDate: () => import("../types/custom.ts").CustomType<Temporal.PlainDate, import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniType<Temporal.PlainDate, Temporal.PlainDate, import("zod/v4/core").$ZodTypeInternals<Temporal.PlainDate, Temporal.PlainDate>>>;
+export declare const plainDatetime: () => import("../types/custom.ts").CustomType<Temporal.PlainDateTime, import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniType<Temporal.PlainDateTime, Temporal.PlainDateTime, import("zod/v4/core").$ZodTypeInternals<Temporal.PlainDateTime, Temporal.PlainDateTime>>>;
+export declare const plainTime: () => import("../types/custom.ts").CustomType<Temporal.PlainTime, import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniType<Temporal.PlainTime, Temporal.PlainTime, import("zod/v4/core").$ZodTypeInternals<Temporal.PlainTime, Temporal.PlainTime>>>;
+export declare const zonedDatetime: () => import("../types/custom.ts").CustomType<Temporal.ZonedDateTime, import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniType<Temporal.ZonedDateTime, Temporal.ZonedDateTime, import("zod/v4/core").$ZodTypeInternals<Temporal.ZonedDateTime, Temporal.ZonedDateTime>>>;
+export declare const duration: () => import("../types/custom.ts").CustomType<Temporal.Duration, import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniType<Temporal.Duration, Temporal.Duration, import("zod/v4/core").$ZodTypeInternals<Temporal.Duration, Temporal.Duration>>>;
+export declare const plainYearMonth: () => import("../types/custom.ts").CustomType<Temporal.PlainYearMonth, import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniType<Temporal.PlainYearMonth, Temporal.PlainYearMonth, import("zod/v4/core").$ZodTypeInternals<Temporal.PlainYearMonth, Temporal.PlainYearMonth>>>;
+export declare const plainMonthDay: () => import("../types/custom.ts").CustomType<Temporal.PlainMonthDay, import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniType<Temporal.PlainMonthDay, Temporal.PlainMonthDay, import("zod/v4/core").$ZodTypeInternals<Temporal.PlainMonthDay, Temporal.PlainMonthDay>>>;

package/dist/temporal/polyfill.js

@@ -0,0 +1,9 @@
+import { Temporal } from 'temporal-polyfill';
+import { DurationType, PlainDateTimeType, PlainDateType, PlainMonthDayType, PlainTimeType, PlainYearMonthType, ZonedDateTimeType, } from "../types/temporal.js";
+export const plainDate = PlainDateType.factory.bind(PlainDateType, Temporal);
+export const plainDatetime = PlainDateTimeType.factory.bind(PlainDateTimeType, Temporal);
+export const plainTime = PlainTimeType.factory.bind(PlainTimeType, Temporal);
+export const zonedDatetime = ZonedDateTimeType.factory.bind(ZonedDateTimeType, Temporal);
+export const duration = DurationType.factory.bind(DurationType, Temporal);
+export const plainYearMonth = PlainYearMonthType.factory.bind(PlainYearMonthType, Temporal);
+export const plainMonthDay = PlainMonthDayType.factory.bind(PlainMonthDayType, Temporal);

package/dist/types/temporal.d.ts

@@ -1,45 +1,26 @@
+import type { Temporal } from 'temporal-spec';
 import type { ZodMiniString } from 'zod/mini';
-import { Temporal } from 'temporal-polyfill';
 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;
-};
 type EncodeType = ZodMiniString<string>;
 export declare class PlainDateType extends TransformType<Temporal.PlainDate, EncodeType> {
-    static transformer: TemporalTransformer<"PlainDate">;
-    static factory(): CustomType<Temporal.PlainDate, EncodeType, import("zod/mini").ZodMiniType<Temporal.PlainDate, Temporal.PlainDate, import("zod/v4/core").$ZodTypeInternals<Temporal.PlainDate, Temporal.PlainDate>>>;
+    static factory(implementation: typeof Temporal): CustomType<Temporal.PlainDate, EncodeType, import("zod/mini").ZodMiniType<Temporal.PlainDate, Temporal.PlainDate, import("zod/v4/core").$ZodTypeInternals<Temporal.PlainDate, Temporal.PlainDate>>>;
 }
 export declare class PlainDateTimeType extends TransformType<Temporal.PlainDateTime, EncodeType> {
-    static transformer: TemporalTransformer<"PlainDateTime">;
-    static factory(): CustomType<Temporal.PlainDateTime, EncodeType, import("zod/mini").ZodMiniType<Temporal.PlainDateTime, Temporal.PlainDateTime, import("zod/v4/core").$ZodTypeInternals<Temporal.PlainDateTime, Temporal.PlainDateTime>>>;
+    static factory(implementation: typeof Temporal): CustomType<Temporal.PlainDateTime, EncodeType, import("zod/mini").ZodMiniType<Temporal.PlainDateTime, Temporal.PlainDateTime, import("zod/v4/core").$ZodTypeInternals<Temporal.PlainDateTime, Temporal.PlainDateTime>>>;
 }
 export declare class ZonedDateTimeType extends TransformType<Temporal.ZonedDateTime, EncodeType> {
-    static transformer: TemporalTransformer<"ZonedDateTime">;
-    static factory(): CustomType<Temporal.ZonedDateTime, EncodeType, import("zod/mini").ZodMiniType<Temporal.ZonedDateTime, Temporal.ZonedDateTime, import("zod/v4/core").$ZodTypeInternals<Temporal.ZonedDateTime, Temporal.ZonedDateTime>>>;
+    static factory(implementation: typeof Temporal): CustomType<Temporal.ZonedDateTime, EncodeType, import("zod/mini").ZodMiniType<Temporal.ZonedDateTime, Temporal.ZonedDateTime, import("zod/v4/core").$ZodTypeInternals<Temporal.ZonedDateTime, Temporal.ZonedDateTime>>>;
 }
 export declare class PlainTimeType extends TransformType<Temporal.PlainTime, EncodeType> {
-    static transformer: TemporalTransformer<"PlainTime">;
-    static factory(): CustomType<Temporal.PlainTime, EncodeType, import("zod/mini").ZodMiniType<Temporal.PlainTime, Temporal.PlainTime, import("zod/v4/core").$ZodTypeInternals<Temporal.PlainTime, Temporal.PlainTime>>>;
+    static factory(implementation: typeof Temporal): CustomType<Temporal.PlainTime, EncodeType, import("zod/mini").ZodMiniType<Temporal.PlainTime, Temporal.PlainTime, import("zod/v4/core").$ZodTypeInternals<Temporal.PlainTime, Temporal.PlainTime>>>;
 }
 export declare class DurationType extends TransformType<Temporal.Duration, EncodeType> {
-    static transformer: TemporalTransformer<"Duration">;
-    static factory(): CustomType<Temporal.Duration, EncodeType, import("zod/mini").ZodMiniType<Temporal.Duration, Temporal.Duration, import("zod/v4/core").$ZodTypeInternals<Temporal.Duration, Temporal.Duration>>>;
+    static factory(implementation: typeof Temporal): CustomType<Temporal.Duration, EncodeType, import("zod/mini").ZodMiniType<Temporal.Duration, Temporal.Duration, import("zod/v4/core").$ZodTypeInternals<Temporal.Duration, Temporal.Duration>>>;
 }
 export declare class PlainYearMonthType extends TransformType<Temporal.PlainYearMonth, EncodeType> {
-    static transformer: TemporalTransformer<"PlainYearMonth">;
-    static factory(): CustomType<Temporal.PlainYearMonth, EncodeType, import("zod/mini").ZodMiniType<Temporal.PlainYearMonth, Temporal.PlainYearMonth, import("zod/v4/core").$ZodTypeInternals<Temporal.PlainYearMonth, Temporal.PlainYearMonth>>>;
+    static factory(implementation: typeof Temporal): CustomType<Temporal.PlainYearMonth, EncodeType, import("zod/mini").ZodMiniType<Temporal.PlainYearMonth, Temporal.PlainYearMonth, import("zod/v4/core").$ZodTypeInternals<Temporal.PlainYearMonth, Temporal.PlainYearMonth>>>;
 }
 export declare class PlainMonthDayType extends TransformType<Temporal.PlainMonthDay, EncodeType> {
-    static transformer: TemporalTransformer<"PlainMonthDay">;
-    static factory(): CustomType<Temporal.PlainMonthDay, EncodeType, import("zod/mini").ZodMiniType<Temporal.PlainMonthDay, Temporal.PlainMonthDay, import("zod/v4/core").$ZodTypeInternals<Temporal.PlainMonthDay, Temporal.PlainMonthDay>>>;
+    static factory(implementation: typeof Temporal): CustomType<Temporal.PlainMonthDay, EncodeType, import("zod/mini").ZodMiniType<Temporal.PlainMonthDay, Temporal.PlainMonthDay, import("zod/v4/core").$ZodTypeInternals<Temporal.PlainMonthDay, Temporal.PlainMonthDay>>>;
 }
-export declare const plainDate: typeof PlainDateType.factory;
-export declare const plainDatetime: typeof PlainDateTimeType.factory;
-export declare const plainTime: typeof PlainTimeType.factory;
-export declare const zonedDatetime: typeof ZonedDateTimeType.factory;
-export declare const duration: typeof DurationType.factory;
-export declare const plainYearMonth: typeof PlainYearMonthType.factory;
-export declare const plainMonthDay: typeof PlainMonthDayType.factory;
 export {};

package/dist/types/temporal.js

@@ -1,95 +1,93 @@
-import { Temporal } from 'temporal-polyfill';
 import { iso, regex, string } from 'zod/mini';
 import { CustomType, TransformType } from "./custom.js";
-const createTemporalTransformer = (type, decode = (value) => Temporal[type].from(value)) => {
-    const encode = (value) => value.toString({
-        calendarName: 'never',
-        smallestUnit: 'microsecond',
-        timeZoneName: 'never',
-    });
+const createTemporalTransformer = (implementation, type, decode = (value) => implementation[type].from(value), encode = (value) => value.toString({
+    calendarName: 'never',
+    smallestUnit: 'microsecond',
+    timeZoneName: 'never',
+})) => {
     return { decode, encode };
 };
 export class PlainDateType extends TransformType {
-    static transformer = createTemporalTransformer('PlainDate');
-    static factory() {
+    static factory(implementation) {
+        const transformer = createTemporalTransformer(implementation, 'PlainDate');
         return CustomType.factory({
-            decode: PlainDateType.transformer.decode,
-            encode: PlainDateType.transformer.encode,
+            decode: transformer.decode,
+            encode: transformer.encode,
             type: iso.date(),
             error: 'Invalid date format',
         });
     }
 }
 export class PlainDateTimeType extends TransformType {
-    static transformer = createTemporalTransformer('PlainDateTime');
-    static factory() {
+    static factory(implementation) {
+        const transformer = createTemporalTransformer(implementation, 'PlainDateTime');
         return CustomType.factory({
-            decode: PlainDateTimeType.transformer.decode,
-            encode: PlainDateTimeType.transformer.encode,
+            decode: transformer.decode,
+            encode: transformer.encode,
             type: iso.datetime({ local: true }),
             error: 'Invalid datetime format',
         });
     }
 }
 export class ZonedDateTimeType extends TransformType {
-    static transformer = createTemporalTransformer('ZonedDateTime', (value) => Temporal.Instant.from(value).toZonedDateTimeISO('UTC'));
-    static factory() {
+    static factory(implementation) {
+        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({
-            decode: ZonedDateTimeType.transformer.decode,
-            encode: ZonedDateTimeType.transformer.encode,
-            type: iso.datetime({ local: true }),
+            decode: transformer.decode,
+            encode: transformer.encode,
+            type: iso.datetime(),
             error: 'Invalid datetime format',
         });
     }
 }
 export class PlainTimeType extends TransformType {
-    static transformer = createTemporalTransformer('PlainTime');
-    static factory() {
+    static factory(implementation) {
+        const transformer = createTemporalTransformer(implementation, 'PlainTime');
         return CustomType.factory({
-            decode: PlainTimeType.transformer.decode,
-            encode: PlainTimeType.transformer.encode,
+            decode: transformer.decode,
+            encode: transformer.encode,
             type: iso.time(),
             error: 'Invalid time format',
         });
     }
 }
 export class DurationType extends TransformType {
-    static transformer = createTemporalTransformer('Duration');
-    static factory() {
+    static factory(implementation) {
+        const transformer = createTemporalTransformer(implementation, 'Duration');
         return CustomType.factory({
-            decode: DurationType.transformer.decode,
-            encode: DurationType.transformer.encode,
+            decode: transformer.decode,
+            encode: transformer.encode,
             type: iso.duration(),
             error: 'Invalid duration format',
         });
     }
 }
 export class PlainYearMonthType extends TransformType {
-    static transformer = createTemporalTransformer('PlainYearMonth');
-    static factory() {
+    static factory(implementation) {
+        const transformer = createTemporalTransformer(implementation, 'PlainYearMonth');
         return CustomType.factory({
-            decode: PlainYearMonthType.transformer.decode,
-            encode: PlainYearMonthType.transformer.encode,
+            decode: transformer.decode,
+            encode: transformer.encode,
             type: string().check(regex(/^\d{4}-\d{2}$/)),
             error: 'Invalid year-month format',
         });
     }
 }
 export class PlainMonthDayType extends TransformType {
-    static transformer = createTemporalTransformer('PlainMonthDay');
-    static factory() {
+    static factory(implementation) {
+        const transformer = createTemporalTransformer(implementation, 'PlainMonthDay');
         return CustomType.factory({
-            decode: PlainMonthDayType.transformer.decode,
-            encode: PlainMonthDayType.transformer.encode,
+            decode: transformer.decode,
+            encode: 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/package.json

@@ -1,6 +1,11 @@
 {
   "name": "@nmtjs/type",
   "type": "module",
+  "files": [
+    "dist",
+    "LICENSE.md",
+    "README.md"
+  ],
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
@@ -13,27 +18,35 @@
       "module-sync": "./dist/types/*.js"
     },
     "./temporal": {
-      "types": "./dist/temporal.d.ts",
-      "import": "./dist/temporal.js",
-      "module-sync": "./dist/temporal.js"
+      "types": "./dist/temporal/global.d.ts",
+      "import": "./dist/temporal/global.js",
+      "module-sync": "./dist/temporal/global.js"
+    },
+    "./temporal-polyfill": {
+      "types": "./dist/temporal/polyfill.d.ts",
+      "import": "./dist/temporal/polyfill.js",
+      "module-sync": "./dist/temporal/polyfill.js"
     }
   },
+  "dependencies": {
+    "temporal-spec": "^0.3.0"
+  },
   "peerDependencies": {
     "temporal-polyfill": "^0.3.0",
     "zod": "^4.0.0",
-    "@nmtjs/common": "0.14.2"
+    "@nmtjs/common": "0.14.4"
   },
   "devDependencies": {
     "temporal-polyfill": "^0.3.0",
     "zod": "^4.0.0",
-    "@nmtjs/common": "0.14.2"
+    "@nmtjs/common": "0.14.4"
   },
-  "files": [
-    "dist",
-    "LICENSE.md",
-    "README.md"
-  ],
-  "version": "0.14.2",
+  "peerDependenciesMeta": {
+    "temporal-polyfill": {
+      "optional": true
+    }
+  },
+  "version": "0.14.4",
   "scripts": {
     "build": "tsc",
     "type-check": "tsc --noEmit"

package/dist/temporal.d.ts

@@ -1 +0,0 @@
-export * from './types/temporal.ts';

package/dist/temporal.js

@@ -1 +0,0 @@
-export * from "./types/temporal.js";