zod-compiler 0.1.0 → 0.1.1

package/dist/index.d.ts

@@ -465,6 +465,9 @@ interface StandaloneOutput {
     /** `true` if this parser has any dependencies. */
     readonly hasDependencies: boolean;
 }
+interface CompiledNonStandaloneParser<TZod extends z.ZodTypeAny> extends CompiledParser<TZod['_output']> {
+    schema: TZod;
+}
 /**
  * Compile a Zod schema for use out-of-source.
  *
@@ -499,8 +502,8 @@ declare function compile<TZod extends z.ZodTypeAny>(schema: TZod, options: Compi
  * console.log(fastSchema.safeParse('Hello, world!')); // { success: true, data: ... }
  * ```
  */
-declare function compile<TZod extends z.ZodTypeAny>(schema: TZod, options?: CompileOptions<false>): CompiledParser<TZod['_output']>;
-declare function compile<TZod extends z.ZodTypeAny>(schema: TZod, options?: CompileOptions<boolean>): StandaloneOutput | CompiledParser<TZod['_output']>;
+declare function compile<TZod extends z.ZodTypeAny>(schema: TZod, options?: CompileOptions<false>): CompiledNonStandaloneParser<TZod>;
+declare function compile<TZod extends z.ZodTypeAny>(schema: TZod, options?: CompileOptions<boolean>): StandaloneOutput | CompiledNonStandaloneParser<TZod>;
 interface TypesOptions {
     /**
      * Output the schema as a type alias in the form of `export type Schema = ...` (where `Schema` is configurable via
@@ -559,6 +562,7 @@ declare function types<TZod extends z.ZodTypeAny>(schema: TZod, options?: TypesO
 type zc_AbstractCompiledType<TZod extends z.ZodType> = AbstractCompiledType<TZod>;
 declare const zc_AbstractCompiledType: typeof AbstractCompiledType;
 type zc_CompileOptions<Standalone extends boolean = false> = CompileOptions<Standalone>;
+type zc_CompiledNonStandaloneParser<TZod extends z.ZodTypeAny> = CompiledNonStandaloneParser<TZod>;
 declare const zc_CompiledParser: typeof CompiledParser;
 type zc_DenormalizedError = DenormalizedError;
 type zc_ErrorMapCtx = ErrorMapCtx;
@@ -663,8 +667,8 @@ type zc_typeToFlattenedError<T, U = string> = typeToFlattenedError<T, U>;
 declare const zc_types: typeof types;
 declare namespace zc {
   export { zc_AbstractCompiledType as AbstractCompiledType, zc_CompiledParser as CompiledParser, zc_InliningMode as InliningMode, zc_ZcAny as ZcAny, zc_ZcArray as ZcArray, zc_ZcBigInt as ZcBigInt, zc_ZcBoolean as ZcBoolean, zc_ZcBranded as ZcBranded, zc_ZcCatch as ZcCatch, zc_ZcDate as ZcDate, zc_ZcDefault as ZcDefault, zc_ZcDiscriminatedUnion as ZcDiscriminatedUnion, zc_ZcEnum as ZcEnum, zc_ZcError as ZcError, zc_ZcIntersection as ZcIntersection, zc_ZcIssueCode as ZcIssueCode, zc_ZcLiteral as ZcLiteral, zc_ZcMap as ZcMap, zc_ZcNaN as ZcNaN, zc_ZcNativeEnum as ZcNativeEnum, zc_ZcNever as ZcNever, zc_ZcNull as ZcNull, zc_ZcNullable as ZcNullable, zc_ZcNumber as ZcNumber, zc_ZcObject as ZcObject, zc_ZcOptional as ZcOptional, zc_ZcReadonly as ZcReadonly, zc_ZcRecord as ZcRecord, zc_ZcSet as ZcSet, zc_ZcString as ZcString, zc_ZcSymbol as ZcSymbol, zc_ZcTuple as ZcTuple, zc_ZcUndefined as ZcUndefined, zc_ZcUnion as ZcUnion, zc_ZcUnknown as ZcUnknown, zc_ZcVoid as ZcVoid, zc_compilable as compilable, zc_compile as compile, zc_types as types };
-  export type { zc_CompileOptions as CompileOptions, zc_DenormalizedError as DenormalizedError, zc_ErrorMapCtx as ErrorMapCtx, zc_IssueData as IssueData, zc_Primitive as Primitive, zc_Scalars as Scalars, zc_StandaloneOutput as StandaloneOutput, zc_StringValidation as StringValidation, zc_TypesOptions as TypesOptions, zc_ZcCustomIssue as ZcCustomIssue, zc_ZcErrorMap as ZcErrorMap, zc_ZcFormattedError as ZcFormattedError, zc_ZcInvalidArgumentsIssue as ZcInvalidArgumentsIssue, zc_ZcInvalidDateIssue as ZcInvalidDateIssue, zc_ZcInvalidEnumValueIssue as ZcInvalidEnumValueIssue, zc_ZcInvalidIntersectionTypesIssue as ZcInvalidIntersectionTypesIssue, zc_ZcInvalidLiteralIssue as ZcInvalidLiteralIssue, zc_ZcInvalidReturnTypeIssue as ZcInvalidReturnTypeIssue, zc_ZcInvalidStringIssue as ZcInvalidStringIssue, zc_ZcInvalidTypeIssue as ZcInvalidTypeIssue, zc_ZcInvalidUnionDiscriminatorIssue as ZcInvalidUnionDiscriminatorIssue, zc_ZcInvalidUnionIssue as ZcInvalidUnionIssue, zc_ZcIssue as ZcIssue, zc_ZcIssueBase as ZcIssueBase, zc_ZcIssueOptionalMessage as ZcIssueOptionalMessage, zc_ZcNotFiniteIssue as ZcNotFiniteIssue, zc_ZcNotMultipleOfIssue as ZcNotMultipleOfIssue, zc_ZcTooBigIssue as ZcTooBigIssue, zc_ZcTooSmallIssue as ZcTooSmallIssue, zc_ZcUnrecognizedKeysIssue as ZcUnrecognizedKeysIssue, zc_typeToFlattenedError as typeToFlattenedError };
+  export type { zc_CompileOptions as CompileOptions, zc_CompiledNonStandaloneParser as CompiledNonStandaloneParser, zc_DenormalizedError as DenormalizedError, zc_ErrorMapCtx as ErrorMapCtx, zc_IssueData as IssueData, zc_Primitive as Primitive, zc_Scalars as Scalars, zc_StandaloneOutput as StandaloneOutput, zc_StringValidation as StringValidation, zc_TypesOptions as TypesOptions, zc_ZcCustomIssue as ZcCustomIssue, zc_ZcErrorMap as ZcErrorMap, zc_ZcFormattedError as ZcFormattedError, zc_ZcInvalidArgumentsIssue as ZcInvalidArgumentsIssue, zc_ZcInvalidDateIssue as ZcInvalidDateIssue, zc_ZcInvalidEnumValueIssue as ZcInvalidEnumValueIssue, zc_ZcInvalidIntersectionTypesIssue as ZcInvalidIntersectionTypesIssue, zc_ZcInvalidLiteralIssue as ZcInvalidLiteralIssue, zc_ZcInvalidReturnTypeIssue as ZcInvalidReturnTypeIssue, zc_ZcInvalidStringIssue as ZcInvalidStringIssue, zc_ZcInvalidTypeIssue as ZcInvalidTypeIssue, zc_ZcInvalidUnionDiscriminatorIssue as ZcInvalidUnionDiscriminatorIssue, zc_ZcInvalidUnionIssue as ZcInvalidUnionIssue, zc_ZcIssue as ZcIssue, zc_ZcIssueBase as ZcIssueBase, zc_ZcIssueOptionalMessage as ZcIssueOptionalMessage, zc_ZcNotFiniteIssue as ZcNotFiniteIssue, zc_ZcNotMultipleOfIssue as ZcNotMultipleOfIssue, zc_ZcTooBigIssue as ZcTooBigIssue, zc_ZcTooSmallIssue as ZcTooSmallIssue, zc_ZcUnrecognizedKeysIssue as ZcUnrecognizedKeysIssue, zc_typeToFlattenedError as typeToFlattenedError };
 }
 
 export { AbstractCompiledType, InliningMode, ZcAny, ZcArray, ZcBigInt, ZcBoolean, ZcBranded, ZcCatch, ZcDate, ZcDefault, ZcDiscriminatedUnion, ZcEnum, ZcError, ZcIntersection, ZcIssueCode, ZcLiteral, ZcMap, ZcNaN, ZcNativeEnum, ZcNever, ZcNull, ZcNullable, ZcNumber, ZcObject, ZcOptional, ZcReadonly, ZcRecord, ZcSet, ZcString, ZcSymbol, ZcTuple, ZcUndefined, ZcUnion, ZcUnknown, ZcVoid, compilable, compile, zc as default, types };
-export type { CompileOptions, DenormalizedError, ErrorMapCtx, IssueData, Primitive, Scalars, StandaloneOutput, StringValidation, TypesOptions, ZcCustomIssue, ZcErrorMap, ZcFormattedError, ZcInvalidArgumentsIssue, ZcInvalidDateIssue, ZcInvalidEnumValueIssue, ZcInvalidIntersectionTypesIssue, ZcInvalidLiteralIssue, ZcInvalidReturnTypeIssue, ZcInvalidStringIssue, ZcInvalidTypeIssue, ZcInvalidUnionDiscriminatorIssue, ZcInvalidUnionIssue, ZcIssue, ZcIssueBase, ZcIssueOptionalMessage, ZcNotFiniteIssue, ZcNotMultipleOfIssue, ZcTooBigIssue, ZcTooSmallIssue, ZcUnrecognizedKeysIssue, typeToFlattenedError };
+export type { CompileOptions, CompiledNonStandaloneParser, DenormalizedError, ErrorMapCtx, IssueData, Primitive, Scalars, StandaloneOutput, StringValidation, TypesOptions, ZcCustomIssue, ZcErrorMap, ZcFormattedError, ZcInvalidArgumentsIssue, ZcInvalidDateIssue, ZcInvalidEnumValueIssue, ZcInvalidIntersectionTypesIssue, ZcInvalidLiteralIssue, ZcInvalidReturnTypeIssue, ZcInvalidStringIssue, ZcInvalidTypeIssue, ZcInvalidUnionDiscriminatorIssue, ZcInvalidUnionIssue, ZcIssue, ZcIssueBase, ZcIssueOptionalMessage, ZcNotFiniteIssue, ZcNotMultipleOfIssue, ZcTooBigIssue, ZcTooSmallIssue, ZcUnrecognizedKeysIssue, typeToFlattenedError };

package/dist/index.js

@@ -2473,7 +2473,10 @@ function compile(schema, options) {
     sourceFile.identifiers = new Map();
     const source = print(sourceFile);
     const parser = new Function('input', 'ctx', source);
-    return standalone__default.default(parser, dependencies.dependencies);
+    return {
+        ...standalone__default.default(parser, dependencies.dependencies),
+        schema
+    };
 }
 /**
  * Exports the `schema` to a TypeScript type definition.

package/dist/index.mjs

@@ -2465,7 +2465,10 @@ function compile(schema, options) {
     sourceFile.identifiers = new Map();
     const source = print(sourceFile);
     const parser = new Function('input', 'ctx', source);
-    return standalone(parser, dependencies.dependencies);
+    return {
+        ...standalone(parser, dependencies.dependencies),
+        schema
+    };
 }
 /**
  * Exports the `schema` to a TypeScript type definition.

package/dist/standalone.d.ts

@@ -246,6 +246,98 @@ declare namespace regex {
   };
 }
 
+/**
+ * The Standard Schema interface.
+ */
+type StandardSchemaV1<Input = unknown, Output = Input> = {
+    /**
+     * The Standard Schema properties.
+     */
+    readonly '~standard': StandardSchemaV1Props<Input, Output>;
+};
+/**
+ * The Standard Schema properties interface.
+ */
+interface StandardSchemaV1Props<Input = unknown, Output = Input> {
+    /**
+     * The version number of the standard.
+     */
+    readonly version: 1;
+    /**
+     * The vendor name of the schema library.
+     */
+    readonly vendor: string;
+    /**
+     * Validates unknown input values.
+     */
+    readonly validate: (value: unknown) => StandardSchemaV1Result<Output> | Promise<StandardSchemaV1Result<Output>>;
+    /**
+     * Inferred types associated with the schema.
+     */
+    readonly types?: StandardSchemaV1Types<Input, Output> | undefined;
+}
+/**
+ * The result interface of the validate function.
+ */
+type StandardSchemaV1Result<Output> = StandardSchemaV1SuccessResult<Output> | StandardSchemaV1FailureResult;
+/**
+ * The result interface if validation succeeds.
+ */
+interface StandardSchemaV1SuccessResult<Output> {
+    /**
+     * The typed output value.
+     */
+    readonly value: Output;
+    /**
+     * The non-existent issues.
+     */
+    readonly issues?: undefined;
+}
+/**
+ * The result interface if validation fails.
+ */
+interface StandardSchemaV1FailureResult {
+    /**
+     * The issues of failed validation.
+     */
+    readonly issues: ReadonlyArray<StandardSchemaV1Issue>;
+}
+/**
+ * The issue interface of the failure output.
+ */
+interface StandardSchemaV1Issue {
+    /**
+     * The error message of the issue.
+     */
+    readonly message: string;
+    /**
+     * The path of the issue, if any.
+     */
+    readonly path?: ReadonlyArray<PropertyKey | StandardSchemaV1PathSegment> | undefined;
+}
+/**
+ * The path segment interface of the issue.
+ */
+interface StandardSchemaV1PathSegment {
+    /**
+     * The key representing a path segment.
+     */
+    readonly key: PropertyKey;
+}
+/**
+ * The Standard Schema types interface.
+ */
+interface StandardSchemaV1Types<Input = unknown, Output = Input> {
+    /**
+     * The input type of the schema.
+     */
+    readonly input: Input;
+    /**
+     * The output type of the schema.
+     */
+    readonly output: Output;
+}
+
 declare const errorMap: ZcErrorMap;
 
 declare function setErrorMap(map: ZcErrorMap): void;
@@ -283,7 +375,7 @@ interface ParseParams {
     path?: (string | number)[];
     errorMap?: ZcErrorMap;
 }
-interface CompiledParser<T> {
+interface CompiledParser<T> extends StandardSchemaV1<unknown, T> {
     parse(data: unknown, params?: ParseParams): T;
     safeParse(data: unknown, params?: ParseParams): SafeParseSuccess<T> | SafeParseError<T>;
 }

package/dist/standalone.js

@@ -509,7 +509,24 @@ function standalone(parser, dependencies = []) {
                     error: new ZcError(ctx.issues)
                 };
             }
-        }
+        },
+        '~standard': Object.freeze({
+            version: 1,
+            vendor: 'zod-compiler',
+            validate (value) {
+                const ctx = createContext(dependencies, undefined);
+                const status = typedParser(value, ctx);
+                if (status === 0) {
+                    return {
+                        value: ctx.output
+                    };
+                } else {
+                    return {
+                        issues: ctx.issues
+                    };
+                }
+            }
+        })
     };
 }
 

package/dist/standalone.mjs

@@ -507,7 +507,24 @@ function standalone(parser, dependencies = []) {
                     error: new ZcError(ctx.issues)
                 };
             }
-        }
+        },
+        '~standard': Object.freeze({
+            version: 1,
+            vendor: 'zod-compiler',
+            validate (value) {
+                const ctx = createContext(dependencies, undefined);
+                const status = typedParser(value, ctx);
+                if (status === 0) {
+                    return {
+                        value: ctx.output
+                    };
+                } else {
+                    return {
+                        issues: ctx.issues
+                    };
+                }
+            }
+        })
     };
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "zod-compiler",
-	"version": "0.1.0",
+	"version": "0.1.1",
 	"description": "Compile Zod schemas to fast parsers or TypeScript types",
 	"author": "Carson M. <carson@pyke.io>",
 	"license": "MIT OR Apache-2.0",