@xylabs/zod 5.0.42 → 5.0.44

package/dist/neutral/index.d.ts

@@ -1,6 +1,8 @@
 export * from './Config.ts';
 export * from './zodAllFactory.ts';
+export * from './zodAsAsyncFactory.ts';
 export * from './zodAsFactory.ts';
 export * from './zodIsFactory.ts';
+export * from './zodToAsyncFactory.ts';
 export * from './zodToFactory.ts';
 //# sourceMappingURL=index.d.ts.map

package/dist/neutral/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAA;AAC3B,cAAc,oBAAoB,CAAA;AAClC,cAAc,mBAAmB,CAAA;AACjC,cAAc,mBAAmB,CAAA;AACjC,cAAc,mBAAmB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAA;AAC3B,cAAc,oBAAoB,CAAA;AAClC,cAAc,wBAAwB,CAAA;AACtC,cAAc,mBAAmB,CAAA;AACjC,cAAc,mBAAmB,CAAA;AACjC,cAAc,wBAAwB,CAAA;AACtC,cAAc,mBAAmB,CAAA"}

package/dist/neutral/index.mjs

@@ -4,7 +4,7 @@ function zodAsFactory(zod, name) {
   function asFunc(value, assert) {
     const result = zod.safeParse(value);
     if (result.success) {
-      return result.data;
+      return value;
     }
     if (assert !== void 0) {
       let assertConfig;
@@ -53,10 +53,54 @@ function zodAllFactory(zod, name) {
     [`to${name}`]: zodToFactory(zod, `to${name}`)
   };
 }
+
+// src/zodAsAsyncFactory.ts
+import { assertError as assertError2 } from "@xylabs/error";
+function zodAsAsyncFactory(zod, name) {
+  async function asFunc(value, assert) {
+    const result = await zod.safeParseAsync(value);
+    if (result.success) {
+      return value;
+    }
+    if (assert !== void 0) {
+      let assertConfig;
+      switch (typeof assert) {
+        case "string": {
+          assertConfig = `[${name}][${value}] ${assert}`;
+          break;
+        }
+        case "object": {
+          assertConfig = `[${name}][${assert.name}][${value}] ${result.error.message}`;
+          break;
+        }
+        case "boolean": {
+          assertConfig = `[${name}][${value}] ${result.error.message}`;
+          break;
+        }
+        case "function": {
+          assertConfig = assert(value, result.error.message);
+          break;
+        }
+        default: {
+          assertConfig = true;
+        }
+      }
+      return assertError2(value, assertConfig, result.error.message);
+    }
+  }
+  return asFunc;
+}
+
+// src/zodToAsyncFactory.ts
+function zodToAsyncFactory(zod, name) {
+  return zodAsAsyncFactory(zod, name);
+}
 export {
   zodAllFactory,
+  zodAsAsyncFactory,
   zodAsFactory,
   zodIsFactory,
+  zodToAsyncFactory,
   zodToFactory
 };
 //# sourceMappingURL=index.mjs.map

package/dist/neutral/index.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/zodAsFactory.ts","../../src/zodIsFactory.ts","../../src/zodToFactory.ts","../../src/zodAllFactory.ts"],"sourcesContent":["import type { AssertConfig } from '@xylabs/error'\nimport { assertError } from '@xylabs/error'\nimport type z from 'zod'\n\nimport type { ZodFactoryConfig } from './Config.ts'\n\nexport function zodAsFactory<T>(zod: z.ZodType<T>, name: string) {\n  function asFunc(value: unknown): T | undefined\n  function asFunc(value: unknown, assert: ZodFactoryConfig): T\n  function asFunc(value: unknown, assert?: ZodFactoryConfig): T | undefined {\n    const result = zod.safeParse(value)\n    if (result.success) {\n      return result.data\n    }\n    if (assert !== undefined) {\n      let assertConfig: AssertConfig\n      switch (typeof assert) {\n        case 'string': {\n          assertConfig = `[${name}][${value}] ${assert}`\n          break\n        }\n        case 'object': {\n          assertConfig = `[${name}][${assert.name}][${value}] ${result.error.message}`\n          break\n        }\n        case 'boolean': {\n          assertConfig = `[${name}][${value}] ${result.error.message}`\n          break\n        }\n        case 'function': {\n          assertConfig = assert(value, result.error.message)\n          break\n        }\n        default: {\n          assertConfig = true\n        }\n      }\n      return assertError(value, assertConfig, result.error.message)\n    }\n  }\n\n  return asFunc\n}\n","import type z from 'zod'\n\nexport function zodIsFactory<TZod>(zod: z.ZodType<TZod>) {\n  return <T>(value: T): value is T & TZod => zod.safeParse(value).success\n}\n","import type z from 'zod'\n\nimport { zodAsFactory } from './zodAsFactory.ts'\n\nexport function zodToFactory<T>(zod: z.ZodType<T>, name: string) {\n  return zodAsFactory<T>(zod, name)\n}\n","import type z from 'zod'\n\nimport { zodAsFactory } from './zodAsFactory.ts'\nimport { zodIsFactory } from './zodIsFactory.ts'\nimport { zodToFactory } from './zodToFactory.ts'\n\n/** @alpha */\nexport type AllZodFactories<TType, TName extends string> = {\n  [K in `is${TName}`]: ReturnType<typeof zodIsFactory<TType>>\n} & {\n  [K in `as${TName}`]: ReturnType<typeof zodAsFactory<TType>>\n} & {\n  [K in `to${TName}`]: ReturnType<typeof zodToFactory<TType>>\n}\n\n/** @alpha */\nexport function zodAllFactory<T, TName extends string>(zod: z.ZodType<T>, name: TName) {\n  return {\n    [`is${name}`]: zodIsFactory<T>(zod),\n    [`as${name}`]: zodAsFactory<T>(zod, `as${name}`),\n    [`to${name}`]: zodToFactory<T>(zod, `to${name}`),\n  }\n}\n"],"mappings":";AACA,SAAS,mBAAmB;AAKrB,SAAS,aAAgB,KAAmB,MAAc;AAG/D,WAAS,OAAO,OAAgB,QAA0C;AACxE,UAAM,SAAS,IAAI,UAAU,KAAK;AAClC,QAAI,OAAO,SAAS;AAClB,aAAO,OAAO;AAAA,IAChB;AACA,QAAI,WAAW,QAAW;AACxB,UAAI;AACJ,cAAQ,OAAO,QAAQ;AAAA,QACrB,KAAK,UAAU;AACb,yBAAe,IAAI,IAAI,KAAK,KAAK,KAAK,MAAM;AAC5C;AAAA,QACF;AAAA,QACA,KAAK,UAAU;AACb,yBAAe,IAAI,IAAI,KAAK,OAAO,IAAI,KAAK,KAAK,KAAK,OAAO,MAAM,OAAO;AAC1E;AAAA,QACF;AAAA,QACA,KAAK,WAAW;AACd,yBAAe,IAAI,IAAI,KAAK,KAAK,KAAK,OAAO,MAAM,OAAO;AAC1D;AAAA,QACF;AAAA,QACA,KAAK,YAAY;AACf,yBAAe,OAAO,OAAO,OAAO,MAAM,OAAO;AACjD;AAAA,QACF;AAAA,QACA,SAAS;AACP,yBAAe;AAAA,QACjB;AAAA,MACF;AACA,aAAO,YAAY,OAAO,cAAc,OAAO,MAAM,OAAO;AAAA,IAC9D;AAAA,EACF;AAEA,SAAO;AACT;;;ACxCO,SAAS,aAAmB,KAAsB;AACvD,SAAO,CAAI,UAAgC,IAAI,UAAU,KAAK,EAAE;AAClE;;;ACAO,SAAS,aAAgB,KAAmB,MAAc;AAC/D,SAAO,aAAgB,KAAK,IAAI;AAClC;;;ACUO,SAAS,cAAuC,KAAmB,MAAa;AACrF,SAAO;AAAA,IACL,CAAC,KAAK,IAAI,EAAE,GAAG,aAAgB,GAAG;AAAA,IAClC,CAAC,KAAK,IAAI,EAAE,GAAG,aAAgB,KAAK,KAAK,IAAI,EAAE;AAAA,IAC/C,CAAC,KAAK,IAAI,EAAE,GAAG,aAAgB,KAAK,KAAK,IAAI,EAAE;AAAA,EACjD;AACF;","names":[]}
+{"version":3,"sources":["../../src/zodAsFactory.ts","../../src/zodIsFactory.ts","../../src/zodToFactory.ts","../../src/zodAllFactory.ts","../../src/zodAsAsyncFactory.ts","../../src/zodToAsyncFactory.ts"],"sourcesContent":["import type { AssertConfig } from '@xylabs/error'\nimport { assertError } from '@xylabs/error'\nimport type z from 'zod'\n\nimport type { ZodFactoryConfig } from './Config.ts'\n\nexport function zodAsFactory<TZod>(zod: z.ZodType<TZod>, name: string) {\n  function asFunc<T>(value: unknown): (T & TZod) | undefined\n  function asFunc<T>(value: unknown, assert: ZodFactoryConfig): (T & TZod)\n  function asFunc<T>(value: unknown, assert?: ZodFactoryConfig): (T & TZod) | undefined {\n    const result = zod.safeParse(value)\n    if (result.success) {\n      return value as (T & TZod)\n    }\n    if (assert !== undefined) {\n      let assertConfig: AssertConfig\n      switch (typeof assert) {\n        case 'string': {\n          assertConfig = `[${name}][${value}] ${assert}`\n          break\n        }\n        case 'object': {\n          assertConfig = `[${name}][${assert.name}][${value}] ${result.error.message}`\n          break\n        }\n        case 'boolean': {\n          assertConfig = `[${name}][${value}] ${result.error.message}`\n          break\n        }\n        case 'function': {\n          assertConfig = assert(value, result.error.message)\n          break\n        }\n        default: {\n          assertConfig = true\n        }\n      }\n      return assertError(value, assertConfig, result.error.message)\n    }\n  }\n\n  return asFunc\n}\n","import type z from 'zod'\n\nexport function zodIsFactory<TZod>(zod: z.ZodType<TZod>) {\n  return <T>(value: T): value is T & TZod => zod.safeParse(value).success\n}\n","import type z from 'zod'\n\nimport { zodAsFactory } from './zodAsFactory.ts'\n\nexport function zodToFactory<T>(zod: z.ZodType<T>, name: string) {\n  return zodAsFactory<T>(zod, name)\n}\n","import type z from 'zod'\n\nimport { zodAsFactory } from './zodAsFactory.ts'\nimport { zodIsFactory } from './zodIsFactory.ts'\nimport { zodToFactory } from './zodToFactory.ts'\n\n/** @alpha */\nexport type AllZodFactories<TType, TName extends string> = {\n  [K in `is${TName}`]: ReturnType<typeof zodIsFactory<TType>>\n} & {\n  [K in `as${TName}`]: ReturnType<typeof zodAsFactory<TType>>\n} & {\n  [K in `to${TName}`]: ReturnType<typeof zodToFactory<TType>>\n}\n\n/** @alpha */\nexport function zodAllFactory<T, TName extends string>(zod: z.ZodType<T>, name: TName) {\n  return {\n    [`is${name}`]: zodIsFactory<T>(zod),\n    [`as${name}`]: zodAsFactory<T>(zod, `as${name}`),\n    [`to${name}`]: zodToFactory<T>(zod, `to${name}`),\n  }\n}\n","import type { AssertConfig } from '@xylabs/error'\nimport { assertError } from '@xylabs/error'\nimport type z from 'zod'\n\nimport type { ZodFactoryConfig } from './Config.ts'\n\nexport function zodAsAsyncFactory<TZod>(zod: z.ZodType<TZod>, name: string) {\n  function asFunc<T>(value: unknown): Promise<(T & TZod) | undefined>\n  function asFunc<T>(value: unknown, assert: ZodFactoryConfig): Promise<(T & TZod)>\n  async function asFunc<T>(value: unknown, assert?: ZodFactoryConfig): Promise<(T & TZod) | undefined> {\n    const result = await zod.safeParseAsync(value)\n    if (result.success) {\n      return value as (T & TZod)\n    }\n    if (assert !== undefined) {\n      let assertConfig: AssertConfig\n      switch (typeof assert) {\n        case 'string': {\n          assertConfig = `[${name}][${value}] ${assert}`\n          break\n        }\n        case 'object': {\n          assertConfig = `[${name}][${assert.name}][${value}] ${result.error.message}`\n          break\n        }\n        case 'boolean': {\n          assertConfig = `[${name}][${value}] ${result.error.message}`\n          break\n        }\n        case 'function': {\n          assertConfig = assert(value, result.error.message)\n          break\n        }\n        default: {\n          assertConfig = true\n        }\n      }\n      return assertError(value, assertConfig, result.error.message)\n    }\n  }\n\n  return asFunc\n}\n","import type z from 'zod'\n\nimport { zodAsAsyncFactory } from './zodAsAsyncFactory.ts'\n\nexport function zodToAsyncFactory<T>(zod: z.ZodType<T>, name: string) {\n  return zodAsAsyncFactory<T>(zod, name)\n}\n"],"mappings":";AACA,SAAS,mBAAmB;AAKrB,SAAS,aAAmB,KAAsB,MAAc;AAGrE,WAAS,OAAU,OAAgB,QAAmD;AACpF,UAAM,SAAS,IAAI,UAAU,KAAK;AAClC,QAAI,OAAO,SAAS;AAClB,aAAO;AAAA,IACT;AACA,QAAI,WAAW,QAAW;AACxB,UAAI;AACJ,cAAQ,OAAO,QAAQ;AAAA,QACrB,KAAK,UAAU;AACb,yBAAe,IAAI,IAAI,KAAK,KAAK,KAAK,MAAM;AAC5C;AAAA,QACF;AAAA,QACA,KAAK,UAAU;AACb,yBAAe,IAAI,IAAI,KAAK,OAAO,IAAI,KAAK,KAAK,KAAK,OAAO,MAAM,OAAO;AAC1E;AAAA,QACF;AAAA,QACA,KAAK,WAAW;AACd,yBAAe,IAAI,IAAI,KAAK,KAAK,KAAK,OAAO,MAAM,OAAO;AAC1D;AAAA,QACF;AAAA,QACA,KAAK,YAAY;AACf,yBAAe,OAAO,OAAO,OAAO,MAAM,OAAO;AACjD;AAAA,QACF;AAAA,QACA,SAAS;AACP,yBAAe;AAAA,QACjB;AAAA,MACF;AACA,aAAO,YAAY,OAAO,cAAc,OAAO,MAAM,OAAO;AAAA,IAC9D;AAAA,EACF;AAEA,SAAO;AACT;;;ACxCO,SAAS,aAAmB,KAAsB;AACvD,SAAO,CAAI,UAAgC,IAAI,UAAU,KAAK,EAAE;AAClE;;;ACAO,SAAS,aAAgB,KAAmB,MAAc;AAC/D,SAAO,aAAgB,KAAK,IAAI;AAClC;;;ACUO,SAAS,cAAuC,KAAmB,MAAa;AACrF,SAAO;AAAA,IACL,CAAC,KAAK,IAAI,EAAE,GAAG,aAAgB,GAAG;AAAA,IAClC,CAAC,KAAK,IAAI,EAAE,GAAG,aAAgB,KAAK,KAAK,IAAI,EAAE;AAAA,IAC/C,CAAC,KAAK,IAAI,EAAE,GAAG,aAAgB,KAAK,KAAK,IAAI,EAAE;AAAA,EACjD;AACF;;;ACrBA,SAAS,eAAAA,oBAAmB;AAKrB,SAAS,kBAAwB,KAAsB,MAAc;AAG1E,iBAAe,OAAU,OAAgB,QAA4D;AACnG,UAAM,SAAS,MAAM,IAAI,eAAe,KAAK;AAC7C,QAAI,OAAO,SAAS;AAClB,aAAO;AAAA,IACT;AACA,QAAI,WAAW,QAAW;AACxB,UAAI;AACJ,cAAQ,OAAO,QAAQ;AAAA,QACrB,KAAK,UAAU;AACb,yBAAe,IAAI,IAAI,KAAK,KAAK,KAAK,MAAM;AAC5C;AAAA,QACF;AAAA,QACA,KAAK,UAAU;AACb,yBAAe,IAAI,IAAI,KAAK,OAAO,IAAI,KAAK,KAAK,KAAK,OAAO,MAAM,OAAO;AAC1E;AAAA,QACF;AAAA,QACA,KAAK,WAAW;AACd,yBAAe,IAAI,IAAI,KAAK,KAAK,KAAK,OAAO,MAAM,OAAO;AAC1D;AAAA,QACF;AAAA,QACA,KAAK,YAAY;AACf,yBAAe,OAAO,OAAO,OAAO,MAAM,OAAO;AACjD;AAAA,QACF;AAAA,QACA,SAAS;AACP,yBAAe;AAAA,QACjB;AAAA,MACF;AACA,aAAOA,aAAY,OAAO,cAAc,OAAO,MAAM,OAAO;AAAA,IAC9D;AAAA,EACF;AAEA,SAAO;AACT;;;ACtCO,SAAS,kBAAqB,KAAmB,MAAc;AACpE,SAAO,kBAAqB,KAAK,IAAI;AACvC;","names":["assertError"]}

package/dist/neutral/zodAllFactory.d.ts

@@ -12,9 +12,9 @@ export type AllZodFactories<TType, TName extends string> = {
 };
 /** @alpha */
 export declare function zodAllFactory<T, TName extends string>(zod: z.ZodType<T>, name: TName): {
-    [x: string]: (<T_1>(value: T_1) => value is T_1 & T) | {
-        (value: unknown): T | undefined;
-        (value: unknown, assert: import("./Config.ts").ZodFactoryConfig): T;
+    [x: string]: {
+        <T_1>(value: unknown): (T_1 & T) | undefined;
+        <T_1>(value: unknown, assert: import("./Config.ts").ZodFactoryConfig): T_1 & T;
     };
 };
 //# sourceMappingURL=zodAllFactory.d.ts.map

package/dist/neutral/zodAsAsyncFactory.d.ts

@@ -0,0 +1,7 @@
+import type z from 'zod';
+import type { ZodFactoryConfig } from './Config.ts';
+export declare function zodAsAsyncFactory<TZod>(zod: z.ZodType<TZod>, name: string): {
+    <T>(value: unknown): Promise<(T & TZod) | undefined>;
+    <T>(value: unknown, assert: ZodFactoryConfig): Promise<(T & TZod)>;
+};
+//# sourceMappingURL=zodAsAsyncFactory.d.ts.map

package/dist/neutral/zodAsAsyncFactory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zodAsAsyncFactory.d.ts","sourceRoot":"","sources":["../../src/zodAsAsyncFactory.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAExB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAA;AAEnD,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,GAAG,EAAE,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,MAAM;KACxD,CAAC,SAAS,OAAO,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,SAAS,CAAC;KACnD,CAAC,SAAS,OAAO,UAAU,gBAAgB,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;EAkClF"}

package/dist/neutral/zodAsFactory.d.ts

@@ -1,7 +1,7 @@
 import type z from 'zod';
 import type { ZodFactoryConfig } from './Config.ts';
-export declare function zodAsFactory<T>(zod: z.ZodType<T>, name: string): {
-    (value: unknown): T | undefined;
-    (value: unknown, assert: ZodFactoryConfig): T;
+export declare function zodAsFactory<TZod>(zod: z.ZodType<TZod>, name: string): {
+    <T>(value: unknown): (T & TZod) | undefined;
+    <T>(value: unknown, assert: ZodFactoryConfig): (T & TZod);
 };
 //# sourceMappingURL=zodAsFactory.d.ts.map

package/dist/neutral/zodAsFactory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"zodAsFactory.d.ts","sourceRoot":"","sources":["../../src/zodAsFactory.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAExB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAA;AAEnD,wBAAgB,YAAY,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM;YACtC,OAAO,GAAG,CAAC,GAAG,SAAS;YACvB,OAAO,UAAU,gBAAgB,GAAG,CAAC;EAkC7D"}
+{"version":3,"file":"zodAsFactory.d.ts","sourceRoot":"","sources":["../../src/zodAsFactory.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAExB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAA;AAEnD,wBAAgB,YAAY,CAAC,IAAI,EAAE,GAAG,EAAE,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,MAAM;KACnD,CAAC,SAAS,OAAO,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,SAAS;KAC1C,CAAC,SAAS,OAAO,UAAU,gBAAgB,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC;EAkCzE"}

package/dist/neutral/zodToAsyncFactory.d.ts

@@ -0,0 +1,6 @@
+import type z from 'zod';
+export declare function zodToAsyncFactory<T>(zod: z.ZodType<T>, name: string): {
+    <T_1>(value: unknown): Promise<(T_1 & T) | undefined>;
+    <T_1>(value: unknown, assert: import("./Config.ts").ZodFactoryConfig): Promise<T_1 & T>;
+};
+//# sourceMappingURL=zodToAsyncFactory.d.ts.map

package/dist/neutral/zodToAsyncFactory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zodToAsyncFactory.d.ts","sourceRoot":"","sources":["../../src/zodToAsyncFactory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAIxB,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM;;;EAEnE"}

package/dist/neutral/zodToFactory.d.ts

@@ -1,6 +1,6 @@
 import type z from 'zod';
 export declare function zodToFactory<T>(zod: z.ZodType<T>, name: string): {
-    (value: unknown): T | undefined;
-    (value: unknown, assert: import("./Config.ts").ZodFactoryConfig): T;
+    <T_1>(value: unknown): (T_1 & T) | undefined;
+    <T_1>(value: unknown, assert: import("./Config.ts").ZodFactoryConfig): T_1 & T;
 };
 //# sourceMappingURL=zodToFactory.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xylabs/zod",
-  "version": "5.0.42",
+  "version": "5.0.44",
   "description": "Base functionality used throughout XY Labs TypeScript/JavaScript libraries",
   "homepage": "https://xyo.network",
   "bugs": {
@@ -38,7 +38,7 @@
     "!**/*.test.*"
   ],
   "dependencies": {
-    "@xylabs/error": "~5.0.42",
+    "@xylabs/error": "~5.0.44",
     "zod": "~4.1.12"
   },
   "devDependencies": {

package/src/index.ts

@@ -1,5 +1,7 @@
 export * from './Config.ts'
 export * from './zodAllFactory.ts'
+export * from './zodAsAsyncFactory.ts'
 export * from './zodAsFactory.ts'
 export * from './zodIsFactory.ts'
+export * from './zodToAsyncFactory.ts'
 export * from './zodToFactory.ts'

package/src/zodAsAsyncFactory.ts

@@ -0,0 +1,43 @@
+import type { AssertConfig } from '@xylabs/error'
+import { assertError } from '@xylabs/error'
+import type z from 'zod'
+
+import type { ZodFactoryConfig } from './Config.ts'
+
+export function zodAsAsyncFactory<TZod>(zod: z.ZodType<TZod>, name: string) {
+  function asFunc<T>(value: unknown): Promise<(T & TZod) | undefined>
+  function asFunc<T>(value: unknown, assert: ZodFactoryConfig): Promise<(T & TZod)>
+  async function asFunc<T>(value: unknown, assert?: ZodFactoryConfig): Promise<(T & TZod) | undefined> {
+    const result = await zod.safeParseAsync(value)
+    if (result.success) {
+      return value as (T & TZod)
+    }
+    if (assert !== undefined) {
+      let assertConfig: AssertConfig
+      switch (typeof assert) {
+        case 'string': {
+          assertConfig = `[${name}][${value}] ${assert}`
+          break
+        }
+        case 'object': {
+          assertConfig = `[${name}][${assert.name}][${value}] ${result.error.message}`
+          break
+        }
+        case 'boolean': {
+          assertConfig = `[${name}][${value}] ${result.error.message}`
+          break
+        }
+        case 'function': {
+          assertConfig = assert(value, result.error.message)
+          break
+        }
+        default: {
+          assertConfig = true
+        }
+      }
+      return assertError(value, assertConfig, result.error.message)
+    }
+  }
+
+  return asFunc
+}

package/src/zodAsFactory.ts

@@ -4,13 +4,13 @@ import type z from 'zod'
 
 import type { ZodFactoryConfig } from './Config.ts'
 
-export function zodAsFactory<T>(zod: z.ZodType<T>, name: string) {
-  function asFunc(value: unknown): T | undefined
-  function asFunc(value: unknown, assert: ZodFactoryConfig): T
-  function asFunc(value: unknown, assert?: ZodFactoryConfig): T | undefined {
+export function zodAsFactory<TZod>(zod: z.ZodType<TZod>, name: string) {
+  function asFunc<T>(value: unknown): (T & TZod) | undefined
+  function asFunc<T>(value: unknown, assert: ZodFactoryConfig): (T & TZod)
+  function asFunc<T>(value: unknown, assert?: ZodFactoryConfig): (T & TZod) | undefined {
     const result = zod.safeParse(value)
     if (result.success) {
-      return result.data
+      return value as (T & TZod)
     }
     if (assert !== undefined) {
       let assertConfig: AssertConfig

package/src/zodToAsyncFactory.ts

@@ -0,0 +1,7 @@
+import type z from 'zod'
+
+import { zodAsAsyncFactory } from './zodAsAsyncFactory.ts'
+
+export function zodToAsyncFactory<T>(zod: z.ZodType<T>, name: string) {
+  return zodAsAsyncFactory<T>(zod, name)
+}