bupkis 0.18.0 → 0.18.2

package/dist/value-to-schema.d.cts

@@ -1,144 +0,0 @@
-import { z } from 'zod';
-/**
- * Recursively converts an arbitrary value to a Zod v4 schema that would
- * validate values with the same structure.
- *
- * This function analyzes the runtime value and generates a corresponding Zod
- * schema that captures the value's structure and type information. It handles
- * primitives, objects, arrays, functions, and various built-in types, with
- * support for circular reference detection.
- *
- * @example
- *
- * ```typescript
- * // Primitive types
- * valueToSchema('hello'); // z.string()
- * valueToSchema(42); // z.number()
- * valueToSchema(true); // z.boolean()
- *
- * // Objects
- * valueToSchema({ name: 'John', age: 30 });
- * // z.object({ name: z.string(), age: z.number() })
- *
- * // Arrays
- * valueToSchema(['a', 'b', 'c']); // z.array(z.string())
- * valueToSchema([1, 'mixed']); // z.array(z.union([z.number(), z.string()]))
- *
- * // Nested structures
- * valueToSchema({ users: [{ name: 'John' }] });
- * // z.object({ users: z.array(z.object({ name: z.string() })) })
- * ```
- *
- * @function
- * @param value - The value to convert to a schema
- * @param options - Configuration options for schema generation
- * @param visited - Internal WeakSet for circular reference detection
- * @returns A Zod schema that validates values matching the input's structure.
- *   This value is unfortunately untyped due to the complexity involved. But the
- *   schema works!
- */
-export declare const valueToSchema: (value: unknown, options?: ValueToSchemaOptions, visited?: WeakSet<object>) => z.ZodType<any>;
-/**
- * Options for {@link valueToSchema}
- */
-export interface ValueToSchemaOptions {
-    /**
-     * If `true`, treat empty arrays `[]` as literal empty arrays that only match
-     * arrays with zero elements. When `false`, empty arrays match any array.
-     *
-     * @defaultValue false
-     */
-    literalEmptyArrays?: boolean;
-    /**
-     * If `true`, treat empty objects `{}` as literal empty objects that only
-     * match objects with zero own properties
-     *
-     * @defaultValue false
-     */
-    literalEmptyObjects?: boolean;
-    /**
-     * If `true`, use literal schema for primitive values instead of type schema
-     *
-     * @defaultValue false
-     */
-    literalPrimitives?: boolean;
-    /**
-     * If `true`, treat `RegExp` literals as `RegExp` literals; otherwise treat as
-     * strings and attempt match
-     *
-     * @defaultValue false
-     */
-    literalRegExp?: boolean;
-    /**
-     * If `true`, treat arrays as tuples wherever possible.
-     *
-     * Implies `false` for {@link noMixedArrays}.
-     *
-     * @defaultValue false
-     */
-    literalTuples?: boolean;
-    /**
-     * Maximum nesting depth to prevent stack overflow
-     *
-     * @defaultValue 10
-     */
-    maxDepth?: number;
-    /**
-     * Whether to allow mixed types in arrays
-     *
-     * If {@link literalTuples} is `true`, this option is ignored and treated as
-     * `false`.
-     *
-     * @defaultValue false
-     */
-    noMixedArrays?: boolean;
-    /**
-     * If `true`, use property checking that works on any value type (functions,
-     * arrays, etc.), not just plain objects. Properties are checked using the
-     * `in` operator which works with non-enumerable and inherited properties.
-     *
-     * Only applies when `strict` is `false`. When `strict` is `true`, standard
-     * Zod object validation is used which requires exact type matching.
-     *
-     * @defaultValue false
-     */
-    permissivePropertyCheck?: boolean;
-    /**
-     * If `true`, will disallow unknown properties in parsed objects
-     *
-     * @defaultValue false
-     */
-    strict?: boolean;
-}
-/**
- * Predefined options for {@link valueToSchema} optimized for object satisfaction
- * checks.
- *
- * Uses literal primitives and tuples for exact matching while allowing extra
- * properties.
- */
-export declare const valueToSchemaOptionsForSatisfies: Readonly<{
-    readonly literalEmptyArrays: false;
-    readonly literalEmptyObjects: true;
-    readonly literalPrimitives: true;
-    readonly literalRegExp: false;
-    readonly literalTuples: true;
-    readonly permissivePropertyCheck: true;
-    readonly strict: false;
-}>;
-/**
- * Predefined options for {@link valueToSchema} optimized for deep equality
- * checks.
- *
- * Uses literal primitives, regexp, and tuples with strict validation for exact
- * matching.
- */
-export declare const valueToSchemaOptionsForDeepEqual: Readonly<{
-    readonly literalEmptyArrays: true;
-    readonly literalEmptyObjects: true;
-    readonly literalPrimitives: true;
-    readonly literalRegExp: true;
-    readonly literalTuples: true;
-    readonly strict: true;
-}>;
-//# sourceMappingURL=value-to-schema.d.ts.map

package/dist/value-to-schema.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"value-to-schema.d.ts","sourceRoot":"","sources":["../src/value-to-schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAiBxB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AAEH,eAAO,MAAM,aAAa,GACxB,OAAO,OAAO,EACd,UAAS,oBAAyB,EAClC,yBAA+B,KAC9B,CAAC,CAAC,OAAO,CAAC,GAAG,CAukBf,CAAC;AAEF;;GAEG;AACH,MAAM,WAAW,oBAAoB;IAQnC;;;;;OAKG;IACH,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAE7B;;;;;OAKG;IACH,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAE9B;;;;OAIG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAE5B;;;;;OAKG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IAExB;;;;;;OAMG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IAExB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB;;;;;;;OAOG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IAExB;;;;;;;;;OASG;IACH,uBAAuB,CAAC,EAAE,OAAO,CAAC;IAElC;;;;OAIG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED;;;;;;GAMG;AACH,eAAO,MAAM,gCAAgC;;;;;;;;EAQH,CAAC;AAE3C;;;;;;GAMG;AACH,eAAO,MAAM,gCAAgC;;;;;;;EAOH,CAAC"}

package/dist/value-to-schema.d.ts

@@ -1,144 +0,0 @@
-import { z } from 'zod';
-/**
- * Recursively converts an arbitrary value to a Zod v4 schema that would
- * validate values with the same structure.
- *
- * This function analyzes the runtime value and generates a corresponding Zod
- * schema that captures the value's structure and type information. It handles
- * primitives, objects, arrays, functions, and various built-in types, with
- * support for circular reference detection.
- *
- * @example
- *
- * ```typescript
- * // Primitive types
- * valueToSchema('hello'); // z.string()
- * valueToSchema(42); // z.number()
- * valueToSchema(true); // z.boolean()
- *
- * // Objects
- * valueToSchema({ name: 'John', age: 30 });
- * // z.object({ name: z.string(), age: z.number() })
- *
- * // Arrays
- * valueToSchema(['a', 'b', 'c']); // z.array(z.string())
- * valueToSchema([1, 'mixed']); // z.array(z.union([z.number(), z.string()]))
- *
- * // Nested structures
- * valueToSchema({ users: [{ name: 'John' }] });
- * // z.object({ users: z.array(z.object({ name: z.string() })) })
- * ```
- *
- * @function
- * @param value - The value to convert to a schema
- * @param options - Configuration options for schema generation
- * @param visited - Internal WeakSet for circular reference detection
- * @returns A Zod schema that validates values matching the input's structure.
- *   This value is unfortunately untyped due to the complexity involved. But the
- *   schema works!
- */
-export declare const valueToSchema: (value: unknown, options?: ValueToSchemaOptions, visited?: WeakSet<object>) => z.ZodType<any>;
-/**
- * Options for {@link valueToSchema}
- */
-export interface ValueToSchemaOptions {
-    /**
-     * If `true`, treat empty arrays `[]` as literal empty arrays that only match
-     * arrays with zero elements. When `false`, empty arrays match any array.
-     *
-     * @defaultValue false
-     */
-    literalEmptyArrays?: boolean;
-    /**
-     * If `true`, treat empty objects `{}` as literal empty objects that only
-     * match objects with zero own properties
-     *
-     * @defaultValue false
-     */
-    literalEmptyObjects?: boolean;
-    /**
-     * If `true`, use literal schema for primitive values instead of type schema
-     *
-     * @defaultValue false
-     */
-    literalPrimitives?: boolean;
-    /**
-     * If `true`, treat `RegExp` literals as `RegExp` literals; otherwise treat as
-     * strings and attempt match
-     *
-     * @defaultValue false
-     */
-    literalRegExp?: boolean;
-    /**
-     * If `true`, treat arrays as tuples wherever possible.
-     *
-     * Implies `false` for {@link noMixedArrays}.
-     *
-     * @defaultValue false
-     */
-    literalTuples?: boolean;
-    /**
-     * Maximum nesting depth to prevent stack overflow
-     *
-     * @defaultValue 10
-     */
-    maxDepth?: number;
-    /**
-     * Whether to allow mixed types in arrays
-     *
-     * If {@link literalTuples} is `true`, this option is ignored and treated as
-     * `false`.
-     *
-     * @defaultValue false
-     */
-    noMixedArrays?: boolean;
-    /**
-     * If `true`, use property checking that works on any value type (functions,
-     * arrays, etc.), not just plain objects. Properties are checked using the
-     * `in` operator which works with non-enumerable and inherited properties.
-     *
-     * Only applies when `strict` is `false`. When `strict` is `true`, standard
-     * Zod object validation is used which requires exact type matching.
-     *
-     * @defaultValue false
-     */
-    permissivePropertyCheck?: boolean;
-    /**
-     * If `true`, will disallow unknown properties in parsed objects
-     *
-     * @defaultValue false
-     */
-    strict?: boolean;
-}
-/**
- * Predefined options for {@link valueToSchema} optimized for object satisfaction
- * checks.
- *
- * Uses literal primitives and tuples for exact matching while allowing extra
- * properties.
- */
-export declare const valueToSchemaOptionsForSatisfies: Readonly<{
-    readonly literalEmptyArrays: false;
-    readonly literalEmptyObjects: true;
-    readonly literalPrimitives: true;
-    readonly literalRegExp: false;
-    readonly literalTuples: true;
-    readonly permissivePropertyCheck: true;
-    readonly strict: false;
-}>;
-/**
- * Predefined options for {@link valueToSchema} optimized for deep equality
- * checks.
- *
- * Uses literal primitives, regexp, and tuples with strict validation for exact
- * matching.
- */
-export declare const valueToSchemaOptionsForDeepEqual: Readonly<{
-    readonly literalEmptyArrays: true;
-    readonly literalEmptyObjects: true;
-    readonly literalPrimitives: true;
-    readonly literalRegExp: true;
-    readonly literalTuples: true;
-    readonly strict: true;
-}>;
-//# sourceMappingURL=value-to-schema.d.ts.map

package/dist/value-to-schema.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"value-to-schema.d.ts","sourceRoot":"","sources":["../src/value-to-schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAiBxB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AAEH,eAAO,MAAM,aAAa,GACxB,OAAO,OAAO,EACd,UAAS,oBAAyB,EAClC,yBAA+B,KAC9B,CAAC,CAAC,OAAO,CAAC,GAAG,CAukBf,CAAC;AAEF;;GAEG;AACH,MAAM,WAAW,oBAAoB;IAQnC;;;;;OAKG;IACH,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAE7B;;;;;OAKG;IACH,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAE9B;;;;OAIG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAE5B;;;;;OAKG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IAExB;;;;;;OAMG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IAExB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB;;;;;;;OAOG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IAExB;;;;;;;;;OASG;IACH,uBAAuB,CAAC,EAAE,OAAO,CAAC;IAElC;;;;OAIG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED;;;;;;GAMG;AACH,eAAO,MAAM,gCAAgC;;;;;;;;EAQH,CAAC;AAE3C;;;;;;GAMG;AACH,eAAO,MAAM,gCAAgC;;;;;;;EAOH,CAAC"}