bupkis 0.18.2 → 1.0.0

package/src/assertion/impl/sync.ts

@@ -58,21 +58,33 @@ import {
   arrayContainsAssertion,
   arrayItemSatisfiesAssertion,
   arraySizeAssertion,
+  collectionHasValueExhaustivelySatisfyingAssertion,
+  collectionHasValueSatisfyingAssertion,
   collectionSizeBetweenAssertion,
   collectionSizeGreaterThanAssertion,
   collectionSizeLessThanAssertion,
+  collectionValuesExhaustivelySatisfyAssertion,
+  collectionValuesSatisfyAssertion,
   emptyMapAssertion,
   emptySetAssertion,
   mapContainsAssertion,
   mapEntryAssertion,
   mapEqualityAssertion,
+  mapHasKeyExhaustivelySatisfyingAssertion,
+  mapHasKeySatisfyingAssertion,
   mapKeyAssertion,
+  mapKeysExhaustivelySatisfyAssertion,
+  mapKeysSatisfyAssertion,
   mapSizeAssertion,
   mapValueAssertion,
   nonEmptyArrayAssertion,
   objectExactKeyAssertion,
+  objectHasKeyMatchingAssertion,
+  objectHasKeySatisfyingAssertion,
   objectKeyAssertion,
   objectKeysAssertion,
+  objectKeysMatchAssertion,
+  objectKeysSatisfyAssertion,
   objectSizeAssertion,
   setContainsAssertion,
   setDifferenceEqualityAssertion,
@@ -283,6 +295,21 @@ export const SyncCollectionAssertions = [
   collectionSizeGreaterThanAssertion,
   collectionSizeLessThanAssertion,
   collectionSizeBetweenAssertion,
+  // Collection value assertions (Map/Set/Array)
+  collectionValuesSatisfyAssertion,
+  collectionValuesExhaustivelySatisfyAssertion,
+  collectionHasValueSatisfyingAssertion,
+  collectionHasValueExhaustivelySatisfyingAssertion,
+  // Map key assertions
+  mapKeysSatisfyAssertion,
+  mapKeysExhaustivelySatisfyAssertion,
+  mapHasKeySatisfyingAssertion,
+  mapHasKeyExhaustivelySatisfyingAssertion,
+  // Object key assertions
+  objectKeysSatisfyAssertion,
+  objectHasKeySatisfyingAssertion,
+  objectKeysMatchAssertion,
+  objectHasKeyMatchingAssertion,
 ] as const;
 
 /**

package/src/error.ts

@@ -118,11 +118,8 @@ export class AssertionError extends NodeAssertionError {
    * @param value Some value
    * @returns `true` if `value` is an instance of `AssertionError`
    */
-  static isAssertionError(value: unknown): value is AssertionError {
-    return (
-      isA(value, NodeAssertionError) && hasOwn(value, kBupkisAssertionError)
-    );
-  }
+  static isAssertionError = (value: unknown): value is AssertionError =>
+    isA(value, NodeAssertionError) && hasOwn(value, kBupkisAssertionError);
 
   toJSON() {
     return {
@@ -148,9 +145,8 @@ export class BupkisError extends Error {
 
   override name = 'BupkisError';
 
-  static isBupkisError(err: unknown): err is BupkisError {
-    return isA(err, Error) && hasOwn(err, kBupkisError);
-  }
+  static isBupkisError = (err: unknown): err is BupkisError =>
+    isA(err, Error) && hasOwn(err, kBupkisError);
 }
 
 /**
@@ -175,11 +171,10 @@ export class AssertionImplementationError extends BupkisError {
     this.result = result;
   }
 
-  static isAssertionImplementationError(
+  static isAssertionImplementationError = (
     err: unknown,
-  ): err is AssertionImplementationError {
-    return isA(err, AssertionImplementationError);
-  }
+  ): err is AssertionImplementationError =>
+    isA(err, AssertionImplementationError);
 }
 
 /**
@@ -200,11 +195,8 @@ export class FailAssertionError extends AssertionError {
     super({ ...options, id: FAIL });
   }
 
-  static isFailAssertionError(err: unknown): err is FailAssertionError {
-    return (
-      isA(err, FailAssertionError) && hasOwn(err, kBupkisFailAssertionError)
-    );
-  }
+  static isFailAssertionError = (err: unknown): err is FailAssertionError =>
+    isA(err, FailAssertionError) && hasOwn(err, kBupkisFailAssertionError);
 }
 
 /**
@@ -259,11 +251,10 @@ export class NegatedAssertionError extends AssertionError {
 
   override name = 'NegatedAssertionError';
 
-  static isNegatedAssertionError(err: unknown): err is NegatedAssertionError {
-    return (
-      isA(err, AssertionError) && hasOwn(err, kBupkisNegatedAssertionError)
-    );
-  }
+  static isNegatedAssertionError = (
+    err: unknown,
+  ): err is NegatedAssertionError =>
+    isA(err, AssertionError) && hasOwn(err, kBupkisNegatedAssertionError);
 }
 
 /**

package/src/expect.ts

@@ -1,4 +1,4 @@
-import createDebug from 'debug';
+import { createDebug } from 'obug';
 import { inspect } from 'util';
 
 import {

package/src/guards.ts

@@ -118,9 +118,8 @@ export const isStandardSchema = (value: unknown): value is StandardSchemaV1 => {
  * @param value Value to test
  * @returns `true` if the value is a plain object, `false` otherwise
  */
-export const isObject = (value: unknown): value is NonNullable<object> => {
-  return typeof value === 'object' && value !== null && !isArray(value);
-};
+export const isObject = (value: unknown): value is NonNullable<object> =>
+  typeof value === 'object' && value !== null && !isArray(value);
 
 /**
  * Checks if a value is "promise-like", meaning it is a "thenable" object.
@@ -157,7 +156,7 @@ export const isConstructible = (fn: unknown): fn is Constructor => {
   }
   try {
     // this will throw if there is no `[[construct]]` slot.. or so I've heard.
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-call, custom/require-function-tag-in-arrow-functions
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @bupkis/require-function-tag-in-arrow-functions
     new new Proxy(fn as any, { construct: () => ({}) })();
     return true;
   } catch {
@@ -287,9 +286,7 @@ export const isPhrase = (
 export const isA = <T extends Constructor>(
   value: unknown,
   ctor: T,
-): value is InstanceType<T> => {
-  return isNonNullObject(value) && value instanceof ctor;
-};
+): value is InstanceType<T> => isNonNullObject(value) && value instanceof ctor;
 
 /**
  * Type guard for Error instances.
@@ -352,10 +349,7 @@ export const isError =
  */
 export const isExpectItExecutor = <Subject extends z.ZodType = z.ZodUnknown>(
   value: unknown,
-): value is ExpectItExecutor<Subject> => {
-  return (
-    isFunction(value) &&
-    kExpectIt in value &&
-    (value as unknown as Record<symbol, unknown>)[kExpectIt] === true
-  );
-};
+): value is ExpectItExecutor<Subject> =>
+  isFunction(value) &&
+  kExpectIt in value &&
+  (value as unknown as Record<symbol, unknown>)[kExpectIt] === true;

package/src/internal-schema.ts

@@ -232,11 +232,8 @@ const AssertionPartsSchema = z
  * @returns `true` if value is an AssertionFailure
  * @internal
  */
-export const isAssertionFailure = (
-  value: unknown,
-): value is AssertionFailure => {
-  return AssertionFailureSchema.safeParse(value).success;
-};
+export const isAssertionFailure = (value: unknown): value is AssertionFailure =>
+  AssertionFailureSchema.safeParse(value).success;
 
 /**
  * Type guard for an {@link AssertionParseRequest}.
@@ -248,9 +245,8 @@ export const isAssertionFailure = (
  */
 export const isAssertionParseRequest = (
   value: unknown,
-): value is AssertionParseRequest => {
-  return AssertionParseRequestSchema.safeParse(value).success;
-};
+): value is AssertionParseRequest =>
+  AssertionParseRequestSchema.safeParse(value).success;
 
 /**
  * Schema for the input parameters of {@link createAssertion}.

package/src/metadata.ts

@@ -47,8 +47,7 @@ const PhraseLiteralMetadataSchema = z.object({
 /**
  * Final schema for Bupkis registry
  */
-// TODO: Figure out how to make this rule allow type-only usage. Or just export it and tag it.
-
+// eslint-disable-next-line no-useless-assignment
 const _BupkisRegistrySchema = z.union([
   z.object({ ...BaseBupkisMetadataSchema.shape }),
   z.object({

package/src/snapshot/adapter.ts

@@ -272,6 +272,5 @@ export type SnapshotSerializer = (value: unknown) => string;
  */
 export const isTestContext = (
   value: unknown,
-): value is Record<string, unknown> => {
-  return typeof value === 'object' && value !== null;
-};
+): value is Record<string, unknown> =>
+  typeof value === 'object' && value !== null;

package/src/snapshot/adapters/fallback.ts

@@ -360,10 +360,9 @@ export class FallbackAdapter implements SnapshotAdapter {
    * @param context - Test context or snapshot name
    * @returns `true` for strings or objects
    */
-  canHandle(context: unknown): boolean {
+  canHandle = (context: unknown): boolean =>
     // Fallback handles strings (explicit names) and objects (Mocha)
-    return typeof context === 'string' || typeof context === 'object';
-  }
+    typeof context === 'string' || typeof context === 'object';
 
   /**
    * Extract snapshot context from Mocha context or string name.

package/src/snapshot/adapters/node-test.ts

@@ -252,16 +252,13 @@ const getTestFilePathFromStack = (): string => {
  * @param value - Value to check
  * @returns `true` if value looks like a node:test context
  */
-const looksLikeNodeTestContext = (value: unknown): boolean => {
-  return (
-    isTestContext(value) &&
-    'name' in value &&
-    typeof value.name === 'string' &&
-    'assert' in value &&
-    typeof value.assert === 'object' &&
-    value.assert !== null
-  );
-};
+const looksLikeNodeTestContext = (value: unknown): boolean =>
+  isTestContext(value) &&
+  'name' in value &&
+  typeof value.name === 'string' &&
+  'assert' in value &&
+  typeof value.assert === 'object' &&
+  value.assert !== null;
 
 /**
  * Type guard for node:test context.
@@ -281,16 +278,13 @@ const looksLikeNodeTestContext = (value: unknown): boolean => {
  * @param value - Value to check
  * @returns `true` if value is a node:test context
  */
-const isNodeTestContext = (value: unknown): value is NodeTestContext => {
-  return (
-    isTestContext(value) &&
-    'assert' in value &&
-    typeof value.assert === 'object' &&
-    value.assert !== null &&
-    'snapshot' in value.assert &&
-    typeof (value.assert as NodeTestContext['assert']).snapshot === 'function'
-  );
-};
+const isNodeTestContext = (value: unknown): value is NodeTestContext =>
+  isTestContext(value) &&
+  'assert' in value &&
+  typeof value.assert === 'object' &&
+  value.assert !== null &&
+  'snapshot' in value.assert &&
+  typeof (value.assert as NodeTestContext['assert']).snapshot === 'function';
 
 /**
  * Check if we're running in node:test update mode.

package/src/snapshot/select-adapter.ts

@@ -63,9 +63,9 @@ const adapters: SnapshotAdapter[] = [
  * @function
  * @returns Read-only array of registered adapters
  */
-export const getRegisteredAdapters = (): ReadonlyArray<SnapshotAdapter> => {
-  return [...adapters];
-};
+export const getRegisteredAdapters = (): ReadonlyArray<SnapshotAdapter> => [
+  ...adapters,
+];
 
 /**
  * Register a custom snapshot adapter.

package/src/snapshot/serializer.ts

@@ -308,7 +308,6 @@ export const defaultSerializer = (
  * @param value - Value to serialize
  * @returns JSON string representation
  */
-export const nodeTestCompatibleSerializer = (value: unknown): string => {
+export const nodeTestCompatibleSerializer = (value: unknown): string =>
   // Node:test expects the same format as our default serializer
-  return defaultSerializer(value);
-};
+  defaultSerializer(value);

package/src/types.ts

@@ -48,7 +48,6 @@ import type {
   PhraseLiteralSlot,
 } from './assertion/assertion-types.js';
 import type { StandardSchemaV1 } from './standard-schema.js';
-import type { ValueToSchemaOptions } from './value-to-schema.js';
 
 import { type kExpectIt } from './constant.js';
 
@@ -110,63 +109,6 @@ export interface BaseExpect {
   fail: FailFn;
 }
 
-/**
- * Configuration for valueToSchema benchmark generation.
- */
-export interface BenchmarkConfig {
-  /** Optional filter for input categories */
-  categories?: string[];
-  /** Complexity levels to test */
-  complexityLevels: ComplexityLevel[];
-  /** Number of benchmark iterations (1-10000) */
-  iterations: number;
-  /** ValueToSchemaOptions combinations to test */
-  options?: Partial<ValueToSchemaOptions>[];
-  /** Number of test data samples to generate (10-10000) */
-  sampleSize: number;
-  /** Benchmark timeout in milliseconds (1000-300000) */
-  timeout: number;
-  /** Number of warmup iterations (1-100) */
-  warmupIterations: number;
-}
-
-/**
- * Type representing a dot-notation or bracket-notation keypath for accessing
- * nested object properties. Uses recursive template literal types to validate
- * keypath syntax.
- *
- * Supports paths like:
- *
- * - 'foo.bar'
- * - 'foo[0]'
- * - 'foo["bar-baz"]'
- * - 'foo.bar[1].baz'
- *
- * @public
- */
-
-/**
- * Complete benchmark result.
- */
-export interface BenchmarkResult {
-  /** Computed insights and bottleneck identification */
-  analysis: PerformanceAnalysis;
-  /** Environment details when benchmark was run */
-  executionContext: ExecutionContext;
-  /** Total execution time in milliseconds */
-  executionTime: number;
-  /** Metadata about the benchmark run */
-  metadata: {
-    nodeVersion: string;
-    timestamp: string;
-    version: string;
-  };
-  /** Individual measurement results */
-  results: PerformanceMetrics[];
-  /** Benchmark suite identifier */
-  suiteId: string;
-}
-
 export type * from './assertion/assertion-types.js';
 export type { StandardSchemaV1 };
 
@@ -225,11 +167,6 @@ export interface Bupkis<
   >;
 }
 
-/**
- * Complexity levels for test data generation.
- */
-export type ComplexityLevel = 'complex' | 'medium' | 'simple';
-
 /**
  * Helper type to concatenate two tuples
  *
@@ -258,34 +195,6 @@ export type DefFromZodType<T extends z.core.$ZodType | z.ZodType> =
       ? T['_zod']['def']
       : never;
 
-/**
- * Execution context for benchmark runs.
- */
-export interface ExecutionContext {
-  /** CPU model */
-  cpuModel: string;
-  /** Total memory */
-  memoryTotal: number;
-  /** Node.js version */
-  nodeVersion: string;
-  /** Platform information */
-  platform: string;
-}
-
-/**
- * Execution time statistics.
- */
-export interface ExecutionTimeStats {
-  /** Mean execution time */
-  mean: number;
-  /** Median execution time */
-  median: number;
-  /** 95th percentile execution time */
-  p95: number;
-  /** 99th percentile execution time */
-  p99: number;
-}
-
 /**
  * The main synchronous assertion function.
  *
@@ -847,9 +756,8 @@ export type MapExpectSlots<Parts extends readonly AssertionPart[]> =
           : AssertionSlot<First> extends PhraseLiteralChoiceSlot<
                 infer StringLiterals
               >
-            ?
-                | ArrayValues<StringLiterals>
-                | Negation<ArrayValues<StringLiterals>>
+            ? | ArrayValues<StringLiterals>
+              | Negation<ArrayValues<StringLiterals>>
             : AssertionSlot<First> extends z.ZodType
               ? z.infer<AssertionSlot<First>>
               : never,
@@ -857,23 +765,6 @@ export type MapExpectSlots<Parts extends readonly AssertionPart[]> =
       ]
     : readonly [];
 
-/**
- * @groupDescription Benchmark Types
- * Types for valueToSchema() benchmark functionality.
- */
-
-/**
- * Memory usage statistics.
- */
-export interface MemoryStats {
-  /** External memory */
-  external: number;
-  /** Total heap memory */
-  heapTotal: number;
-  /** Heap memory used */
-  heapUsed: number;
-}
-
 /**
  * Makes tuple types accept both mutable and readonly variants.
  *
@@ -937,57 +828,6 @@ export type MutableOrReadonly<Tuple extends readonly unknown[]> =
  */
 export type Negation<S extends string> = `not ${S}`;
 
-/**
- * Performance analysis results.
- */
-export interface PerformanceAnalysis {
-  /** Identified bottlenecks */
-  bottlenecks: Array<{
-    category: string;
-    impact: 'high' | 'low' | 'medium';
-    opsPerSecond: number;
-    reason: string;
-  }>;
-  /** Statistical outliers */
-  outliers: Array<{
-    category: string;
-    deviation: number;
-    options: ValueToSchemaOptions;
-    value: number;
-  }>;
-  /** Summary statistics */
-  summary: {
-    averageOpsPerSecond: number;
-    fastestCategory: string;
-    slowestCategory: string;
-    totalExecutionTime: number;
-  };
-  /** Performance trends */
-  trends: Array<{
-    description: string;
-    factor: string;
-    impact: number;
-  }>;
-}
-
-/**
- * Performance metrics for a benchmark run.
- */
-export interface PerformanceMetrics {
-  /** Timing statistics */
-  executionTime: ExecutionTimeStats;
-  /** Category of input being measured */
-  inputCategory: string;
-  /** Memory allocation data (if available) */
-  memoryUsage?: MemoryStats;
-  /** Throughput measurement (operations per second) */
-  operationsPerSecond: number;
-  /** Configuration used for this measurement */
-  options: ValueToSchemaOptions;
-  /** When measurement was taken */
-  timestamp: Date;
-}
-
 /**
  * Converts `AssertionParts` to complete function parameter types for expect
  * functions.