bupkis 0.18.3 → 1.0.0

package/dist/snapshot/adapters/node-test.js

@@ -0,0 +1,293 @@
+/**
+ * Adapter for node:test's built-in snapshot support.
+ *
+ * Node.js native test runner includes snapshot testing capabilities as of
+ * Node.js v22. This adapter delegates to node:test's native `assert.snapshot()`
+ * function while providing the unified BUPKIS snapshot interface.
+ *
+ * @packageDocumentation
+ * @see https://nodejs.org/api/test.html#snapshots
+ */
+import { AssertionError as NodeTestAssertionError } from 'node:assert';
+import { inspect } from 'node:util';
+import { isA, isError } from "../../guards.js";
+import { isTestContext } from "../adapter.js";
+import { assertNodeVersion } from "../node-version.js";
+import { defaultSerializer } from "../serializer.js";
+/**
+ * Adapter for node:test snapshot support.
+ *
+ * This adapter leverages node:test's native snapshot functionality while
+ * providing the unified BUPKIS snapshot interface. It's the preferred adapter
+ * when running tests with node:test.
+ *
+ * **Features:**
+ *
+ * - Delegates to native `assert.snapshot()`
+ * - Supports custom serializers
+ * - Automatically detects update mode from CLI flags
+ * - Zero configuration required
+ *
+ * **Detection:** The adapter detects node:test by checking for
+ * `context.assert.snapshot`.
+ *
+ * **Update Mode:** Respects the `--test-update-snapshots` flag.
+ *
+ * @example
+ *
+ * ```typescript
+ * import test from 'node:test';
+ * import { expect } from 'bupkis';
+ *
+ * test('renders component', (t) => {
+ *   const output = render(<MyComponent />);
+ *   expect(output, 'to match snapshot', t);
+ * });
+ * ```
+ *
+ * @example
+ *
+ * ```typescript
+ * // With custom serializer
+ * test('redacts secrets', (t) => {
+ *   const data = { public: 'visible', secret: 'password123' };
+ *   expect(data, 'to match snapshot', t, {
+ *     serializer: (value: any) =>
+ *       JSON.stringify({ ...value, secret: '[REDACTED]' }, null, 2),
+ *   });
+ * });
+ * ```
+ */
+export class NodeTestAdapter {
+    /**
+     * Adapter name for identification and debugging.
+     */
+    name = 'node:test';
+    /**
+     * Check if this adapter can handle the given context.
+     *
+     * Returns `true` if the context has the structure of a node:test context,
+     * specifically checking for `context.assert.snapshot`.
+     *
+     * @param context - Test context to check
+     * @returns `true` if this is a node:test context
+     * @throws {Error} If running on Node.js < 22 with a node:test context
+     */
+    canHandle(context) {
+        if (looksLikeNodeTestContext(context) && !isNodeTestContext(context)) {
+            assertNodeVersion();
+        }
+        return isNodeTestContext(context);
+    }
+    /**
+     * Extract snapshot context from node:test context.
+     *
+     * Extracts:
+     *
+     * - **testPath**: The test name from `context.name`
+     * - **filePath**: Extracted from stack trace
+     * - **isUpdateMode**: Detected from `--test-update-snapshots` flag
+     *
+     * @param context - Node:test context object
+     * @returns Normalized snapshot context
+     * @throws {TypeError} If context is not a valid node:test context
+     */
+    getContext(context) {
+        if (!isNodeTestContext(context)) {
+            throw new TypeError('Invalid node:test context');
+        }
+        return {
+            filePath: getTestFilePathFromStack(),
+            isUpdateMode: isNodeTestUpdateMode(),
+            testPath: context.name,
+        };
+    }
+    /**
+     * Perform snapshot assertion using node:test's native functionality.
+     *
+     * This method delegates to `context.assert.snapshot()`, which handles:
+     *
+     * - Snapshot file creation and management
+     * - Snapshot comparison
+     * - Update mode behavior
+     * - Error messages and diffs
+     *
+     * If a custom serializer is provided in options, it will be passed to
+     * node:test as a serializer function.
+     *
+     * @example
+     *
+     * ```typescript
+     * const adapter = new NodeTestAdapter();
+     * adapter.assertSnapshot({ foo: 'bar' }, testContext);
+     * ```
+     *
+     * @param value - Value to snapshot
+     * @param context - Node:test context object
+     * @param options - Optional serialization options
+     * @throws {TypeError} If context is not a valid node:test context
+     * @throws {AssertionError} If snapshot doesn't match (via node:test)
+     */
+    validateSnapshot(value, context, options) {
+        if (!isNodeTestContext(context)) {
+            throw new TypeError('Invalid node:test context');
+        }
+        // Use custom serializer if provided, otherwise use default serializer
+        // to handle circular references and special types
+        const serializers = options?.serializer
+            ? [options.serializer]
+            : [defaultSerializer];
+        try {
+            // Build snapshot options - include hint as name if provided
+            const snapshotOptions = { serializers };
+            if (options?.hint) {
+                snapshotOptions.name = options.hint;
+            }
+            context.assert.snapshot(value, snapshotOptions);
+        }
+        catch (err) {
+            if (isNodeAssertionError(err)) {
+                return {
+                    actual: err.actual,
+                    expected: err.expected,
+                    message: err.message,
+                };
+            }
+            if (isError(err)) {
+                return {
+                    message: err.message,
+                };
+            }
+            return {
+                message: inspect(err),
+            };
+        }
+    }
+}
+/**
+ * Extract the test file path from the stack trace.
+ *
+ * This is a fallback method used when the test context doesn't provide the file
+ * path directly. It searches the stack trace for lines that look like test file
+ * paths (containing `.test.` or `.spec.`).
+ *
+ * @example
+ *
+ * ```typescript
+ * // If called from /path/to/my.test.ts, returns '/path/to/my.test.ts'
+ * const filePath = getTestFilePathFromStack();
+ * ```
+ *
+ * @function
+ * @returns Absolute file path, or 'unknown' if not found
+ */
+const getTestFilePathFromStack = () => {
+    const stack = new Error().stack || '';
+    const lines = stack.split('\n');
+    // Look for first line that looks like a test file
+    for (const line of lines) {
+        const match = line.match(/\((.+\.(?:test|spec)\.[jt]s):\d+:\d+\)/);
+        if (match && match[1]) {
+            return match[1];
+        }
+    }
+    return 'unknown';
+};
+/**
+ * Check if a value looks like a node:test context (has `name` and `assert`
+ * properties).
+ *
+ * This is used to detect when someone is passing a node:test context on an
+ * older Node.js version that doesn't support `assert.snapshot`.
+ *
+ * @function
+ * @param value - Value to check
+ * @returns `true` if value looks like a node:test context
+ */
+const looksLikeNodeTestContext = (value) => 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.
+ *
+ * Checks if the given value is a valid node:test test context by verifying the
+ * presence of required properties.
+ *
+ * @example
+ *
+ * ```typescript
+ * if (isNodeTestContext(context)) {
+ *   context.assert.snapshot(value);
+ * }
+ * ```
+ *
+ * @function
+ * @param value - Value to check
+ * @returns `true` if value is a node:test context
+ */
+const isNodeTestContext = (value) => isTestContext(value) &&
+    'assert' in value &&
+    typeof value.assert === 'object' &&
+    value.assert !== null &&
+    'snapshot' in value.assert &&
+    typeof value.assert.snapshot === 'function';
+/**
+ * Check if we're running in node:test update mode.
+ *
+ * Node:test uses the `--test-update-snapshots` flag to indicate that snapshots
+ * should be updated rather than compared. This function also respects the
+ * `BUPKIS_UPDATE_SNAPSHOTS` environment variable for consistency with other
+ * adapters.
+ *
+ * This function checks:
+ *
+ * 1. `process.execArgv` (flags passed to Node.js)
+ * 2. `process.argv` (arguments passed to the script)
+ * 3. `BUPKIS_UPDATE_SNAPSHOTS` environment variable
+ *
+ * @example
+ *
+ * ```sh
+ * # These commands will trigger update mode:
+ * node --test --test-update-snapshots
+ * node --test-update-snapshots=true --test test.js
+ * BUPKIS_UPDATE_SNAPSHOTS=1 node --test
+ * ```
+ *
+ * @function
+ * @returns `true` if in update mode
+ */
+const isNodeTestUpdateMode = () => {
+    // Check for BUPKIS_UPDATE_SNAPSHOTS environment variable
+    if (process.env.BUPKIS_UPDATE_SNAPSHOTS === '1') {
+        return true;
+    }
+    // Check for --test-update-snapshots flag in exec args or argv
+    return (process.execArgv.some((arg) => arg === '--test-update-snapshots' ||
+        arg.startsWith('--test-update-snapshots=')) ||
+        process.argv.some((arg) => arg === '--test-update-snapshots' ||
+            arg.startsWith('--test-update-snapshots=')));
+};
+/**
+ * Singleton instance of the node:test adapter.
+ *
+ * This is the primary export and should be used for adapter registration.
+ *
+ * @example
+ *
+ * ```typescript
+ * import { nodeTestAdapter } from 'bupkis/snapshot';
+ * import { registerAdapter } from 'bupkis/snapshot';
+ *
+ * registerAdapter(nodeTestAdapter);
+ * ```
+ */
+export const nodeTestAdapter = new NodeTestAdapter();
+/**
+ * @function
+ */
+const isNodeAssertionError = (value) => isA(value, NodeTestAssertionError);
+//# sourceMappingURL=node-test.js.map

package/dist/snapshot/adapters/node-test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-test.js","sourceRoot":"","sources":["../../../src/snapshot/adapters/node-test.ts"],"names":[],"mappings":"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"}

package/dist/snapshot/index.cjs

@@ -0,0 +1,61 @@
+"use strict";
+/**
+ * Snapshot testing utilities for BUPKIS.
+ *
+ * This module provides unified snapshot testing across multiple test frameworks
+ * including node:test, Jest, Vitest, Mocha, and custom test runners.
+ *
+ * **Quick Start:**
+ *
+ * ```typescript
+ * import test from 'node:test';
+ * import { expect } from 'bupkis';
+ *
+ * test('component renders correctly', (t) => {
+ *   const output = renderComponent();
+ *   expect(output, 'to match snapshot', t);
+ * });
+ * ```
+ *
+ * **Key Features:**
+ *
+ * - Unified API across all frameworks
+ * - Automatic framework detection
+ * - Custom serialization support
+ * - Multiple snapshots per test
+ * - Chainable with other assertions
+ *
+ * @packageDocumentation
+ * @see {@link snapshotAssertion} for the main snapshot assertion
+ * @see {@link SnapshotAdapter} for custom adapter implementation
+ * @see {@link defaultSerializer} for serialization utilities
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nodeTestCompatibleSerializer = exports.defaultSerializer = exports.selectAdapter = exports.registerAdapter = exports.getRegisteredAdapters = exports.supportsNodeTestSnapshots = exports.MIN_NODE_MAJOR_VERSION = exports.getNodeMajorVersion = exports.assertNodeVersion = exports.nodeTestAdapter = exports.fallbackAdapter = exports.isTestContext = exports.SnapshotAssertions = exports.snapshotAssertion = void 0;
+// Snapshot assertion (re-export from assertion module for convenience)
+var snapshot_js_1 = require("../assertion/impl/snapshot.cjs");
+Object.defineProperty(exports, "snapshotAssertion", { enumerable: true, get: function () { return snapshot_js_1.snapshotAssertion; } });
+Object.defineProperty(exports, "SnapshotAssertions", { enumerable: true, get: function () { return snapshot_js_1.SnapshotAssertions; } });
+var adapter_js_1 = require("./adapter.cjs");
+Object.defineProperty(exports, "isTestContext", { enumerable: true, get: function () { return adapter_js_1.isTestContext; } });
+// Built-in adapters
+var fallback_js_1 = require("./adapters/fallback.cjs");
+Object.defineProperty(exports, "fallbackAdapter", { enumerable: true, get: function () { return fallback_js_1.fallbackAdapter; } });
+var node_test_js_1 = require("./adapters/node-test.cjs");
+Object.defineProperty(exports, "nodeTestAdapter", { enumerable: true, get: function () { return node_test_js_1.nodeTestAdapter; } });
+// Node.js version utilities
+var node_version_js_1 = require("./node-version.cjs");
+Object.defineProperty(exports, "assertNodeVersion", { enumerable: true, get: function () { return node_version_js_1.assertNodeVersion; } });
+Object.defineProperty(exports, "getNodeMajorVersion", { enumerable: true, get: function () { return node_version_js_1.getNodeMajorVersion; } });
+Object.defineProperty(exports, "MIN_NODE_MAJOR_VERSION", { enumerable: true, get: function () { return node_version_js_1.MIN_NODE_MAJOR_VERSION; } });
+Object.defineProperty(exports, "supportsNodeTestSnapshots", { enumerable: true, get: function () { return node_version_js_1.supportsNodeTestSnapshots; } });
+// Adapter selection
+var select_adapter_js_1 = require("./select-adapter.cjs");
+Object.defineProperty(exports, "getRegisteredAdapters", { enumerable: true, get: function () { return select_adapter_js_1.getRegisteredAdapters; } });
+Object.defineProperty(exports, "registerAdapter", { enumerable: true, get: function () { return select_adapter_js_1.registerAdapter; } });
+Object.defineProperty(exports, "selectAdapter", { enumerable: true, get: function () { return select_adapter_js_1.selectAdapter; } });
+// Serialization
+var serializer_js_1 = require("./serializer.cjs");
+Object.defineProperty(exports, "defaultSerializer", { enumerable: true, get: function () { return serializer_js_1.defaultSerializer; } });
+Object.defineProperty(exports, "nodeTestCompatibleSerializer", { enumerable: true, get: function () { return serializer_js_1.nodeTestCompatibleSerializer; } });
+//# sourceMappingURL=index.js.map

package/dist/snapshot/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/snapshot/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;;;AAEH,uEAAuE;AACvE,8DAIuC;AAHrC,gHAAA,iBAAiB,OAAA;AACjB,iHAAA,kBAAkB,OAAA;AAYpB,4CAA6C;AAApC,2GAAA,aAAa,OAAA;AAEtB,oBAAoB;AACpB,uDAA+E;AAAtE,8GAAA,eAAe,OAAA;AAExB,yDAAgF;AAAvE,+GAAA,eAAe,OAAA;AAExB,4BAA4B;AAC5B,sDAK2B;AAJzB,oHAAA,iBAAiB,OAAA;AACjB,sHAAA,mBAAmB,OAAA;AACnB,yHAAA,sBAAsB,OAAA;AACtB,4HAAA,yBAAyB,OAAA;AAG3B,oBAAoB;AACpB,0DAI6B;AAH3B,0HAAA,qBAAqB,OAAA;AACrB,oHAAA,eAAe,OAAA;AACf,kHAAA,aAAa,OAAA;AAGf,gBAAgB;AAChB,kDAIyB;AAHvB,kHAAA,iBAAiB,OAAA;AACjB,6HAAA,4BAA4B,OAAA"}

package/dist/snapshot/index.d.cts

@@ -0,0 +1,40 @@
+/**
+ * Snapshot testing utilities for BUPKIS.
+ *
+ * This module provides unified snapshot testing across multiple test frameworks
+ * including node:test, Jest, Vitest, Mocha, and custom test runners.
+ *
+ * **Quick Start:**
+ *
+ * ```typescript
+ * import test from 'node:test';
+ * import { expect } from 'bupkis';
+ *
+ * test('component renders correctly', (t) => {
+ *   const output = renderComponent();
+ *   expect(output, 'to match snapshot', t);
+ * });
+ * ```
+ *
+ * **Key Features:**
+ *
+ * - Unified API across all frameworks
+ * - Automatic framework detection
+ * - Custom serialization support
+ * - Multiple snapshots per test
+ * - Chainable with other assertions
+ *
+ * @packageDocumentation
+ * @see {@link snapshotAssertion} for the main snapshot assertion
+ * @see {@link SnapshotAdapter} for custom adapter implementation
+ * @see {@link defaultSerializer} for serialization utilities
+ */
+export { snapshotAssertion, SnapshotAssertions, type SnapshotAssertions as SnapshotAssertionsType, } from "../assertion/impl/snapshot.cjs";
+export type { SnapshotAdapter, SnapshotContext, SnapshotOptions, SnapshotSerializer, } from "./adapter.cjs";
+export { isTestContext } from "./adapter.cjs";
+export { fallbackAdapter, type FallbackAdapter } from "./adapters/fallback.cjs";
+export { nodeTestAdapter, type NodeTestAdapter } from "./adapters/node-test.cjs";
+export { assertNodeVersion, getNodeMajorVersion, MIN_NODE_MAJOR_VERSION, supportsNodeTestSnapshots, } from "./node-version.cjs";
+export { getRegisteredAdapters, registerAdapter, selectAdapter, } from "./select-adapter.cjs";
+export { defaultSerializer, nodeTestCompatibleSerializer, type SerializerOptions, } from "./serializer.cjs";
+//# sourceMappingURL=index.d.ts.map

package/dist/snapshot/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/snapshot/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAGH,OAAO,EACL,iBAAiB,EACjB,kBAAkB,EAClB,KAAK,kBAAkB,IAAI,sBAAsB,GAClD,uCAAsC;AAGvC,YAAY,EACV,eAAe,EACf,eAAe,EACf,eAAe,EACf,kBAAkB,GACnB,sBAAqB;AAEtB,OAAO,EAAE,aAAa,EAAE,sBAAqB;AAG7C,OAAO,EAAE,eAAe,EAAE,KAAK,eAAe,EAAE,gCAA+B;AAE/E,OAAO,EAAE,eAAe,EAAE,KAAK,eAAe,EAAE,iCAAgC;AAGhF,OAAO,EACL,iBAAiB,EACjB,mBAAmB,EACnB,sBAAsB,EACtB,yBAAyB,GAC1B,2BAA0B;AAG3B,OAAO,EACL,qBAAqB,EACrB,eAAe,EACf,aAAa,GACd,6BAA4B;AAG7B,OAAO,EACL,iBAAiB,EACjB,4BAA4B,EAC5B,KAAK,iBAAiB,GACvB,yBAAwB"}

package/dist/snapshot/index.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Snapshot testing utilities for BUPKIS.
+ *
+ * This module provides unified snapshot testing across multiple test frameworks
+ * including node:test, Jest, Vitest, Mocha, and custom test runners.
+ *
+ * **Quick Start:**
+ *
+ * ```typescript
+ * import test from 'node:test';
+ * import { expect } from 'bupkis';
+ *
+ * test('component renders correctly', (t) => {
+ *   const output = renderComponent();
+ *   expect(output, 'to match snapshot', t);
+ * });
+ * ```
+ *
+ * **Key Features:**
+ *
+ * - Unified API across all frameworks
+ * - Automatic framework detection
+ * - Custom serialization support
+ * - Multiple snapshots per test
+ * - Chainable with other assertions
+ *
+ * @packageDocumentation
+ * @see {@link snapshotAssertion} for the main snapshot assertion
+ * @see {@link SnapshotAdapter} for custom adapter implementation
+ * @see {@link defaultSerializer} for serialization utilities
+ */
+export { snapshotAssertion, SnapshotAssertions, type SnapshotAssertions as SnapshotAssertionsType, } from "../assertion/impl/snapshot.js";
+export type { SnapshotAdapter, SnapshotContext, SnapshotOptions, SnapshotSerializer, } from "./adapter.js";
+export { isTestContext } from "./adapter.js";
+export { fallbackAdapter, type FallbackAdapter } from "./adapters/fallback.js";
+export { nodeTestAdapter, type NodeTestAdapter } from "./adapters/node-test.js";
+export { assertNodeVersion, getNodeMajorVersion, MIN_NODE_MAJOR_VERSION, supportsNodeTestSnapshots, } from "./node-version.js";
+export { getRegisteredAdapters, registerAdapter, selectAdapter, } from "./select-adapter.js";
+export { defaultSerializer, nodeTestCompatibleSerializer, type SerializerOptions, } from "./serializer.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/snapshot/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/snapshot/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAGH,OAAO,EACL,iBAAiB,EACjB,kBAAkB,EAClB,KAAK,kBAAkB,IAAI,sBAAsB,GAClD,sCAAsC;AAGvC,YAAY,EACV,eAAe,EACf,eAAe,EACf,eAAe,EACf,kBAAkB,GACnB,qBAAqB;AAEtB,OAAO,EAAE,aAAa,EAAE,qBAAqB;AAG7C,OAAO,EAAE,eAAe,EAAE,KAAK,eAAe,EAAE,+BAA+B;AAE/E,OAAO,EAAE,eAAe,EAAE,KAAK,eAAe,EAAE,gCAAgC;AAGhF,OAAO,EACL,iBAAiB,EACjB,mBAAmB,EACnB,sBAAsB,EACtB,yBAAyB,GAC1B,0BAA0B;AAG3B,OAAO,EACL,qBAAqB,EACrB,eAAe,EACf,aAAa,GACd,4BAA4B;AAG7B,OAAO,EACL,iBAAiB,EACjB,4BAA4B,EAC5B,KAAK,iBAAiB,GACvB,wBAAwB"}

package/dist/snapshot/index.js

@@ -0,0 +1,44 @@
+/**
+ * Snapshot testing utilities for BUPKIS.
+ *
+ * This module provides unified snapshot testing across multiple test frameworks
+ * including node:test, Jest, Vitest, Mocha, and custom test runners.
+ *
+ * **Quick Start:**
+ *
+ * ```typescript
+ * import test from 'node:test';
+ * import { expect } from 'bupkis';
+ *
+ * test('component renders correctly', (t) => {
+ *   const output = renderComponent();
+ *   expect(output, 'to match snapshot', t);
+ * });
+ * ```
+ *
+ * **Key Features:**
+ *
+ * - Unified API across all frameworks
+ * - Automatic framework detection
+ * - Custom serialization support
+ * - Multiple snapshots per test
+ * - Chainable with other assertions
+ *
+ * @packageDocumentation
+ * @see {@link snapshotAssertion} for the main snapshot assertion
+ * @see {@link SnapshotAdapter} for custom adapter implementation
+ * @see {@link defaultSerializer} for serialization utilities
+ */
+// Snapshot assertion (re-export from assertion module for convenience)
+export { snapshotAssertion, SnapshotAssertions, } from "../assertion/impl/snapshot.js";
+export { isTestContext } from "./adapter.js";
+// Built-in adapters
+export { fallbackAdapter } from "./adapters/fallback.js";
+export { nodeTestAdapter } from "./adapters/node-test.js";
+// Node.js version utilities
+export { assertNodeVersion, getNodeMajorVersion, MIN_NODE_MAJOR_VERSION, supportsNodeTestSnapshots, } from "./node-version.js";
+// Adapter selection
+export { getRegisteredAdapters, registerAdapter, selectAdapter, } from "./select-adapter.js";
+// Serialization
+export { defaultSerializer, nodeTestCompatibleSerializer, } from "./serializer.js";
+//# sourceMappingURL=index.js.map

package/dist/snapshot/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/snapshot/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH,uEAAuE;AACvE,OAAO,EACL,iBAAiB,EACjB,kBAAkB,GAEnB,sCAAsC;AAUvC,OAAO,EAAE,aAAa,EAAE,qBAAqB;AAE7C,oBAAoB;AACpB,OAAO,EAAE,eAAe,EAAwB,+BAA+B;AAE/E,OAAO,EAAE,eAAe,EAAwB,gCAAgC;AAEhF,4BAA4B;AAC5B,OAAO,EACL,iBAAiB,EACjB,mBAAmB,EACnB,sBAAsB,EACtB,yBAAyB,GAC1B,0BAA0B;AAE3B,oBAAoB;AACpB,OAAO,EACL,qBAAqB,EACrB,eAAe,EACf,aAAa,GACd,4BAA4B;AAE7B,gBAAgB;AAChB,OAAO,EACL,iBAAiB,EACjB,4BAA4B,GAE7B,wBAAwB"}

package/dist/snapshot/node-version.cjs

@@ -0,0 +1,49 @@
+"use strict";
+/**
+ * Node.js version utilities for snapshot testing.
+ *
+ * @packageDocumentation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertNodeVersion = exports.supportsNodeTestSnapshots = exports.getNodeMajorVersion = exports.MIN_NODE_MAJOR_VERSION = void 0;
+/**
+ * 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.
+ */
+exports.MIN_NODE_MAJOR_VERSION = 22;
+/**
+ * Get the current Node.js major version.
+ *
+ * @function
+ * @returns Major version number (e.g., 20, 22, 24)
+ */
+const getNodeMajorVersion = () => {
+    const parts = process.versions.node.split('.');
+    return Number(parts[0]) || 0;
+};
+exports.getNodeMajorVersion = getNodeMajorVersion;
+/**
+ * Check if the current Node.js version supports snapshot testing with
+ * node:test.
+ *
+ * @returns `true` if Node.js version >= {@link MIN_NODE_MAJOR_VERSION}
+ */
+exports.supportsNodeTestSnapshots = (0, exports.getNodeMajorVersion)() >= exports.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}
+ */
+const assertNodeVersion = () => {
+    const major = (0, exports.getNodeMajorVersion)();
+    if (major < exports.MIN_NODE_MAJOR_VERSION) {
+        throw new Error(`Snapshot testing with node:test requires Node.js v${exports.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).`);
+    }
+};
+exports.assertNodeVersion = assertNodeVersion;
+//# sourceMappingURL=node-version.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"node-version.js","sourceRoot":"","sources":["../../src/snapshot/node-version.ts"],"names":[],"mappings":";AAAA;;;;GAIG;;;AAEH;;;;;GAKG;AACU,QAAA,sBAAsB,GAAG,EAAE,CAAC;AAEzC;;;;;GAKG;AACI,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;AAHW,QAAA,mBAAmB,uBAG9B;AAEF;;;;;GAKG;AACU,QAAA,yBAAyB,GACpC,IAAA,2BAAmB,GAAE,IAAI,8BAAsB,CAAC;AAElD;;;;;GAKG;AACI,MAAM,iBAAiB,GAAG,GAAS,EAAE;IAC1C,MAAM,KAAK,GAAG,IAAA,2BAAmB,GAAE,CAAC;IACpC,IAAI,KAAK,GAAG,8BAAsB,EAAE,CAAC;QACnC,MAAM,IAAI,KAAK,CACb,qDAAqD,8BAAsB,aAAa;YACtF,qBAAqB,OAAO,CAAC,QAAQ,CAAC,IAAI,IAAI;YAC9C,qIAAqI,CACxI,CAAC;IACJ,CAAC;AACH,CAAC,CAAC;AATW,QAAA,iBAAiB,qBAS5B"}

package/dist/snapshot/node-version.d.cts

@@ -0,0 +1,34 @@
+/**
+ * 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 declare const MIN_NODE_MAJOR_VERSION = 22;
+/**
+ * Get the current Node.js major version.
+ *
+ * @function
+ * @returns Major version number (e.g., 20, 22, 24)
+ */
+export declare const getNodeMajorVersion: () => number;
+/**
+ * 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 declare const supportsNodeTestSnapshots: boolean;
+/**
+ * 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 declare const assertNodeVersion: () => void;
+//# sourceMappingURL=node-version.d.ts.map

package/dist/snapshot/node-version.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-version.d.ts","sourceRoot":"","sources":["../../src/snapshot/node-version.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;;GAKG;AACH,eAAO,MAAM,sBAAsB,KAAK,CAAC;AAEzC;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,QAAO,MAGtC,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,yBAAyB,SACW,CAAC;AAElD;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,QAAO,IASpC,CAAC"}

package/dist/snapshot/node-version.d.ts

@@ -0,0 +1,34 @@
+/**
+ * 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 declare const MIN_NODE_MAJOR_VERSION = 22;
+/**
+ * Get the current Node.js major version.
+ *
+ * @function
+ * @returns Major version number (e.g., 20, 22, 24)
+ */
+export declare const getNodeMajorVersion: () => number;
+/**
+ * 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 declare const supportsNodeTestSnapshots: boolean;
+/**
+ * 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 declare const assertNodeVersion: () => void;
+//# sourceMappingURL=node-version.d.ts.map

package/dist/snapshot/node-version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-version.d.ts","sourceRoot":"","sources":["../../src/snapshot/node-version.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;;GAKG;AACH,eAAO,MAAM,sBAAsB,KAAK,CAAC;AAEzC;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,QAAO,MAGtC,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,yBAAyB,SACW,CAAC;AAElD;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,QAAO,IASpC,CAAC"}