bupkis 0.18.1 → 0.18.2

package/dist/snapshot/node-version.js

@@ -1,44 +0,0 @@
-/**
- * Node.js version utilities for snapshot testing.
- *
- * @packageDocumentation
- */
-/**
- * Minimum Node.js major version required for snapshot testing with node:test.
- *
- * Node.js v22 is the first version with stable `assert.snapshot()` support in
- * the native test runner.
- */
-export const MIN_NODE_MAJOR_VERSION = 22;
-/**
- * Get the current Node.js major version.
- *
- * @function
- * @returns Major version number (e.g., 20, 22, 24)
- */
-export const getNodeMajorVersion = () => {
-    const parts = process.versions.node.split('.');
-    return Number(parts[0]) || 0;
-};
-/**
- * Check if the current Node.js version supports snapshot testing with
- * node:test.
- *
- * @returns `true` if Node.js version >= {@link MIN_NODE_MAJOR_VERSION}
- */
-export const supportsNodeTestSnapshots = getNodeMajorVersion() >= MIN_NODE_MAJOR_VERSION;
-/**
- * Assert that the Node.js version supports snapshot testing.
- *
- * @function
- * @throws {Error} If Node.js version is less than {@link MIN_NODE_MAJOR_VERSION}
- */
-export const assertNodeVersion = () => {
-    const major = getNodeMajorVersion();
-    if (major < MIN_NODE_MAJOR_VERSION) {
-        throw new Error(`Snapshot testing with node:test requires Node.js v${MIN_NODE_MAJOR_VERSION} or later. ` +
-            `Current version: v${process.versions.node}. ` +
-            `Please upgrade Node.js or use a different snapshot adapter (e.g., pass an explicit snapshot name string instead of a test context).`);
-    }
-};
-//# sourceMappingURL=node-version.js.map

package/dist/snapshot/node-version.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"node-version.js","sourceRoot":"","sources":["../../src/snapshot/node-version.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;;GAKG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAG,EAAE,CAAC;AAEzC;;;;;GAKG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,GAAW,EAAE;IAC9C,MAAM,KAAK,GAAG,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IAC/C,OAAO,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;AAC/B,CAAC,CAAC;AAEF;;;;;GAKG;AACH,MAAM,CAAC,MAAM,yBAAyB,GACpC,mBAAmB,EAAE,IAAI,sBAAsB,CAAC;AAElD;;;;;GAKG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,GAAS,EAAE;IAC1C,MAAM,KAAK,GAAG,mBAAmB,EAAE,CAAC;IACpC,IAAI,KAAK,GAAG,sBAAsB,EAAE,CAAC;QACnC,MAAM,IAAI,KAAK,CACb,qDAAqD,sBAAsB,aAAa;YACtF,qBAAqB,OAAO,CAAC,QAAQ,CAAC,IAAI,IAAI;YAC9C,qIAAqI,CACxI,CAAC;IACJ,CAAC;AACH,CAAC,CAAC"}

package/dist/snapshot/select-adapter.cjs

@@ -1,170 +0,0 @@
-"use strict";
-/**
- * Adapter selection logic for choosing the appropriate snapshot adapter.
- *
- * This module manages the registry of snapshot adapters and provides logic for
- * selecting the correct adapter based on the test context.
- *
- * @packageDocumentation
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.selectAdapter = exports.registerAdapter = exports.getRegisteredAdapters = void 0;
-const fallback_js_1 = require("./adapters/fallback.cjs");
-const node_test_js_1 = require("./adapters/node-test.cjs");
-/**
- * Registered adapters in priority order.
- *
- * Adapters are checked in order, and the first adapter that can handle the
- * context is selected. The fallback adapter should always be last as it accepts
- * most inputs.
- *
- * **Default order:**
- *
- * 1. Node:test adapter (most specific)
- * 2. Fallback adapter (always matches)
- */
-const adapters = [
-    node_test_js_1.nodeTestAdapter,
-    // jestVitestAdapter will be added in Phase 2
-    fallback_js_1.fallbackAdapter, // Always last
-];
-/**
- * Get all registered adapters (for debugging).
- *
- * Returns a read-only copy of the adapter list in priority order. This is
- * useful for debugging adapter selection or verifying that custom adapters have
- * been registered correctly.
- *
- * @example
- *
- * ```typescript
- * import { getRegisteredAdapters } from 'bupkis/snapshot';
- *
- * const adapters = getRegisteredAdapters();
- * console.log(
- *   'Registered adapters:',
- *   adapters.map((a) => a.name),
- * );
- * // Output: ['node:test', 'fallback']
- * ```
- *
- * @example
- *
- * ```typescript
- * // After registering custom adapter
- * registerAdapter(customAdapter, 0);
- * const adapters = getRegisteredAdapters();
- * console.log(adapters.map((a) => a.name));
- * // Output: ['my-custom', 'node:test', 'fallback']
- * ```
- *
- * @function
- * @returns Read-only array of registered adapters
- */
-const getRegisteredAdapters = () => {
-    return [...adapters];
-};
-exports.getRegisteredAdapters = getRegisteredAdapters;
-/**
- * Register a custom snapshot adapter.
- *
- * This allows plugins or custom code to add new snapshot adapters for
- * frameworks not supported out of the box.
- *
- * **Important:** If an adapter with the same name is already registered, it
- * will be removed before the new adapter is inserted.
- *
- * @example
- *
- * ```typescript
- * import { registerAdapter } from 'bupkis/snapshot';
- *
- * const customAdapter = {
- *   name: 'my-framework',
- *   canHandle: (context) => {
- *     return (
- *       context &&
- *       typeof context === 'object' &&
- *       'myFrameworkMarker' in context
- *     );
- *   },
- *   getContext: (context) => {
- *     // Extract context from custom framework
- *   },
- *   assertSnapshot: (value, context, options) => {
- *     // Perform snapshot assertion
- *   },
- * };
- *
- * // Register with high priority (before node:test)
- * registerAdapter(customAdapter, 0);
- * ```
- *
- * @example
- *
- * ```typescript
- * // Register Jest adapter (Phase 2)
- * import { jestAdapter } from './adapters/jest.js';
- * registerAdapter(jestAdapter, 1); // After node:test, before fallback
- * ```
- *
- * @function
- * @param adapter - Custom adapter to register
- * @param priority - Priority index (lower = higher priority). Defaults to
- *   inserting before fallback.
- */
-const registerAdapter = (adapter, priority = adapters.length - 1) => {
-    // Remove if already registered
-    const index = adapters.findIndex((a) => a.name === adapter.name);
-    if (index !== -1) {
-        adapters.splice(index, 1);
-    }
-    // Insert at specified priority
-    adapters.splice(priority, 0, adapter);
-};
-exports.registerAdapter = registerAdapter;
-/**
- * Select the appropriate snapshot adapter for the given context.
- *
- * Iterates through registered adapters in priority order and returns the first
- * adapter whose `canHandle()` method returns `true` for the context.
- *
- * Since the fallback adapter is always last and accepts most inputs, this
- * function is guaranteed to return a valid adapter.
- *
- * @example
- *
- * ```typescript
- * import test from 'node:test';
- * import { selectAdapter } from 'bupkis/snapshot';
- *
- * test('my test', (t) => {
- *   const adapter = selectAdapter(t);
- *   console.log(adapter.name); // 'node:test'
- *   adapter.assertSnapshot({ foo: 'bar' }, t);
- * });
- * ```
- *
- * @example
- *
- * ```typescript
- * // With explicit name (selects fallback)
- * const adapter = selectAdapter('my-snapshot-name');
- * console.log(adapter.name); // 'fallback'
- * ```
- *
- * @function
- * @param context - Test context object or explicit snapshot name
- * @returns Adapter that can handle the context
- */
-const selectAdapter = (context) => {
-    for (const adapter of adapters) {
-        if (adapter.canHandle(context)) {
-            return adapter;
-        }
-    }
-    // This should never happen since fallback always handles
-    return fallback_js_1.fallbackAdapter;
-};
-exports.selectAdapter = selectAdapter;
-//# sourceMappingURL=select-adapter.js.map

package/dist/snapshot/select-adapter.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"select-adapter.js","sourceRoot":"","sources":["../../src/snapshot/select-adapter.ts"],"names":[],"mappings":";AAAA;;;;;;;GAOG;;;AAIH,yDAAyD;AACzD,2DAA0D;AAE1D;;;;;;;;;;;GAWG;AACH,MAAM,QAAQ,GAAsB;IAClC,8BAAe;IACf,6CAA6C;IAC7C,6BAAe,EAAE,cAAc;CAChC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACI,MAAM,qBAAqB,GAAG,GAAmC,EAAE;IACxE,OAAO,CAAC,GAAG,QAAQ,CAAC,CAAC;AACvB,CAAC,CAAC;AAFW,QAAA,qBAAqB,yBAEhC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACI,MAAM,eAAe,GAAG,CAC7B,OAAwB,EACxB,WAAmB,QAAQ,CAAC,MAAM,GAAG,CAAC,EAChC,EAAE;IACR,+BAA+B;IAC/B,MAAM,KAAK,GAAG,QAAQ,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACjE,IAAI,KAAK,KAAK,CAAC,CAAC,EAAE,CAAC;QACjB,QAAQ,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;IAC5B,CAAC;IAED,+BAA+B;IAC/B,QAAQ,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC,EAAE,OAAO,CAAC,CAAC;AACxC,CAAC,CAAC;AAZW,QAAA,eAAe,mBAY1B;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACI,MAAM,aAAa,GAAG,CAAC,OAAgB,EAAmB,EAAE;IACjE,KAAK,MAAM,OAAO,IAAI,QAAQ,EAAE,CAAC;QAC/B,IAAI,OAAO,CAAC,SAAS,CAAC,OAAO,CAAC,EAAE,CAAC;YAC/B,OAAO,OAAO,CAAC;QACjB,CAAC;IACH,CAAC;IAED,yDAAyD;IACzD,OAAO,6BAAe,CAAC;AACzB,CAAC,CAAC;AATW,QAAA,aAAa,iBASxB"}

package/dist/snapshot/select-adapter.d.cts

@@ -1,128 +0,0 @@
-/**
- * Adapter selection logic for choosing the appropriate snapshot adapter.
- *
- * This module manages the registry of snapshot adapters and provides logic for
- * selecting the correct adapter based on the test context.
- *
- * @packageDocumentation
- */
-import type { SnapshotAdapter } from "./adapter.cjs";
-/**
- * Get all registered adapters (for debugging).
- *
- * Returns a read-only copy of the adapter list in priority order. This is
- * useful for debugging adapter selection or verifying that custom adapters have
- * been registered correctly.
- *
- * @example
- *
- * ```typescript
- * import { getRegisteredAdapters } from 'bupkis/snapshot';
- *
- * const adapters = getRegisteredAdapters();
- * console.log(
- *   'Registered adapters:',
- *   adapters.map((a) => a.name),
- * );
- * // Output: ['node:test', 'fallback']
- * ```
- *
- * @example
- *
- * ```typescript
- * // After registering custom adapter
- * registerAdapter(customAdapter, 0);
- * const adapters = getRegisteredAdapters();
- * console.log(adapters.map((a) => a.name));
- * // Output: ['my-custom', 'node:test', 'fallback']
- * ```
- *
- * @function
- * @returns Read-only array of registered adapters
- */
-export declare const getRegisteredAdapters: () => ReadonlyArray<SnapshotAdapter>;
-/**
- * Register a custom snapshot adapter.
- *
- * This allows plugins or custom code to add new snapshot adapters for
- * frameworks not supported out of the box.
- *
- * **Important:** If an adapter with the same name is already registered, it
- * will be removed before the new adapter is inserted.
- *
- * @example
- *
- * ```typescript
- * import { registerAdapter } from 'bupkis/snapshot';
- *
- * const customAdapter = {
- *   name: 'my-framework',
- *   canHandle: (context) => {
- *     return (
- *       context &&
- *       typeof context === 'object' &&
- *       'myFrameworkMarker' in context
- *     );
- *   },
- *   getContext: (context) => {
- *     // Extract context from custom framework
- *   },
- *   assertSnapshot: (value, context, options) => {
- *     // Perform snapshot assertion
- *   },
- * };
- *
- * // Register with high priority (before node:test)
- * registerAdapter(customAdapter, 0);
- * ```
- *
- * @example
- *
- * ```typescript
- * // Register Jest adapter (Phase 2)
- * import { jestAdapter } from './adapters/jest.js';
- * registerAdapter(jestAdapter, 1); // After node:test, before fallback
- * ```
- *
- * @function
- * @param adapter - Custom adapter to register
- * @param priority - Priority index (lower = higher priority). Defaults to
- *   inserting before fallback.
- */
-export declare const registerAdapter: (adapter: SnapshotAdapter, priority?: number) => void;
-/**
- * Select the appropriate snapshot adapter for the given context.
- *
- * Iterates through registered adapters in priority order and returns the first
- * adapter whose `canHandle()` method returns `true` for the context.
- *
- * Since the fallback adapter is always last and accepts most inputs, this
- * function is guaranteed to return a valid adapter.
- *
- * @example
- *
- * ```typescript
- * import test from 'node:test';
- * import { selectAdapter } from 'bupkis/snapshot';
- *
- * test('my test', (t) => {
- *   const adapter = selectAdapter(t);
- *   console.log(adapter.name); // 'node:test'
- *   adapter.assertSnapshot({ foo: 'bar' }, t);
- * });
- * ```
- *
- * @example
- *
- * ```typescript
- * // With explicit name (selects fallback)
- * const adapter = selectAdapter('my-snapshot-name');
- * console.log(adapter.name); // 'fallback'
- * ```
- *
- * @function
- * @param context - Test context object or explicit snapshot name
- * @returns Adapter that can handle the context
- */
-export declare const selectAdapter: (context: unknown) => SnapshotAdapter;
-//# sourceMappingURL=select-adapter.d.ts.map

package/dist/snapshot/select-adapter.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"select-adapter.d.ts","sourceRoot":"","sources":["../../src/snapshot/select-adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,sBAAqB;AAuBpD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,eAAO,MAAM,qBAAqB,QAAO,aAAa,CAAC,eAAe,CAErE,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,eAAO,MAAM,eAAe,GAC1B,SAAS,eAAe,EACxB,WAAU,MAA4B,KACrC,IASF,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,eAAO,MAAM,aAAa,GAAI,SAAS,OAAO,KAAG,eAShD,CAAC"}

package/dist/snapshot/select-adapter.d.ts

@@ -1,128 +0,0 @@
-/**
- * Adapter selection logic for choosing the appropriate snapshot adapter.
- *
- * This module manages the registry of snapshot adapters and provides logic for
- * selecting the correct adapter based on the test context.
- *
- * @packageDocumentation
- */
-import type { SnapshotAdapter } from "./adapter.js";
-/**
- * Get all registered adapters (for debugging).
- *
- * Returns a read-only copy of the adapter list in priority order. This is
- * useful for debugging adapter selection or verifying that custom adapters have
- * been registered correctly.
- *
- * @example
- *
- * ```typescript
- * import { getRegisteredAdapters } from 'bupkis/snapshot';
- *
- * const adapters = getRegisteredAdapters();
- * console.log(
- *   'Registered adapters:',
- *   adapters.map((a) => a.name),
- * );
- * // Output: ['node:test', 'fallback']
- * ```
- *
- * @example
- *
- * ```typescript
- * // After registering custom adapter
- * registerAdapter(customAdapter, 0);
- * const adapters = getRegisteredAdapters();
- * console.log(adapters.map((a) => a.name));
- * // Output: ['my-custom', 'node:test', 'fallback']
- * ```
- *
- * @function
- * @returns Read-only array of registered adapters
- */
-export declare const getRegisteredAdapters: () => ReadonlyArray<SnapshotAdapter>;
-/**
- * Register a custom snapshot adapter.
- *
- * This allows plugins or custom code to add new snapshot adapters for
- * frameworks not supported out of the box.
- *
- * **Important:** If an adapter with the same name is already registered, it
- * will be removed before the new adapter is inserted.
- *
- * @example
- *
- * ```typescript
- * import { registerAdapter } from 'bupkis/snapshot';
- *
- * const customAdapter = {
- *   name: 'my-framework',
- *   canHandle: (context) => {
- *     return (
- *       context &&
- *       typeof context === 'object' &&
- *       'myFrameworkMarker' in context
- *     );
- *   },
- *   getContext: (context) => {
- *     // Extract context from custom framework
- *   },
- *   assertSnapshot: (value, context, options) => {
- *     // Perform snapshot assertion
- *   },
- * };
- *
- * // Register with high priority (before node:test)
- * registerAdapter(customAdapter, 0);
- * ```
- *
- * @example
- *
- * ```typescript
- * // Register Jest adapter (Phase 2)
- * import { jestAdapter } from './adapters/jest.js';
- * registerAdapter(jestAdapter, 1); // After node:test, before fallback
- * ```
- *
- * @function
- * @param adapter - Custom adapter to register
- * @param priority - Priority index (lower = higher priority). Defaults to
- *   inserting before fallback.
- */
-export declare const registerAdapter: (adapter: SnapshotAdapter, priority?: number) => void;
-/**
- * Select the appropriate snapshot adapter for the given context.
- *
- * Iterates through registered adapters in priority order and returns the first
- * adapter whose `canHandle()` method returns `true` for the context.
- *
- * Since the fallback adapter is always last and accepts most inputs, this
- * function is guaranteed to return a valid adapter.
- *
- * @example
- *
- * ```typescript
- * import test from 'node:test';
- * import { selectAdapter } from 'bupkis/snapshot';
- *
- * test('my test', (t) => {
- *   const adapter = selectAdapter(t);
- *   console.log(adapter.name); // 'node:test'
- *   adapter.assertSnapshot({ foo: 'bar' }, t);
- * });
- * ```
- *
- * @example
- *
- * ```typescript
- * // With explicit name (selects fallback)
- * const adapter = selectAdapter('my-snapshot-name');
- * console.log(adapter.name); // 'fallback'
- * ```
- *
- * @function
- * @param context - Test context object or explicit snapshot name
- * @returns Adapter that can handle the context
- */
-export declare const selectAdapter: (context: unknown) => SnapshotAdapter;
-//# sourceMappingURL=select-adapter.d.ts.map

package/dist/snapshot/select-adapter.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"select-adapter.d.ts","sourceRoot":"","sources":["../../src/snapshot/select-adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,qBAAqB;AAuBpD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,eAAO,MAAM,qBAAqB,QAAO,aAAa,CAAC,eAAe,CAErE,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,eAAO,MAAM,eAAe,GAC1B,SAAS,eAAe,EACxB,WAAU,MAA4B,KACrC,IASF,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,eAAO,MAAM,aAAa,GAAI,SAAS,OAAO,KAAG,eAShD,CAAC"}

package/dist/snapshot/select-adapter.js

@@ -1,164 +0,0 @@
-/**
- * Adapter selection logic for choosing the appropriate snapshot adapter.
- *
- * This module manages the registry of snapshot adapters and provides logic for
- * selecting the correct adapter based on the test context.
- *
- * @packageDocumentation
- */
-import { fallbackAdapter } from "./adapters/fallback.js";
-import { nodeTestAdapter } from "./adapters/node-test.js";
-/**
- * Registered adapters in priority order.
- *
- * Adapters are checked in order, and the first adapter that can handle the
- * context is selected. The fallback adapter should always be last as it accepts
- * most inputs.
- *
- * **Default order:**
- *
- * 1. Node:test adapter (most specific)
- * 2. Fallback adapter (always matches)
- */
-const adapters = [
-    nodeTestAdapter,
-    // jestVitestAdapter will be added in Phase 2
-    fallbackAdapter, // Always last
-];
-/**
- * Get all registered adapters (for debugging).
- *
- * Returns a read-only copy of the adapter list in priority order. This is
- * useful for debugging adapter selection or verifying that custom adapters have
- * been registered correctly.
- *
- * @example
- *
- * ```typescript
- * import { getRegisteredAdapters } from 'bupkis/snapshot';
- *
- * const adapters = getRegisteredAdapters();
- * console.log(
- *   'Registered adapters:',
- *   adapters.map((a) => a.name),
- * );
- * // Output: ['node:test', 'fallback']
- * ```
- *
- * @example
- *
- * ```typescript
- * // After registering custom adapter
- * registerAdapter(customAdapter, 0);
- * const adapters = getRegisteredAdapters();
- * console.log(adapters.map((a) => a.name));
- * // Output: ['my-custom', 'node:test', 'fallback']
- * ```
- *
- * @function
- * @returns Read-only array of registered adapters
- */
-export const getRegisteredAdapters = () => {
-    return [...adapters];
-};
-/**
- * Register a custom snapshot adapter.
- *
- * This allows plugins or custom code to add new snapshot adapters for
- * frameworks not supported out of the box.
- *
- * **Important:** If an adapter with the same name is already registered, it
- * will be removed before the new adapter is inserted.
- *
- * @example
- *
- * ```typescript
- * import { registerAdapter } from 'bupkis/snapshot';
- *
- * const customAdapter = {
- *   name: 'my-framework',
- *   canHandle: (context) => {
- *     return (
- *       context &&
- *       typeof context === 'object' &&
- *       'myFrameworkMarker' in context
- *     );
- *   },
- *   getContext: (context) => {
- *     // Extract context from custom framework
- *   },
- *   assertSnapshot: (value, context, options) => {
- *     // Perform snapshot assertion
- *   },
- * };
- *
- * // Register with high priority (before node:test)
- * registerAdapter(customAdapter, 0);
- * ```
- *
- * @example
- *
- * ```typescript
- * // Register Jest adapter (Phase 2)
- * import { jestAdapter } from './adapters/jest.js';
- * registerAdapter(jestAdapter, 1); // After node:test, before fallback
- * ```
- *
- * @function
- * @param adapter - Custom adapter to register
- * @param priority - Priority index (lower = higher priority). Defaults to
- *   inserting before fallback.
- */
-export const registerAdapter = (adapter, priority = adapters.length - 1) => {
-    // Remove if already registered
-    const index = adapters.findIndex((a) => a.name === adapter.name);
-    if (index !== -1) {
-        adapters.splice(index, 1);
-    }
-    // Insert at specified priority
-    adapters.splice(priority, 0, adapter);
-};
-/**
- * Select the appropriate snapshot adapter for the given context.
- *
- * Iterates through registered adapters in priority order and returns the first
- * adapter whose `canHandle()` method returns `true` for the context.
- *
- * Since the fallback adapter is always last and accepts most inputs, this
- * function is guaranteed to return a valid adapter.
- *
- * @example
- *
- * ```typescript
- * import test from 'node:test';
- * import { selectAdapter } from 'bupkis/snapshot';
- *
- * test('my test', (t) => {
- *   const adapter = selectAdapter(t);
- *   console.log(adapter.name); // 'node:test'
- *   adapter.assertSnapshot({ foo: 'bar' }, t);
- * });
- * ```
- *
- * @example
- *
- * ```typescript
- * // With explicit name (selects fallback)
- * const adapter = selectAdapter('my-snapshot-name');
- * console.log(adapter.name); // 'fallback'
- * ```
- *
- * @function
- * @param context - Test context object or explicit snapshot name
- * @returns Adapter that can handle the context
- */
-export const selectAdapter = (context) => {
-    for (const adapter of adapters) {
-        if (adapter.canHandle(context)) {
-            return adapter;
-        }
-    }
-    // This should never happen since fallback always handles
-    return fallbackAdapter;
-};
-//# sourceMappingURL=select-adapter.js.map

package/dist/snapshot/select-adapter.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"select-adapter.js","sourceRoot":"","sources":["../../src/snapshot/select-adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,OAAO,EAAE,eAAe,EAAE,+BAA+B;AACzD,OAAO,EAAE,eAAe,EAAE,gCAAgC;AAE1D;;;;;;;;;;;GAWG;AACH,MAAM,QAAQ,GAAsB;IAClC,eAAe;IACf,6CAA6C;IAC7C,eAAe,EAAE,cAAc;CAChC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,GAAmC,EAAE;IACxE,OAAO,CAAC,GAAG,QAAQ,CAAC,CAAC;AACvB,CAAC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,CAC7B,OAAwB,EACxB,WAAmB,QAAQ,CAAC,MAAM,GAAG,CAAC,EAChC,EAAE;IACR,+BAA+B;IAC/B,MAAM,KAAK,GAAG,QAAQ,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACjE,IAAI,KAAK,KAAK,CAAC,CAAC,EAAE,CAAC;QACjB,QAAQ,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;IAC5B,CAAC;IAED,+BAA+B;IAC/B,QAAQ,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC,EAAE,OAAO,CAAC,CAAC;AACxC,CAAC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,OAAgB,EAAmB,EAAE;IACjE,KAAK,MAAM,OAAO,IAAI,QAAQ,EAAE,CAAC;QAC/B,IAAI,OAAO,CAAC,SAAS,CAAC,OAAO,CAAC,EAAE,CAAC;YAC/B,OAAO,OAAO,CAAC;QACjB,CAAC;IACH,CAAC;IAED,yDAAyD;IACzD,OAAO,eAAe,CAAC;AACzB,CAAC,CAAC"}