bupkis 0.7.2 → 0.8.0

package/src/use.ts

@@ -27,6 +27,8 @@ import {
   type UseFn,
 } from './types.js';
 
+const { assign } = Object;
+
 /**
  * Creates an `expect.it()` factory function for generating embeddable assertion
  * executors.
@@ -60,6 +62,7 @@ import {
  *
  * @template SyncAssertions - Array of synchronous assertion objects that define
  *   the available assertion logic for the embeddable functions
+ * @function
  * @param expect - The underlying expect function that will execute the
  *   assertions when the returned executors are called
  * @returns A factory function that creates {@link ExpectItExecutor} instances
@@ -72,8 +75,11 @@ import {
 const createExpectIt = <SyncAssertions extends AnySyncAssertions>(
   expect: any,
 ): ExpectIt<SyncAssertions> => {
+  /**
+   * @function
+   */
   const expectIt = (...args: readonly unknown[]) => {
-    const func = Object.assign(
+    const func = assign(
       (subject: unknown) => {
         const allArgs = [subject, ...args];
         // eslint-disable-next-line @typescript-eslint/no-unsafe-call
@@ -121,6 +127,7 @@ const createExpectIt = <SyncAssertions extends AnySyncAssertions>(
  *
  * @template AsyncAssertions - Array of asynchronous assertion objects that
  *   define the available assertion logic for the embeddable async functions
+ * @function
  * @param expectAsync - The underlying expectAsync function that will execute
  *   the assertions when the returned executors are called
  * @returns A factory function that creates {@link ExpectItExecutorAsync}
@@ -134,8 +141,11 @@ const createExpectIt = <SyncAssertions extends AnySyncAssertions>(
 const createExpectItAsync = <AsyncAssertions extends AnyAsyncAssertions>(
   expectAsync: any,
 ): ExpectItAsync<AsyncAssertions> => {
+  /**
+   * @function
+   */
   const expectItAsync = (...args: readonly unknown[]) => {
-    const func = Object.assign(
+    const func = assign(
       async (subject: unknown) => {
         const allArgs = [subject, ...args];
         // eslint-disable-next-line @typescript-eslint/no-unsafe-call
@@ -210,6 +220,7 @@ const createExpectItAsync = <AsyncAssertions extends AnyAsyncAssertions>(
  *   available in the composed functions
  * @template AsyncAssertions - Array of base asynchronous assertions that will
  *   be available in the composed functions
+ * @function
  * @param syncAssertions - Base synchronous assertions to include in all
  *   composed expect functions
  * @param asyncAssertions - Base asynchronous assertions to include in all
@@ -223,15 +234,18 @@ const createExpectItAsync = <AsyncAssertions extends AnyAsyncAssertions>(
  * @see {@link FilterAsyncAssertions} for how async assertions are extracted
  * @see {@link Concat} for how assertion arrays are combined
  */
-export function createUse<
+export const createUse = <
   const SyncAssertions extends AnySyncAssertions,
   const AsyncAssertions extends AnyAsyncAssertions,
 >(
   syncAssertions: SyncAssertions,
   asyncAssertions: AsyncAssertions,
-): UseFn<SyncAssertions, AsyncAssertions> {
+): UseFn<SyncAssertions, AsyncAssertions> => {
   const syncAssertionsIn = syncAssertions ?? [];
   const asyncAssertionsIn = asyncAssertions ?? [];
+  /**
+   * @function
+   */
   const use: UseFn<SyncAssertions, AsyncAssertions> = <
     AllAssertions extends readonly AnyAssertion[],
     FilteredSyncAssertions extends FilterSyncAssertions<AllAssertions>,
@@ -256,12 +270,12 @@ export function createUse<
     const expectFunction = createExpectSyncFunction(allSyncAssertions);
     const expectAsyncFunction = createExpectAsyncFunction(allAsyncAssertions);
 
-    const expect = Object.assign(
+    const expect = assign(
       expectFunction,
       createBaseExpect(allSyncAssertions, allAsyncAssertions, 'sync'),
       { it: createExpectIt(expectFunction) },
     );
-    const expectAsync = Object.assign(
+    const expectAsync = assign(
       expectAsyncFunction,
       createBaseExpect(allSyncAssertions, allAsyncAssertions, 'async'),
       { it: createExpectItAsync(expectAsyncFunction) },
@@ -276,4 +290,4 @@ export function createUse<
     };
   };
   return use;
-}
+};

package/src/util.ts

@@ -17,6 +17,10 @@ import { type Keypath } from './types.js';
 
 export * from './value-to-schema.js';
 
+const { hasOwn, keys, values } = Object;
+const { isInteger, isNaN } = Number;
+const { isArray } = Array;
+
 /**
  * Retrieves the value at a given keypath from an object using dot or bracket
  * notation.
@@ -191,18 +195,18 @@ export const hasKeyDeep = (
   visited.add(obj);
 
   try {
-    if (Object.hasOwn(obj, key)) {
+    if (hasOwn(obj, key)) {
       return true;
     }
 
-    if (Array.isArray(obj)) {
+    if (isArray(obj)) {
       for (const item of obj) {
         if (hasKeyDeep(item, key, visited)) {
           return true;
         }
       }
     } else {
-      for (const propValue of Object.values(obj)) {
+      for (const propValue of values(obj)) {
         if (hasKeyDeep(propValue, key, visited)) {
           return true;
         }
@@ -255,13 +259,13 @@ export const hasValueDeep = (
   if (
     typeof obj === 'object' &&
     obj !== null &&
-    !Array.isArray(obj) &&
+    !isArray(obj) &&
     typeof value === 'object' &&
     value !== null &&
-    !Array.isArray(value)
+    !isArray(value)
   ) {
-    const objKeys = Object.keys(obj);
-    const valueKeys = Object.keys(value);
+    const objKeys = keys(obj);
+    const valueKeys = keys(value);
 
     if (objKeys.length === 0 && valueKeys.length === 0) {
       return true;
@@ -278,14 +282,14 @@ export const hasValueDeep = (
   visited.add(obj);
 
   try {
-    if (Array.isArray(obj)) {
+    if (isArray(obj)) {
       for (const item of obj) {
         if (hasValueDeep(item, value, visited)) {
           return true;
         }
       }
     } else {
-      for (const propValue of Object.values(obj)) {
+      for (const propValue of values(obj)) {
         if (hasValueDeep(propValue, value, visited)) {
           return true;
         }
@@ -364,6 +368,7 @@ export const keyBy = <
  * parseKeypath("arr[10]['spam']"); // ['arr', 10, 'spam']
  * ```
  *
+ * @function
  * @param keypath The keypath string to parse, using dot and/or bracket
  *   notation.
  * @returns An array of keys, where each key is a string or number. Bracketed
@@ -401,9 +406,7 @@ export const parseKeypath = <S extends string = string>(
       i++;
 
       const numKey = Number(key);
-      keys.push(
-        Number.isInteger(numKey) && !Number.isNaN(numKey) ? numKey : key,
-      );
+      keys.push(isInteger(numKey) && !isNaN(numKey) ? numKey : key);
     } else if (keypath[i] === '.') {
       i++;
     } else {

package/src/value-to-schema.ts

@@ -11,6 +11,10 @@ import {
 } from './guards.js';
 import { RegExpSchema, WrappedPromiseLikeSchema } from './schema.js';
 
+const { isNaN } = Number;
+const { entries, freeze, hasOwn, keys } = Object;
+const { isArray } = Array;
+
 /**
  * Recursively converts an arbitrary value to a Zod v4 schema that would
  * validate values with the same structure.
@@ -41,6 +45,7 @@ import { RegExpSchema, WrappedPromiseLikeSchema } from './schema.js';
  * // 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
@@ -82,7 +87,7 @@ export const valueToSchema = (
         })
       : z.undefined();
   }
-  if (Number.isNaN(value as number)) {
+  if (isNaN(value as number)) {
     return z.nan();
   }
   if (value === Infinity || value === -Infinity) {
@@ -142,7 +147,7 @@ export const valueToSchema = (
 
     try {
       // Check for objects with own __proto__ property - these can cause unexpected behavior
-      if (Object.hasOwn(value, '__proto__')) {
+      if (hasOwn(value, '__proto__')) {
         throw new ValueToSchemaError(
           'Objects with an own "__proto__" property are not supported by valueToSchema',
         );
@@ -195,7 +200,7 @@ export const valueToSchema = (
       }
 
       // Handle arrays
-      if (Array.isArray(value)) {
+      if (isArray(value)) {
         // For arrays, we need to preserve undefined values while allowing
         // other elements to use the original literalPrimitives setting
         const filteredValue = value; // Always process all elements
@@ -232,6 +237,9 @@ export const valueToSchema = (
 
         if (!noMixedArrays) {
           // Helper function to generate structural keys for schemas
+          /**
+           * @function
+           */
           const getSchemaKey = <T extends z.core.SomeType | z.ZodType>(
             zodType: T,
           ): string => {
@@ -253,7 +261,7 @@ export const valueToSchema = (
                 string,
                 z.ZodType
               >;
-              const shapeKeys = Object.keys(shape)
+              const shapeKeys = keys(shape)
                 .sort()
                 .map((key) => {
                   const propSchema = shape[key]!;
@@ -304,7 +312,7 @@ export const valueToSchema = (
         const schemaShape: Record<string, z.ZodType<any>> = {};
         const undefinedKeys: string[] = [];
 
-        for (const [key, val] of Object.entries(value)) {
+        for (const [key, val] of entries(value)) {
           if (isString(key)) {
             // Skip undefined values unless we're in literalPrimitives mode
             // This prevents objects with only undefined values from matching any object
@@ -347,7 +355,7 @@ export const valueToSchema = (
 
             const obj = data as Record<string, unknown>;
             for (const key of undefinedKeys) {
-              if (!Object.hasOwn(obj, key)) {
+              if (!hasOwn(obj, key)) {
                 ctx.addIssue({
                   code: z.ZodIssueCode.custom,
                   message: `Expected property "${key}" to exist with value undefined`,
@@ -359,10 +367,10 @@ export const valueToSchema = (
         }
 
         // Check if this is an empty object and literalEmptyObjects is enabled
-        if (Object.keys(schemaShape).length === 0 && literalEmptyObjects) {
+        if (keys(schemaShape).length === 0 && literalEmptyObjects) {
           // Create a schema that only matches empty objects
           return z.custom<Record<string, never>>(
-            (val) => isObject(val) && Object.keys(val).length === 0,
+            (val) => isObject(val) && keys(val).length === 0,
             {
               message: 'Expected an empty object with no own properties',
             },
@@ -461,7 +469,7 @@ export interface ValueToSchemaOptions {
  * Uses literal primitives and tuples for exact matching while allowing extra
  * properties.
  */
-export const valueToSchemaOptionsForSatisfies = Object.freeze({
+export const valueToSchemaOptionsForSatisfies = freeze({
   literalEmptyObjects: true,
   literalPrimitives: true,
   literalRegExp: false,
@@ -476,7 +484,7 @@ export const valueToSchemaOptionsForSatisfies = Object.freeze({
  * Uses literal primitives, regexp, and tuples with strict validation for exact
  * matching.
  */
-export const valueToSchemaOptionsForDeepEqual = Object.freeze({
+export const valueToSchemaOptionsForDeepEqual = freeze({
   literalEmptyObjects: true,
   literalPrimitives: true,
   literalRegExp: true,