valrs 0.1.0

package/dist/factory.d.ts

@@ -0,0 +1,107 @@
+/**
+ * Schema factory functions for creating Standard Schema compliant objects.
+ *
+ * These factories wrap validation and JSON Schema generation functions
+ * into the Standard Schema format with the `~standard` property.
+ */
+import type { StandardSchemaV1, StandardJSONSchemaV1, ValidationResult, ValidationIssue } from './types';
+/** The vendor name for schemas created by this library. */
+export declare const VENDOR: "valrs";
+/** The Standard Schema version. */
+export declare const VERSION: 1;
+/**
+ * A function that validates an unknown value.
+ */
+export type ValidateFn<T> = (value: unknown) => ValidationResult<T>;
+/**
+ * A function that generates a JSON Schema.
+ */
+export type JsonSchemaFn = (target: string) => Record<string, unknown>;
+/**
+ * Creates a Standard Schema from a validation function.
+ *
+ * This is the simplest way to create a compliant schema. The returned
+ * object has the `~standard` property with the validate function.
+ *
+ * @template T - The validated output type
+ * @param validateFn - The validation function
+ * @returns A Standard Schema compliant object
+ *
+ * @example
+ * ```typescript
+ * const PositiveNumber = createSchema<number>((value) => {
+ *   if (typeof value !== 'number') {
+ *     return { issues: [{ message: 'Expected a number' }] };
+ *   }
+ *   if (value <= 0) {
+ *     return { issues: [{ message: 'Must be positive' }] };
+ *   }
+ *   return { value };
+ * });
+ * ```
+ */
+export declare function createSchema<T>(validateFn: ValidateFn<T>): StandardSchemaV1<T, T>;
+/**
+ * Creates a Standard Schema with JSON Schema generation support.
+ *
+ * This extends the basic schema with the ability to generate JSON Schema
+ * representations for different targets (Draft 2020-12, Draft 07, OpenAPI 3.0).
+ *
+ * @template T - The validated output type
+ * @param validateFn - The validation function
+ * @param jsonSchemaFn - Function to generate JSON Schema for a target
+ * @returns A Standard JSON Schema compliant object
+ *
+ * @example
+ * ```typescript
+ * const StringSchema = createSchemaWithJsonSchema<string>(
+ *   (value) => {
+ *     if (typeof value !== 'string') {
+ *       return { issues: [{ message: 'Expected a string' }] };
+ *     }
+ *     return { value };
+ *   },
+ *   (target) => ({ type: 'string' })
+ * );
+ * ```
+ */
+export declare function createSchemaWithJsonSchema<T>(validateFn: ValidateFn<T>, jsonSchemaFn: JsonSchemaFn): StandardJSONSchemaV1<T, T>;
+/**
+ * Creates a Standard Schema with separate input/output JSON Schemas.
+ *
+ * Use this when the input and output types differ (e.g., coercion, defaults).
+ *
+ * @template Input - The input type
+ * @template Output - The output type after transformation
+ * @param validateFn - The validation function
+ * @param inputSchemaFn - Function to generate input JSON Schema
+ * @param outputSchemaFn - Function to generate output JSON Schema
+ * @returns A Standard JSON Schema compliant object
+ */
+export declare function createSchemaWithSeparateJsonSchemas<Input, Output>(validateFn: ValidateFn<Output>, inputSchemaFn: JsonSchemaFn, outputSchemaFn: JsonSchemaFn): StandardJSONSchemaV1<Input, Output>;
+/**
+ * Creates a validation success result.
+ *
+ * @template T - The value type
+ * @param value - The validated value
+ * @returns A successful validation result
+ */
+export declare function success<T>(value: T): ValidationResult<T>;
+/**
+ * Creates a validation failure result.
+ *
+ * @param issues - The validation issues
+ * @returns A failed validation result
+ */
+export declare function failure(issues: ReadonlyArray<ValidationIssue>): ValidationResult<never>;
+/**
+ * Creates a validation failure with a single issue.
+ *
+ * @param message - The error message
+ * @param path - Optional path to the invalid value
+ * @returns A failed validation result
+ */
+export declare function fail(message: string, path?: ReadonlyArray<string | number | {
+    readonly key: string | number;
+}>): ValidationResult<never>;
+//# sourceMappingURL=factory.d.ts.map

package/dist/factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../src/factory.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EACV,gBAAgB,EAChB,oBAAoB,EACpB,gBAAgB,EAChB,eAAe,EAEhB,MAAM,SAAS,CAAC;AAEjB,2DAA2D;AAC3D,eAAO,MAAM,MAAM,EAAG,OAAgB,CAAC;AAEvC,mCAAmC;AACnC,eAAO,MAAM,OAAO,EAAG,CAAU,CAAC;AAElC;;GAEG;AACH,MAAM,MAAM,UAAU,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,OAAO,KAAK,gBAAgB,CAAC,CAAC,CAAC,CAAC;AAEpE;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,MAAM,EAAE,MAAM,KAAK,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAEvE;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC,CAQjF;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,0BAA0B,CAAC,CAAC,EAC1C,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC,EACzB,YAAY,EAAE,YAAY,GACzB,oBAAoB,CAAC,CAAC,EAAE,CAAC,CAAC,CAY5B;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,mCAAmC,CAAC,KAAK,EAAE,MAAM,EAC/D,UAAU,EAAE,UAAU,CAAC,MAAM,CAAC,EAC9B,aAAa,EAAE,YAAY,EAC3B,cAAc,EAAE,YAAY,GAC3B,oBAAoB,CAAC,KAAK,EAAE,MAAM,CAAC,CAYrC;AAED;;;;;;GAMG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,gBAAgB,CAAC,CAAC,CAAC,CAExD;AAED;;;;;GAKG;AACH,wBAAgB,OAAO,CAAC,MAAM,EAAE,aAAa,CAAC,eAAe,CAAC,GAAG,gBAAgB,CAAC,KAAK,CAAC,CAEvF;AAED;;;;;;GAMG;AACH,wBAAgB,IAAI,CAClB,OAAO,EAAE,MAAM,EACf,IAAI,CAAC,EAAE,aAAa,CAAC,MAAM,GAAG,MAAM,GAAG;IAAE,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;CAAE,CAAC,GACxE,gBAAgB,CAAC,KAAK,CAAC,CAGzB"}

package/dist/factory.js

@@ -0,0 +1,135 @@
+/**
+ * Schema factory functions for creating Standard Schema compliant objects.
+ *
+ * These factories wrap validation and JSON Schema generation functions
+ * into the Standard Schema format with the `~standard` property.
+ */
+/** The vendor name for schemas created by this library. */
+export const VENDOR = 'valrs';
+/** The Standard Schema version. */
+export const VERSION = 1;
+/**
+ * Creates a Standard Schema from a validation function.
+ *
+ * This is the simplest way to create a compliant schema. The returned
+ * object has the `~standard` property with the validate function.
+ *
+ * @template T - The validated output type
+ * @param validateFn - The validation function
+ * @returns A Standard Schema compliant object
+ *
+ * @example
+ * ```typescript
+ * const PositiveNumber = createSchema<number>((value) => {
+ *   if (typeof value !== 'number') {
+ *     return { issues: [{ message: 'Expected a number' }] };
+ *   }
+ *   if (value <= 0) {
+ *     return { issues: [{ message: 'Must be positive' }] };
+ *   }
+ *   return { value };
+ * });
+ * ```
+ */
+export function createSchema(validateFn) {
+    return {
+        '~standard': {
+            version: VERSION,
+            vendor: VENDOR,
+            validate: validateFn,
+        },
+    };
+}
+/**
+ * Creates a Standard Schema with JSON Schema generation support.
+ *
+ * This extends the basic schema with the ability to generate JSON Schema
+ * representations for different targets (Draft 2020-12, Draft 07, OpenAPI 3.0).
+ *
+ * @template T - The validated output type
+ * @param validateFn - The validation function
+ * @param jsonSchemaFn - Function to generate JSON Schema for a target
+ * @returns A Standard JSON Schema compliant object
+ *
+ * @example
+ * ```typescript
+ * const StringSchema = createSchemaWithJsonSchema<string>(
+ *   (value) => {
+ *     if (typeof value !== 'string') {
+ *       return { issues: [{ message: 'Expected a string' }] };
+ *     }
+ *     return { value };
+ *   },
+ *   (target) => ({ type: 'string' })
+ * );
+ * ```
+ */
+export function createSchemaWithJsonSchema(validateFn, jsonSchemaFn) {
+    return {
+        '~standard': {
+            version: VERSION,
+            vendor: VENDOR,
+            validate: validateFn,
+            jsonSchema: {
+                input: (options) => jsonSchemaFn(options.target),
+                output: (options) => jsonSchemaFn(options.target),
+            },
+        },
+    };
+}
+/**
+ * Creates a Standard Schema with separate input/output JSON Schemas.
+ *
+ * Use this when the input and output types differ (e.g., coercion, defaults).
+ *
+ * @template Input - The input type
+ * @template Output - The output type after transformation
+ * @param validateFn - The validation function
+ * @param inputSchemaFn - Function to generate input JSON Schema
+ * @param outputSchemaFn - Function to generate output JSON Schema
+ * @returns A Standard JSON Schema compliant object
+ */
+export function createSchemaWithSeparateJsonSchemas(validateFn, inputSchemaFn, outputSchemaFn) {
+    return {
+        '~standard': {
+            version: VERSION,
+            vendor: VENDOR,
+            validate: validateFn,
+            jsonSchema: {
+                input: (options) => inputSchemaFn(options.target),
+                output: (options) => outputSchemaFn(options.target),
+            },
+        },
+    };
+}
+/**
+ * Creates a validation success result.
+ *
+ * @template T - The value type
+ * @param value - The validated value
+ * @returns A successful validation result
+ */
+export function success(value) {
+    return { value };
+}
+/**
+ * Creates a validation failure result.
+ *
+ * @param issues - The validation issues
+ * @returns A failed validation result
+ */
+export function failure(issues) {
+    return { issues };
+}
+/**
+ * Creates a validation failure with a single issue.
+ *
+ * @param message - The error message
+ * @param path - Optional path to the invalid value
+ * @returns A failed validation result
+ */
+export function fail(message, path) {
+    const issue = path !== undefined ? { message, path } : { message };
+    return { issues: [issue] };
+}
+//# sourceMappingURL=factory.js.map

package/dist/factory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"factory.js","sourceRoot":"","sources":["../src/factory.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAUH,2DAA2D;AAC3D,MAAM,CAAC,MAAM,MAAM,GAAG,OAAgB,CAAC;AAEvC,mCAAmC;AACnC,MAAM,CAAC,MAAM,OAAO,GAAG,CAAU,CAAC;AAYlC;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,UAAU,YAAY,CAAI,UAAyB;IACvD,OAAO;QACL,WAAW,EAAE;YACX,OAAO,EAAE,OAAO;YAChB,MAAM,EAAE,MAAM;YACd,QAAQ,EAAE,UAAU;SACrB;KACF,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,UAAU,0BAA0B,CACxC,UAAyB,EACzB,YAA0B;IAE1B,OAAO;QACL,WAAW,EAAE;YACX,OAAO,EAAE,OAAO;YAChB,MAAM,EAAE,MAAM;YACd,QAAQ,EAAE,UAAU;YACpB,UAAU,EAAE;gBACV,KAAK,EAAE,CAAC,OAA0B,EAAE,EAAE,CAAC,YAAY,CAAC,OAAO,CAAC,MAAM,CAAC;gBACnE,MAAM,EAAE,CAAC,OAA0B,EAAE,EAAE,CAAC,YAAY,CAAC,OAAO,CAAC,MAAM,CAAC;aACrE;SACF;KACF,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,mCAAmC,CACjD,UAA8B,EAC9B,aAA2B,EAC3B,cAA4B;IAE5B,OAAO;QACL,WAAW,EAAE;YACX,OAAO,EAAE,OAAO;YAChB,MAAM,EAAE,MAAM;YACd,QAAQ,EAAE,UAAU;YACpB,UAAU,EAAE;gBACV,KAAK,EAAE,CAAC,OAA0B,EAAE,EAAE,CAAC,aAAa,CAAC,OAAO,CAAC,MAAM,CAAC;gBACpE,MAAM,EAAE,CAAC,OAA0B,EAAE,EAAE,CAAC,cAAc,CAAC,OAAO,CAAC,MAAM,CAAC;aACvE;SACF;KACF,CAAC;AACJ,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,OAAO,CAAI,KAAQ;IACjC,OAAO,EAAE,KAAK,EAAE,CAAC;AACnB,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,OAAO,CAAC,MAAsC;IAC5D,OAAO,EAAE,MAAM,EAAE,CAAC;AACpB,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,IAAI,CAClB,OAAe,EACf,IAAyE;IAEzE,MAAM,KAAK,GAAoB,IAAI,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC;IACpF,OAAO,EAAE,MAAM,EAAE,CAAC,KAAK,CAAC,EAAE,CAAC;AAC7B,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,79 @@
+/**
+ * valrs
+ *
+ * Rust-powered Standard Schema implementation with WASM bindings.
+ *
+ * Provides both a Zod-compatible fluent API (`v`) and Standard Schema
+ * compliant exports for interoperability.
+ *
+ * @packageDocumentation
+ * @see https://standardschema.dev/
+ *
+ * @example Zod-compatible API (recommended)
+ * ```typescript
+ * import { v } from 'valrs';
+ *
+ * // Create schemas with fluent API
+ * const nameSchema = v.string();
+ *
+ * // Parse and validate
+ * const name = nameSchema.parse('Alice');
+ *
+ * // Safe parsing (no exceptions)
+ * const result = nameSchema.safeParse(input);
+ * if (result.success) {
+ *   console.log(result.data);
+ * } else {
+ *   console.log(result.error.issues);
+ * }
+ *
+ * // Type inference
+ * type Name = v.infer<typeof nameSchema>; // string
+ * ```
+ *
+ * @example Standard Schema API
+ * ```typescript
+ * import { init, StringSchema, Int32Schema, isValidationSuccess } from 'valrs';
+ *
+ * async function main() {
+ *   // Initialize the WASM module
+ *   await init();
+ *
+ *   // Validate a string
+ *   const stringResult = StringSchema['~standard'].validate('hello');
+ *   if (isValidationSuccess(stringResult)) {
+ *     console.log(stringResult.value); // 'hello'
+ *   }
+ *
+ *   // Validate an integer
+ *   const intResult = Int32Schema['~standard'].validate(42);
+ *   if (isValidationSuccess(intResult)) {
+ *     console.log(intResult.value); // 42
+ *   }
+ *
+ *   // Get JSON Schema
+ *   const schema = StringSchema['~standard'].jsonSchema.input({ target: 'draft-2020-12' });
+ *   console.log(schema); // { type: 'string' }
+ * }
+ * ```
+ */
+export type { StandardSchemaV1, StandardJSONSchemaV1, ValidationResult, ValidationIssue, PathSegment, JsonSchemaOptions, InferInput, InferOutput, } from './types';
+export { isValidationSuccess, isValidationFailure } from './types';
+export { init, isInitialized } from './wasm';
+export type { WasmExports, WasmValidationResult } from './wasm';
+export { createSchema, createSchemaWithJsonSchema, createSchemaWithSeparateJsonSchemas, success, failure, fail, VENDOR, VERSION, } from './factory';
+export type { ValidateFn, JsonSchemaFn } from './factory';
+export { StringSchema, NumberSchema, BooleanSchema, Int32Schema, Int64Schema, Uint32Schema, Uint64Schema, Float32Schema, Float64Schema, DoubleSchema, IntegerSchema, } from './primitives';
+export { v, v as default } from './v';
+export type { Infer, infer, input, output, SafeParseResult, SafeParseSuccess, SafeParseError } from './v';
+export { ValSchema, ValString, ValNumber, ValBigInt, ValBoolean, ValDate, ValUndefined, ValNull, ValVoid, ValAny, ValUnknown, ValNever, ValInt32, ValInt64, ValUint32, ValUint64, ValFloat32, ValFloat64, ValObject, ValLiteral, ValArray, ValTuple, ValUnion, ValDiscriminatedUnion, ValIntersection, ValRecord, ValMap, ValSet, ValLiteralValue, ValEnum, ValNativeEnum, string, number, bigint, boolean, date, undefined, null, void, any, unknown, never, int32, int64, uint32, uint64, float32, float64, object, array, tuple, union, discriminatedUnion, intersection, record, map, set, literal, nativeEnum, wrap, preprocess, coerce, isSafeParseSuccess, isSafeParseError, } from './v';
+export { enum } from './v';
+export { ValOptional, ValNullable, ValNullish, ValDefault, ValCatch, ValTransformed, ValRefined, ValSuperRefined, ValPiped, ValPreprocessed, } from './schema';
+export type { RefinementContext, RefinementOptions, TransformFn, RefinePredicate, SuperRefineFn, } from './schema';
+export { ValError, setErrorMap, getErrorMap, resetErrorMap, getTypeName, createInvalidTypeIssue, createTooSmallIssue, createTooBigIssue, createInvalidStringIssue, createInvalidEnumValueIssue, createInvalidUnionIssue, createUnrecognizedKeysIssue, createCustomIssue, createInvalidLiteralIssue, createNotMultipleOfIssue, createNotFiniteIssue, createInvalidDateIssue, } from './error';
+export type { ValIssueCode, ValIssueBase, ValIssue, InvalidTypeIssue, InvalidLiteralIssue, CustomIssue, InvalidUnionIssue, InvalidUnionDiscriminatorIssue, InvalidEnumValueIssue, UnrecognizedKeysIssue, InvalidArgumentsIssue, InvalidReturnTypeIssue, InvalidDateIssue, InvalidStringIssue, TooSmallIssue, TooBigIssue, InvalidIntersectionTypesIssue, NotMultipleOfIssue, NotFiniteIssue, SizeType, StringValidation, ErrorMapContext, ErrorMapFn, SchemaErrorOptions, FormattedError, FlattenedError, } from './error';
+export { compileSchema, compileSchemaToCode, CompiledRegistry } from './compiler';
+export type { JsonSchema, CompiledValidator } from './compiler';
+export { stream, streamLines, createMockStream, createChunkedStream, } from './streaming';
+export type { StreamOptions, StreamResult, StreamError, StreamResultWithErrors, StreamInput, } from './streaming';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/dist/index.js

@@ -0,0 +1,104 @@
+/**
+ * valrs
+ *
+ * Rust-powered Standard Schema implementation with WASM bindings.
+ *
+ * Provides both a Zod-compatible fluent API (`v`) and Standard Schema
+ * compliant exports for interoperability.
+ *
+ * @packageDocumentation
+ * @see https://standardschema.dev/
+ *
+ * @example Zod-compatible API (recommended)
+ * ```typescript
+ * import { v } from 'valrs';
+ *
+ * // Create schemas with fluent API
+ * const nameSchema = v.string();
+ *
+ * // Parse and validate
+ * const name = nameSchema.parse('Alice');
+ *
+ * // Safe parsing (no exceptions)
+ * const result = nameSchema.safeParse(input);
+ * if (result.success) {
+ *   console.log(result.data);
+ * } else {
+ *   console.log(result.error.issues);
+ * }
+ *
+ * // Type inference
+ * type Name = v.infer<typeof nameSchema>; // string
+ * ```
+ *
+ * @example Standard Schema API
+ * ```typescript
+ * import { init, StringSchema, Int32Schema, isValidationSuccess } from 'valrs';
+ *
+ * async function main() {
+ *   // Initialize the WASM module
+ *   await init();
+ *
+ *   // Validate a string
+ *   const stringResult = StringSchema['~standard'].validate('hello');
+ *   if (isValidationSuccess(stringResult)) {
+ *     console.log(stringResult.value); // 'hello'
+ *   }
+ *
+ *   // Validate an integer
+ *   const intResult = Int32Schema['~standard'].validate(42);
+ *   if (isValidationSuccess(intResult)) {
+ *     console.log(intResult.value); // 42
+ *   }
+ *
+ *   // Get JSON Schema
+ *   const schema = StringSchema['~standard'].jsonSchema.input({ target: 'draft-2020-12' });
+ *   console.log(schema); // { type: 'string' }
+ * }
+ * ```
+ */
+export { isValidationSuccess, isValidationFailure } from './types';
+// WASM initialization
+export { init, isInitialized } from './wasm';
+// Schema factory functions
+export { createSchema, createSchemaWithJsonSchema, createSchemaWithSeparateJsonSchemas, success, failure, fail, VENDOR, VERSION, } from './factory';
+// Primitive schemas
+export { StringSchema, NumberSchema, BooleanSchema, Int32Schema, Int64Schema, Uint32Schema, Uint64Schema, Float32Schema, Float64Schema, DoubleSchema, IntegerSchema, } from './primitives';
+// Zod-compatible fluent API
+export { v, v as default } from './v';
+export { 
+// Schema classes - primitives
+ValSchema, ValString, ValNumber, ValBigInt, ValBoolean, ValDate, ValUndefined, ValNull, ValVoid, ValAny, ValUnknown, ValNever, ValInt32, ValInt64, ValUint32, ValUint64, ValFloat32, ValFloat64, 
+// Schema classes - composite
+ValObject, ValLiteral, 
+// Schema classes - Phase 4
+ValArray, ValTuple, ValUnion, ValDiscriminatedUnion, ValIntersection, ValRecord, ValMap, ValSet, ValLiteralValue, ValEnum, ValNativeEnum, 
+// Builder functions - primitives
+string, number, bigint, boolean, date, undefined, null, void, any, unknown, never, int32, int64, uint32, uint64, float32, float64, 
+// Builder functions - composite
+object, 
+// Builder functions - Phase 4
+array, tuple, union, discriminatedUnion, intersection, record, map, set, literal, nativeEnum, 
+// Utilities
+wrap, 
+// Phase 5: Transform and refinement utilities
+preprocess, coerce, 
+// Type guards
+isSafeParseSuccess, isSafeParseError, } from './v';
+// Use 'enum' as a named export (reserved word)
+export { enum } from './v';
+// Wrapper schema classes
+export { ValOptional, ValNullable, ValNullish, ValDefault, ValCatch, 
+// Phase 5: Transform and refinement wrappers
+ValTransformed, ValRefined, ValSuperRefined, ValPiped, ValPreprocessed, } from './schema';
+// Error types and formatting (Phase 7)
+export { ValError, 
+// Error map functions
+setErrorMap, getErrorMap, resetErrorMap, 
+// Issue creation helpers
+getTypeName, createInvalidTypeIssue, createTooSmallIssue, createTooBigIssue, createInvalidStringIssue, createInvalidEnumValueIssue, createInvalidUnionIssue, createUnrecognizedKeysIssue, createCustomIssue, createInvalidLiteralIssue, createNotMultipleOfIssue, createNotFiniteIssue, createInvalidDateIssue, } from './error';
+// Schema compiler (JS code generation)
+export { compileSchema, compileSchemaToCode, CompiledRegistry } from './compiler';
+// Phase 6: Streaming validation
+export { stream, streamLines, createMockStream, createChunkedStream, } from './streaming';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DG;AAcH,OAAO,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAEnE,sBAAsB;AACtB,OAAO,EAAE,IAAI,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAC;AAG7C,2BAA2B;AAC3B,OAAO,EACL,YAAY,EACZ,0BAA0B,EAC1B,mCAAmC,EACnC,OAAO,EACP,OAAO,EACP,IAAI,EACJ,MAAM,EACN,OAAO,GACR,MAAM,WAAW,CAAC;AAGnB,oBAAoB;AACpB,OAAO,EACL,YAAY,EACZ,YAAY,EACZ,aAAa,EACb,WAAW,EACX,WAAW,EACX,YAAY,EACZ,YAAY,EACZ,aAAa,EACb,aAAa,EACb,YAAY,EACZ,aAAa,GACd,MAAM,cAAc,CAAC;AAEtB,4BAA4B;AAC5B,OAAO,EAAE,CAAC,EAAE,CAAC,IAAI,OAAO,EAAE,MAAM,KAAK,CAAC;AAEtC,OAAO;AACL,8BAA8B;AAC9B,SAAS,EACT,SAAS,EACT,SAAS,EACT,SAAS,EACT,UAAU,EACV,OAAO,EACP,YAAY,EACZ,OAAO,EACP,OAAO,EACP,MAAM,EACN,UAAU,EACV,QAAQ,EACR,QAAQ,EACR,QAAQ,EACR,SAAS,EACT,SAAS,EACT,UAAU,EACV,UAAU;AACV,6BAA6B;AAC7B,SAAS,EACT,UAAU;AACV,2BAA2B;AAC3B,QAAQ,EACR,QAAQ,EACR,QAAQ,EACR,qBAAqB,EACrB,eAAe,EACf,SAAS,EACT,MAAM,EACN,MAAM,EACN,eAAe,EACf,OAAO,EACP,aAAa;AACb,iCAAiC;AACjC,MAAM,EACN,MAAM,EACN,MAAM,EACN,OAAO,EACP,IAAI,EACJ,SAAS,EACT,IAAI,EACJ,IAAI,EACJ,GAAG,EACH,OAAO,EACP,KAAK,EACL,KAAK,EACL,KAAK,EACL,MAAM,EACN,MAAM,EACN,OAAO,EACP,OAAO;AACP,gCAAgC;AAChC,MAAM;AACN,8BAA8B;AAC9B,KAAK,EACL,KAAK,EACL,KAAK,EACL,kBAAkB,EAClB,YAAY,EACZ,MAAM,EACN,GAAG,EACH,GAAG,EACH,OAAO,EACP,UAAU;AACV,YAAY;AACZ,IAAI;AACJ,8CAA8C;AAC9C,UAAU,EACV,MAAM;AACN,cAAc;AACd,kBAAkB,EAClB,gBAAgB,GACjB,MAAM,KAAK,CAAC;AAEb,+CAA+C;AAC/C,OAAO,EAAE,IAAI,EAAE,MAAM,KAAK,CAAC;AAE3B,yBAAyB;AACzB,OAAO,EACL,WAAW,EACX,WAAW,EACX,UAAU,EACV,UAAU,EACV,QAAQ;AACR,6CAA6C;AAC7C,cAAc,EACd,UAAU,EACV,eAAe,EACf,QAAQ,EACR,eAAe,GAChB,MAAM,UAAU,CAAC;AAWlB,uCAAuC;AACvC,OAAO,EACL,QAAQ;AACR,sBAAsB;AACtB,WAAW,EACX,WAAW,EACX,aAAa;AACb,yBAAyB;AACzB,WAAW,EACX,sBAAsB,EACtB,mBAAmB,EACnB,iBAAiB,EACjB,wBAAwB,EACxB,2BAA2B,EAC3B,uBAAuB,EACvB,2BAA2B,EAC3B,iBAAiB,EACjB,yBAAyB,EACzB,wBAAwB,EACxB,oBAAoB,EACpB,sBAAsB,GACvB,MAAM,SAAS,CAAC;AAqCjB,uCAAuC;AACvC,OAAO,EAAE,aAAa,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAGlF,gCAAgC;AAChC,OAAO,EACL,MAAM,EACN,WAAW,EACX,gBAAgB,EAChB,mBAAmB,GACpB,MAAM,aAAa,CAAC"}

package/dist/primitives.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Primitive schema definitions.
+ *
+ * These schemas validate JavaScript primitives using the WASM bindings.
+ * Each schema implements both validation and JSON Schema generation.
+ */
+import type { StandardJSONSchemaV1 } from './types';
+/**
+ * Schema for validating string values.
+ *
+ * @example
+ * ```typescript
+ * import { init, StringSchema } from 'valrs';
+ *
+ * await init();
+ *
+ * const result = StringSchema['~standard'].validate('hello');
+ * // { value: 'hello' }
+ *
+ * const invalid = StringSchema['~standard'].validate(123);
+ * // { issues: [{ message: 'Expected string' }] }
+ * ```
+ */
+export declare const StringSchema: StandardJSONSchemaV1<string, string>;
+/**
+ * Schema for validating number values (JavaScript number, IEEE 754 double).
+ *
+ * @example
+ * ```typescript
+ * const result = NumberSchema['~standard'].validate(3.14);
+ * // { value: 3.14 }
+ * ```
+ */
+export declare const NumberSchema: StandardJSONSchemaV1<number, number>;
+/**
+ * Schema for validating boolean values.
+ *
+ * @example
+ * ```typescript
+ * const result = BooleanSchema['~standard'].validate(true);
+ * // { value: true }
+ * ```
+ */
+export declare const BooleanSchema: StandardJSONSchemaV1<boolean, boolean>;
+/**
+ * Schema for validating 32-bit signed integers.
+ *
+ * Range: -2,147,483,648 to 2,147,483,647
+ *
+ * @example
+ * ```typescript
+ * const result = Int32Schema['~standard'].validate(42);
+ * // { value: 42 }
+ *
+ * const invalid = Int32Schema['~standard'].validate(3.14);
+ * // { issues: [{ message: 'Expected i32' }] }
+ * ```
+ */
+export declare const Int32Schema: StandardJSONSchemaV1<number, number>;
+/**
+ * Schema for validating 64-bit signed integers.
+ *
+ * Note: JavaScript numbers can only safely represent integers up to 2^53 - 1.
+ * For full i64 range, consider using BigInt.
+ *
+ * Range: -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807
+ */
+export declare const Int64Schema: StandardJSONSchemaV1<number, number>;
+/**
+ * Schema for validating 32-bit unsigned integers.
+ *
+ * Range: 0 to 4,294,967,295
+ */
+export declare const Uint32Schema: StandardJSONSchemaV1<number, number>;
+/**
+ * Schema for validating 64-bit unsigned integers.
+ *
+ * Note: JavaScript numbers can only safely represent integers up to 2^53 - 1.
+ *
+ * Range: 0 to 18,446,744,073,709,551,615
+ */
+export declare const Uint64Schema: StandardJSONSchemaV1<number, number>;
+/**
+ * Schema for validating 32-bit floating point numbers.
+ */
+export declare const Float32Schema: StandardJSONSchemaV1<number, number>;
+/**
+ * Schema for validating 64-bit floating point numbers.
+ */
+export declare const Float64Schema: StandardJSONSchemaV1<number, number>;
+/**
+ * Alias for Float64Schema - the default JavaScript number type.
+ */
+export { Float64Schema as DoubleSchema };
+/**
+ * Alias for Int32Schema - commonly used integer type.
+ */
+export { Int32Schema as IntegerSchema };
+//# sourceMappingURL=primitives.d.ts.map

package/dist/primitives.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"primitives.d.ts","sourceRoot":"","sources":["../src/primitives.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,KAAK,EAAE,oBAAoB,EAAqC,MAAM,SAAS,CAAC;AAmBvF;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,YAAY,EAAE,oBAAoB,CAAC,MAAM,EAAE,MAAM,CAuB7D,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,YAAY,EAAE,oBAAoB,CAAC,MAAM,EAAE,MAAM,CAqB7D,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,aAAa,EAAE,oBAAoB,CAAC,OAAO,EAAE,OAAO,CAqBhE,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,WAAW,EAAE,oBAAoB,CAAC,MAAM,EAAE,MAAM,CA8B5D,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,WAAW,EAAE,oBAAoB,CAAC,MAAM,EAAE,MAAM,CAqB5D,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,YAAY,EAAE,oBAAoB,CAAC,MAAM,EAAE,MAAM,CA6B7D,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,YAAY,EAAE,oBAAoB,CAAC,MAAM,EAAE,MAAM,CAqB7D,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,aAAa,EAAE,oBAAoB,CAAC,MAAM,EAAE,MAAM,CAqB9D,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,aAAa,EAAE,oBAAoB,CAAC,MAAM,EAAE,MAAM,CAqB9D,CAAC;AAEF;;GAEG;AACH,OAAO,EAAE,aAAa,IAAI,YAAY,EAAE,CAAC;AAEzC;;GAEG;AACH,OAAO,EAAE,WAAW,IAAI,aAAa,EAAE,CAAC"}