bupkis 0.18.3 → 1.0.0

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

@@ -0,0 +1,144 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,144 @@
+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

@@ -0,0 +1 @@
+{"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"}