bupkis 0.18.1 → 0.18.2

package/dist/assertion/impl/sync-collection.cjs

@@ -1,856 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.collectionSizeBetweenAssertion = exports.collectionSizeLessThanAssertion = exports.collectionSizeGreaterThanAssertion = exports.mapEqualityAssertion = exports.mapEntryAssertion = exports.mapValueAssertion = exports.mapKeyAssertion = exports.setSymmetricDifferenceEqualityAssertion = exports.setDifferenceEqualityAssertion = exports.setIntersectionEqualityAssertion = exports.setUnionEqualityAssertion = exports.setDisjointAssertion = exports.setIntersectionAssertion = exports.setSupersetAssertion = exports.setSubsetAssertion = exports.setEqualityAssertion = exports.objectSizeAssertion = exports.objectExactKeyAssertion = exports.objectKeyAssertion = exports.objectKeysAssertion = exports.nonEmptyArrayAssertion = exports.arraySizeAssertion = exports.arrayItemSatisfiesAssertion = exports.arrayContainsAssertion = exports.emptySetAssertion = exports.setSizeAssertion = exports.setContainsAssertion = exports.emptyMapAssertion = exports.mapSizeAssertion = exports.mapContainsAssertion = void 0;
-// do not remove; otherwise zshy will not resolve the .d.ts file; it must be referenced directly
-// eslint-disable-next-line @typescript-eslint/triple-slash-reference
-/// <reference path="./shims.d.ts" />
-/**
- * Collection-based assertions for arrays, objects, Maps, and Sets.
- *
- * These assertions handle operations like containment, size checking, and
- * set-theoretic operations for various collection types including native
- * JavaScript collections and WeakMap/WeakSet.
- *
- * @packageDocumentation
- * @groupDescription Collection Assertions
- * Assertions for arrays, objects, Maps, Sets, and collection operations.
- *
- * @showGroup
- */
-const set_prototype_difference_1 = __importDefault(require("set.prototype.difference"));
-const set_prototype_intersection_1 = __importDefault(require("set.prototype.intersection"));
-const set_prototype_isdisjointfrom_1 = __importDefault(require("set.prototype.isdisjointfrom"));
-const set_prototype_issubsetof_1 = __importDefault(require("set.prototype.issubsetof"));
-const set_prototype_issupersetof_1 = __importDefault(require("set.prototype.issupersetof"));
-const set_prototype_symmetricdifference_1 = __importDefault(require("set.prototype.symmetricdifference"));
-const set_prototype_union_1 = __importDefault(require("set.prototype.union"));
-const zod_1 = require("zod");
-const guards_js_1 = require("../../guards.cjs");
-const schema_js_1 = require("../../schema.cjs");
-const util_js_1 = require("../../util.cjs");
-const value_to_schema_js_1 = require("../../value-to-schema.cjs");
-const create_js_1 = require("../create.cjs");
-const { hasOwn, keys } = Object;
-/**
- * Asserts that a Map or WeakMap contains a specific key. For WeakMap, the key
- * must be an object.
- *
- * @example
- *
- * ```ts
- * const map = new Map([['key', 'value']]);
- * expect(map, 'to contain', 'key'); // passes
- *
- * const obj = {};
- * const weakMap = new WeakMap([[obj, 'value']]);
- * expect(weakMap, 'to contain', obj); // passes
- * expect(weakMap, 'to contain', 'string'); // fails (not an object)
- * ```
- *
- * @group Collection Assertions
- * @bupkisAnchor map-to-contain-any
- * @bupkisAssertionCategory collections
- */
-exports.mapContainsAssertion = (0, create_js_1.createAssertion)([schema_js_1.AnyMapSchema, ['to contain', 'to include'], schema_js_1.UnknownSchema], (subject, key) => {
-    // WeakMap.has only works with object or symbol keys
-    let hasKey;
-    if (subject instanceof WeakMap) {
-        if (!(0, guards_js_1.isWeakKey)(key)) {
-            return {
-                message: `WeakMap keys must be objects or symbols, got ${typeof key}`,
-            };
-        }
-        hasKey = subject.has(key);
-    }
-    else {
-        hasKey = subject.has(key);
-    }
-    if (!hasKey) {
-        return {
-            actual: key,
-            expected: `key to exist in ${subject.constructor.name}`,
-            message: `Expected ${subject.constructor.name} to contain key`,
-        };
-    }
-});
-/**
- * Asserts that a Map has a specific size.
- *
- * @example
- *
- * ```ts
- * const map = new Map([
- *   ['a', 1],
- *   ['b', 2],
- * ]);
- * expect(map, 'to have size', 2); // passes
- * expect(map, 'to have size', 3); // fails
- * ```
- *
- * @group Collection Assertions
- * @bupkisAnchor map-to-have-size-nonnegative-integer
- * @bupkisAssertionCategory collections
- */
-exports.mapSizeAssertion = (0, create_js_1.createAssertion)([schema_js_1.MapSchema, 'to have size', schema_js_1.NonNegativeIntegerSchema], (_subject, expectedSize) => zod_1.z.map(zod_1.z.unknown(), zod_1.z.unknown()).refine((map) => map.size === expectedSize, {
-    error: `Expected Map to have size ${expectedSize}`,
-}));
-/**
- * Asserts that a Map is empty.
- *
- * @example
- *
- * ```ts
- * expect(new Map(), 'to be empty'); // passes
- * expect(new Map([['key', 'value']]), 'to be empty'); // fails
- * ```
- *
- * @group Collection Assertions
- * @bupkisAnchor map-to-be-empty
- * @bupkisAssertionCategory collections
- */
-exports.emptyMapAssertion = (0, create_js_1.createAssertion)([schema_js_1.MapSchema, 'to be empty'], schema_js_1.MapSchema.refine((map) => map.size === 0, {
-    error: 'Expected Map to be empty',
-}));
-/**
- * Asserts that a Set or WeakSet contains a specific value. For WeakSet, the
- * value must be an object.
- *
- * @example
- *
- * ```ts
- * const set = new Set(['a', 'b']);
- * expect(set, 'to contain', 'a'); // passes
- *
- * const obj = {};
- * const weakSet = new WeakSet([obj]);
- * expect(weakSet, 'to contain', obj); // passes
- * expect(weakSet, 'to contain', 'string'); // fails (not an object)
- * ```
- *
- * @group Collection Assertions
- * @bupkisAnchor set-to-contain-any
- * @bupkisAssertionCategory collections
- */
-exports.setContainsAssertion = (0, create_js_1.createAssertion)([schema_js_1.AnySetSchema, ['to contain', 'to include'], schema_js_1.UnknownSchema], (subject, value) => {
-    // WeakSet.has only works with object or symbol values
-    if (subject instanceof WeakSet && !(0, guards_js_1.isWeakKey)(value)) {
-        return {
-            message: `WeakSet values must be objects or symbols, got ${typeof value}`,
-        };
-    }
-    // At this point, if it's a WeakSet, we know value is a WeakKey
-    const hasValue = subject instanceof WeakSet
-        ? subject.has(value)
-        : subject.has(value);
-    if (!hasValue) {
-        return {
-            actual: value,
-            expected: `value to exist in ${subject.constructor.name}`,
-            message: `Expected ${subject.constructor.name} to contain value`,
-        };
-    }
-});
-/**
- * Asserts that a Set has a specific size.
- *
- * @example
- *
- * ```ts
- * const set = new Set(['a', 'b']);
- * expect(set, 'to have size', 2); // passes
- * expect(set, 'to have size', 3); // fails
- * ```
- *
- * @group Collection Assertions
- * @bupkisAnchor set-to-have-size-nonnegative-integer
- * @bupkisAssertionCategory collections
- */
-exports.setSizeAssertion = (0, create_js_1.createAssertion)([schema_js_1.SetSchema, 'to have size', schema_js_1.NonNegativeIntegerSchema], (_subject, expectedSize) => zod_1.z
-    .set(zod_1.z.unknown())
-    .min(expectedSize, { error: `Expected Set to have size ${expectedSize}` })
-    .max(expectedSize, {
-    error: `Expected Set to have size ${expectedSize}`,
-}));
-/**
- * Asserts that a Set is empty.
- *
- * @example
- *
- * ```ts
- * expect(new Set(), 'to be empty'); // passes
- * expect(new Set(['value']), 'to be empty'); // fails
- * ```
- *
- * @group Collection Assertions
- * @bupkisAnchor set-to-be-empty
- * @bupkisAssertionCategory collections
- */
-exports.emptySetAssertion = (0, create_js_1.createAssertion)([schema_js_1.SetSchema, 'to be empty'], schema_js_1.SetSchema.refine(({ size }) => size === 0, {
-    error: 'Expected Set to be empty',
-}));
-/**
- * Asserts that an array contains a specific value.
- *
- * @example
- *
- * ```ts
- * expect([1, 2, 3], 'to contain', 2); // passes
- * expect([1, 2, 3], 'to contain', 4); // fails
- * ```
- *
- * @group Collection Assertions
- * @bupkisAnchor array-to-contain-any
- * @bupkisAssertionCategory collections
- */
-exports.arrayContainsAssertion = (0, create_js_1.createAssertion)([schema_js_1.UnknownArraySchema, ['to contain', 'to include'], schema_js_1.UnknownSchema], (subject, value) => {
-    if (!subject.includes(value)) {
-        return {
-            message: `Expected array to contain value`,
-        };
-    }
-});
-/**
- * Asserts that an array contains an item that satisfies a given shape or
- * pattern. Uses partial matching semantics - the item only needs to match the
- * specified properties.
- *
- * @example
- *
- * ```ts
- * expect([{ a: 1, b: 2 }, { c: 3 }], 'to have item satisfying', { a: 1 }); // passes
- * expect([{ a: 1 }, { b: 2 }], 'to have an item satisfying', { c: 3 }); // fails
- * expect([1, 2, 3], 'to contain item satisfying', 2); // passes (exact match)
- * ```
- *
- * @group Collection Assertions
- * @bupkisAnchor array-to-have-item-satisfying
- * @bupkisAssertionCategory collections
- */
-exports.arrayItemSatisfiesAssertion = (0, create_js_1.createAssertion)([
-    schema_js_1.UnknownArraySchema,
-    [
-        'to have item satisfying',
-        'to have an item satisfying',
-        'to contain item satisfying',
-    ],
-    schema_js_1.UnknownSchema,
-], (subject, shape) => {
-    const schema = (0, value_to_schema_js_1.valueToSchema)(shape, value_to_schema_js_1.valueToSchemaOptionsForSatisfies);
-    for (const item of subject) {
-        const result = schema.safeParse(item);
-        if (result.success) {
-            return;
-        }
-    }
-    return {
-        message: `Expected array to contain an item satisfying the given shape`,
-    };
-});
-/**
- * Asserts that an array has a specific size.
- *
- * @example
- *
- * ```ts
- * expect([1, 2, 3], 'to have length', 3); // passes
- * expect([1, 2, 3], 'to have size', 2); // fails
- * ```
- *
- * @group Collection Assertions
- * @bupkisAnchor array-to-have-size-nonnegative-integer
- * @bupkisAssertionCategory collections
- */
-exports.arraySizeAssertion = (0, create_js_1.createAssertion)([
-    schema_js_1.UnknownArraySchema,
-    ['to have length', 'to have size'],
-    schema_js_1.NonNegativeIntegerSchema,
-], (_subject, expectedSize) => schema_js_1.UnknownArraySchema.min(expectedSize, {
-    error: `Expected array to have size ${expectedSize}}`,
-}).max(expectedSize, {
-    error: `Expected array to have size ${expectedSize}}`,
-}));
-/**
- * Asserts that an array is non-empty.
- *
- * @example
- *
- * ```ts
- * expect([1, 2, 3], 'to be non-empty'); // passes
- * expect([], 'to be non-empty'); // fails
- * ```
- *
- * @group Collection Assertions
- * @bupkisAnchor array-not-to-be-empty
- * @bupkisAssertionCategory collections
- */
-exports.nonEmptyArrayAssertion = (0, create_js_1.createAssertion)([schema_js_1.UnknownArraySchema, 'to be non-empty'], schema_js_1.UnknownArraySchema.min(1, { error: 'Expected array to be non-empty' }));
-/**
- * Asserts that an object has specific keys/properties.
- *
- * @example
- *
- * ```ts
- * expect({ a: 1, b: 2 }, 'to have keys', 'a', 'b'); // passes
- * expect({ a: 1 }, 'to have keys', 'a', 'b'); // fails
- * ```
- *
- * @group Collection Assertions
- * @bupkisAnchor object-to-have-keys-array
- * @bupkisAssertionCategory object
- */
-// TODO support keypaths, maybe.
-// TODO support `undefined` values (will require moving away from Zod schema)
-exports.objectKeysAssertion = (0, create_js_1.createAssertion)([
-    schema_js_1.NonCollectionObjectSchema,
-    [
-        'to have keys',
-        'to have properties',
-        'to have props',
-        'to contain keys',
-        'to contain properties',
-        'to contain props',
-        'to include keys',
-        'to include properties',
-        'to include props',
-    ],
-    zod_1.z.array(schema_js_1.PropertyKeySchema).nonempty(),
-], (_subject, keys) => schema_js_1.NonCollectionObjectSchema.superRefine((subject, ctx) => {
-    // iterate thru keys and add an issue for each missing
-    for (const k of keys) {
-        if (!hasOwn(subject, k)) {
-            ctx.addIssue({
-                code: 'custom',
-                input: subject,
-                message: `Expected object to contain key "${String(k)}"`,
-                params: { bupkisType: 'missing_key' },
-            });
-        }
-    }
-}));
-/**
- * Asserts that an object has a property at the specified keypath using dot or
- * bracket notation. Uses the `has()` function to traverse nested properties and
- * supports complex keypaths like 'foo.bar[0]["baz"]'.
- *
- * This assertion supports:
- *
- * - Dot notation: 'prop.nested'
- * - Bracket notation with numbers: 'arr[0]'
- * - Bracket notation with quoted strings: 'obj["key"]' or "obj['key']"
- * - Mixed notation: 'data.items[1].name'
- *
- * @example
- *
- * ```ts
- * const obj = {
- *   foo: { bar: [{ baz: 'value' }] },
- *   'kebab-case': 'works',
- * };
- *
- * expect(obj, 'to have key', 'foo.bar'); // passes
- * expect(obj, 'to have property', 'foo.bar[0].baz'); // passes
- * expect(obj, 'to have prop', 'foo["kebab-case"]'); // passes
- * expect(obj, 'to have key', 'nonexistent.path'); // fails
- * ```
- *
- * @group Collection Assertions
- * @bupkisAnchor object-to-have-key-string-number-symbol
- * @bupkisAssertionCategory object
- */
-exports.objectKeyAssertion = (0, create_js_1.createAssertion)([
-    schema_js_1.NonCollectionObjectSchema,
-    [
-        'to have key',
-        'to have property',
-        'to have prop',
-        'to contain key',
-        'to contain property',
-        'to contain prop',
-        'to include key',
-        'to include property',
-        'to include prop',
-    ],
-    schema_js_1.KeypathSchema,
-], (subject, keypath) => {
-    const result = (0, util_js_1.has)(subject, keypath);
-    if (!result) {
-        return {
-            actual: 'no such keypath',
-            expect: `to have keypath ${keypath}`,
-            message: `Expected object to contain keypath ${keypath}`,
-        };
-    }
-});
-/**
- * Asserts that an object has an exact property key without keypath traversal.
- * This assertion checks for direct properties on the object and supports
- * symbols and keys that would conflict with bracket/dot notation.
- *
- * Unlike `objectKeyAssertion`, this does not use the `has()` function and
- * therefore:
- *
- * - Does not support keypath traversal (no dots or brackets)
- * - Can check for symbol keys
- * - Can check for keys containing dots, brackets, or other special characters
- * - Only checks direct properties (no nested access)
- *
- * @example
- *
- * ```ts
- * const sym = Symbol('test');
- * const obj = {
- *   simple: 'value',
- *   'key.with.dots': 'direct property',
- *   'key[with]brackets': 'another direct property',
- *   [sym]: 'symbol value',
- * };
- *
- * expect(obj, 'to have exact key', 'simple'); // passes
- * expect(obj, 'to have exact property', 'key.with.dots'); // passes (literal key)
- * expect(obj, 'to have exact prop', 'key[with]brackets'); // passes (literal key)
- * expect(obj, 'to have exact key', sym); // passes (symbol key)
- *
- * // These would fail because they're not direct properties:
- * expect(obj, 'to have exact key', 'nested.path'); // fails (no keypath traversal)
- * ```
- *
- * @group Collection Assertions
- * @bupkisAnchor object-to-have-only-keys-array
- * @bupkisAssertionCategory object
- */
-exports.objectExactKeyAssertion = (0, create_js_1.createAssertion)([
-    schema_js_1.NonCollectionObjectSchema,
-    ['to have exact key', 'to have exact property', 'to have exact prop'],
-    schema_js_1.PropertyKeySchema,
-], (_, key) => schema_js_1.NonCollectionObjectSchema.transform((v) => ({ ...v })).refine((value) => hasOwn(value, key), { error: `Expected object to have own exact key "${String(key)}"` }));
-/**
- * Asserts that an object has a specific number of keys.
- *
- * @example
- *
- * ```ts
- * expect({ a: 1, b: 2 }, 'to have size', 2); // passes
- * expect({ a: 1 }, 'to have size', 2); // fails
- * ```
- *
- * @group Collection Assertions
- * @bupkisAnchor unknown-to-be-an-object
- * @bupkisAssertionCategory object
- */
-exports.objectSizeAssertion = (0, create_js_1.createAssertion)([schema_js_1.UnknownRecordSchema, 'to have size', schema_js_1.NonNegativeIntegerSchema], (subject, expectedSize) => {
-    const actual = keys(subject).length;
-    if (actual !== expectedSize) {
-        return {
-            actual,
-            expected: expectedSize,
-            message: `Expected object to have ${expectedSize} keys, but it has ${actual} keys`,
-        };
-    }
-});
-/**
- * Asserts that two Sets are equal (same elements, order-independent).
- *
- * @example
- *
- * ```ts
- * expect(new Set([1, 2]), 'to equal', new Set([2, 1])); // passes
- * expect(new Set([1, 2]), 'to equal', new Set([1, 3])); // fails
- * ```
- *
- * @group Collection Assertions
- * @bupkisAnchor set-to-equal-set
- * @bupkisAssertionCategory collections
- */
-exports.setEqualityAssertion = (0, create_js_1.createAssertion)([schema_js_1.SetSchema, 'to equal', schema_js_1.SetSchema], (actual, expected) => {
-    return actual.size === expected.size && (0, set_prototype_issubsetof_1.default)(actual, expected);
-});
-/**
- * Asserts that one Set is a subset of another.
- *
- * @example
- *
- * ```ts
- * expect(new Set([1, 2]), 'to be a subset of', new Set([1, 2, 3])); // passes
- * expect(new Set([1, 4]), 'to be a subset of', new Set([1, 2, 3])); // fails
- * ```
- *
- * @group Collection Assertions
- * @bupkisAnchor set-to-be-a-subset-of-set
- * @bupkisAssertionCategory collections
- */
-exports.setSubsetAssertion = (0, create_js_1.createAssertion)([schema_js_1.SetSchema, 'to be a subset of', schema_js_1.SetSchema], (subset, superset) => (0, set_prototype_issubsetof_1.default)(subset, superset));
-/**
- * Asserts that one Set is a superset of another.
- *
- * @example
- *
- * ```ts
- * expect(new Set([1, 2, 3]), 'to be a superset of', new Set([1, 2])); // passes
- * expect(new Set([1, 2]), 'to be a superset of', new Set([1, 2, 3])); // fails
- * ```
- *
- * @group Collection Assertions
- * @bupkisAnchor set-to-be-a-superset-of-set
- * @bupkisAssertionCategory collections
- */
-exports.setSupersetAssertion = (0, create_js_1.createAssertion)([schema_js_1.SetSchema, 'to be a superset of', schema_js_1.SetSchema], (superset, subset) => (0, set_prototype_issupersetof_1.default)(superset, subset));
-/**
- * Asserts that two Sets intersect (have common elements).
- *
- * @example
- *
- * ```ts
- * expect(new Set([1, 2]), 'to intersect with', new Set([2, 3])); // passes
- * expect(new Set([1, 2]), 'to intersect with', new Set([3, 4])); // fails
- * ```
- *
- * @group Collection Assertions
- * @bupkisAnchor set-to-have-intersection-with-set-satisfying-any
- * @bupkisAssertionCategory collections
- */
-exports.setIntersectionAssertion = (0, create_js_1.createAssertion)([schema_js_1.SetSchema, 'to intersect with', schema_js_1.SetSchema], (setA, setB) => !(0, set_prototype_isdisjointfrom_1.default)(setA, setB));
-/**
- * Asserts that two Sets are disjoint (have no common elements).
- *
- * @example
- *
- * ```ts
- * expect(new Set([1, 2]), 'to be disjoint from', new Set([3, 4])); // passes
- * expect(new Set([1, 2]), 'to be disjoint from', new Set([2, 3])); // fails
- * ```
- *
- * @group Collection Assertions
- * @bupkisAnchor set-to-be-disjoint-from-set
- * @bupkisAssertionCategory collections
- */
-exports.setDisjointAssertion = (0, create_js_1.createAssertion)([schema_js_1.SetSchema, 'to be disjoint from', schema_js_1.SetSchema], (setA, setB) => (0, set_prototype_isdisjointfrom_1.default)(setA, setB));
-/**
- * Asserts that the union of two Sets equals a third Set.
- *
- * @example
- *
- * ```ts
- * expect(
- *   new Set([1, 2]),
- *   'to have union',
- *   new Set([3]),
- *   'equal to',
- *   new Set([1, 2, 3]),
- * ); // passes
- * ```
- *
- * @group Collection Assertions
- * @bupkisAnchor set-union-with-set-to-equal-set
- * @bupkisAssertionCategory collections
- */
-exports.setUnionEqualityAssertion = (0, create_js_1.createAssertion)([schema_js_1.SetSchema, 'to have union', schema_js_1.SetSchema, 'equal to', schema_js_1.SetSchema], (setA, setB, expected) => {
-    const result = (0, set_prototype_union_1.default)(setA, setB);
-    return (result.size === expected.size &&
-        (0, set_prototype_issubsetof_1.default)(result, expected) &&
-        (0, set_prototype_issubsetof_1.default)(expected, result));
-});
-/**
- * Asserts that the intersection of two Sets equals a third Set.
- *
- * @example
- *
- * ```ts
- * expect(
- *   new Set([1, 2, 3]),
- *   'to have intersection',
- *   new Set([2, 3, 4]),
- *   'equal to',
- *   new Set([2, 3]),
- * ); // passes
- * ```
- *
- * @group Collection Assertions
- * @bupkisAnchor set-intersection-with-set-to-equal-set
- * @bupkisAssertionCategory collections
- */
-exports.setIntersectionEqualityAssertion = (0, create_js_1.createAssertion)([schema_js_1.SetSchema, 'to have intersection', schema_js_1.SetSchema, 'equal to', schema_js_1.SetSchema], (setA, setB, expected) => {
-    const result = (0, set_prototype_intersection_1.default)(setA, setB);
-    return (result.size === expected.size &&
-        (0, set_prototype_issubsetof_1.default)(result, expected) &&
-        (0, set_prototype_issubsetof_1.default)(expected, result));
-});
-/**
- * Asserts that the difference between two Sets equals a third Set.
- *
- * @example
- *
- * ```ts
- * expect(
- *   new Set([1, 2, 3]),
- *   'to have difference',
- *   new Set([2, 4]),
- *   'equal to',
- *   new Set([1, 3]),
- * ); // passes
- * ```
- *
- * @group Collection Assertions
- * @bupkisAnchor set-difference-with-set-to-equal-set
- * @bupkisAssertionCategory collections
- */
-exports.setDifferenceEqualityAssertion = (0, create_js_1.createAssertion)([schema_js_1.SetSchema, 'to have difference', schema_js_1.SetSchema, 'equal to', schema_js_1.SetSchema], (setA, setB, expected) => {
-    const result = (0, set_prototype_difference_1.default)(setA, setB);
-    return (result.size === expected.size &&
-        (0, set_prototype_issubsetof_1.default)(result, expected) &&
-        (0, set_prototype_issubsetof_1.default)(expected, result));
-});
-/**
- * Asserts that the symmetric difference between two Sets equals a third Set.
- *
- * @example
- *
- * ```ts
- * expect(
- *   new Set([1, 2]),
- *   'to have symmetric difference',
- *   new Set([2, 3]),
- *   'equal to',
- *   new Set([1, 3]),
- * ); // passes
- * ```
- *
- * @group Collection Assertions
- * @bupkisAnchor set-symmetric-difference-with-set-to-equal-set
- * @bupkisAssertionCategory collections
- */
-exports.setSymmetricDifferenceEqualityAssertion = (0, create_js_1.createAssertion)([schema_js_1.SetSchema, 'to have symmetric difference', schema_js_1.SetSchema, 'equal to', schema_js_1.SetSchema], (setA, setB, expected) => {
-    const result = (0, set_prototype_symmetricdifference_1.default)(setA, setB);
-    return (result.size === expected.size &&
-        (0, set_prototype_issubsetof_1.default)(result, expected) &&
-        (0, set_prototype_issubsetof_1.default)(expected, result));
-});
-/**
- * Asserts that a Map has a specific key.
- *
- * @example
- *
- * ```ts
- * const map = new Map([['key', 'value']]);
- * expect(map, 'to have key', 'key'); // passes
- * expect(map, 'to have key', 'missing'); // fails
- * ```
- *
- * @group Collection Assertions
- * @bupkisAnchor map-to-have-key-any
- * @bupkisAssertionCategory collections
- */
-exports.mapKeyAssertion = (0, create_js_1.createAssertion)([schema_js_1.MapSchema, 'to have key', schema_js_1.UnknownSchema], (map, key) => {
-    if (!map.has(key)) {
-        return {
-            actual: [...map.keys()],
-            expected: [...map.keys(), key],
-            message: 'Expected Map to have key',
-        };
-    }
-});
-/**
- * Asserts that a Map contains a specific value.
- *
- * @example
- *
- * ```ts
- * const map = new Map([['key', 'value']]);
- * expect(map, 'to have value', 'value'); // passes
- * expect(map, 'to have value', 'missing'); // fails
- * ```
- *
- * @group Collection Assertions
- * @bupkisAnchor map-to-have-value-any
- * @bupkisAssertionCategory collections
- */
-exports.mapValueAssertion = (0, create_js_1.createAssertion)([
-    schema_js_1.MapSchema,
-    ['to have value', 'to contain value', 'to include value'],
-    schema_js_1.UnknownSchema,
-], (map, value) => {
-    for (const mapValue of map.values()) {
-        if (mapValue === value) {
-            return;
-        }
-    }
-    return {
-        actual: [...map.values()],
-        expected: value,
-        message: `Expected Map to have value`,
-    };
-});
-/**
- * Asserts that a Map has a specific key-value entry.
- *
- * @example
- *
- * ```ts
- * const map = new Map([['key', 'value']]);
- * expect(map, 'to have entry', ['key', 'value']); // passes
- * expect(map, 'to have entry', ['key', 'wrong']); // fails
- * ```
- *
- * @group Collection Assertions
- * @bupkisAnchor map-to-have-entry-any-any
- * @bupkisAssertionCategory collections
- */
-exports.mapEntryAssertion = (0, create_js_1.createAssertion)([
-    schema_js_1.AnyMapSchema,
-    [
-        'to have entry',
-        'to have key/value pair',
-        'to contain entry',
-        'to contain key/value pair',
-        'to include entry',
-        'to include key/value pair',
-    ],
-    zod_1.z.tuple([schema_js_1.UnknownSchema, schema_js_1.UnknownSchema]),
-], (map, [key, value]) => {
-    // WeakMap operations only work with object or symbol keys
-    if (map instanceof WeakMap && !(0, guards_js_1.isWeakKey)(key)) {
-        return {
-            message: `WeakMap keys must be objects or symbols, got ${typeof key}`,
-        };
-    }
-    // At this point, if it's a WeakMap, we know key is a WeakKey
-    const actualValue = map instanceof WeakMap ? map.get(key) : map.get(key);
-    if (actualValue === value) {
-        return;
-    }
-    const hasKey = map instanceof WeakMap ? map.has(key) : map.has(key);
-    return {
-        actual: hasKey ? [key, actualValue] : undefined,
-        expected: [key, value],
-        message: hasKey
-            ? `Expected ${map.constructor.name} entry [${String(key)}, ${String(actualValue)}] to equal [${String(key)}, ${String(value)}]`
-            : `Expected ${map.constructor.name} to have key ${String(key)}`,
-    };
-});
-/**
- * Asserts that two Maps are equal (same key-value pairs, order-independent).
- *
- * @example
- *
- * ```ts
- * const map1 = new Map([
- *   ['a', 1],
- *   ['b', 2],
- * ]);
- * const map2 = new Map([
- *   ['b', 2],
- *   ['a', 1],
- * ]);
- * expect(map1, 'to equal', map2); // passes
- * ```
- *
- * @group Collection Assertions
- * @bupkisAnchor map-to-equal-map
- * @bupkisAssertionCategory collections
- */
-exports.mapEqualityAssertion = (0, create_js_1.createAssertion)([schema_js_1.MapSchema, 'to equal', schema_js_1.MapSchema], (mapA, mapB) => {
-    if (mapA.size !== mapB.size) {
-        return {
-            actual: mapA.size,
-            expected: mapB.size,
-            message: `Expected Maps to have equal sizes, got ${mapA.size} and ${mapB.size}`,
-        };
-    }
-    for (const [key, value] of mapA) {
-        if (!mapB.has(key)) {
-            return {
-                message: `Expected second Map to contain key ${String(key)}`,
-            };
-        }
-        if (mapB.get(key) !== value) {
-            return {
-                actual: [key, mapB.get(key)],
-                expected: [key, value],
-                message: `Expected Maps to have equal value for key ${String(key)}`,
-            };
-        }
-    }
-});
-/**
- * Asserts that a collection (Map or Set) has a size greater than a threshold.
- *
- * @example
- *
- * ```ts
- * expect(new Set([1, 2, 3]), 'to have size greater than', 2); // passes
- * expect(new Set([1]), 'to have size greater than', 2); // fails
- * ```
- *
- * @group Collection Assertions
- * @bupkisAnchor collection-to-have-size-greater-than-nonnegative-integer
- * @bupkisAssertionCategory collections
- */
-exports.collectionSizeGreaterThanAssertion = (0, create_js_1.createAssertion)([
-    zod_1.z.union([schema_js_1.MapSchema, schema_js_1.SetSchema]),
-    'to have size greater than',
-    schema_js_1.NonNegativeIntegerSchema,
-], (collection, minSize) => {
-    if (collection.size <= minSize) {
-        return {
-            actual: collection.size,
-            expected: minSize,
-            message: `Expected ${collection.constructor.name} to have size greater than ${minSize}, got ${collection.size}`,
-        };
-    }
-});
-/**
- * Asserts that a collection (Map or Set) has a size less than a threshold.
- *
- * @example
- *
- * ```ts
- * expect(new Set([1]), 'to have size less than', 2); // passes
- * expect(new Set([1, 2, 3]), 'to have size less than', 2); // fails
- * ```
- *
- * @group Collection Assertions
- * @bupkisAnchor collection-to-have-size-less-than-nonnegative-integer
- * @bupkisAssertionCategory collections
- */
-exports.collectionSizeLessThanAssertion = (0, create_js_1.createAssertion)([
-    zod_1.z.union([schema_js_1.MapSchema, schema_js_1.SetSchema]),
-    'to have size less than',
-    schema_js_1.NonNegativeIntegerSchema,
-], (collection, maxSize) => {
-    if (collection.size >= maxSize) {
-        return {
-            actual: collection.size,
-            expected: maxSize,
-            message: `Expected ${collection.constructor.name} to have size less than ${maxSize}, got ${collection.size}`,
-        };
-    }
-});
-/**
- * Asserts that a collection (Map or Set) has a size within a specific range.
- *
- * @example
- *
- * ```ts
- * expect(new Set([1, 2]), 'to have size between', [1, 3]); // passes
- * expect(new Set([1, 2, 3, 4]), 'to have size between', [1, 3]); // fails
- * ```
- *
- * @group Collection Assertions
- * @bupkisAnchor collection-to-have-size-between-nonnegative-integer-and-nonnegative-integer
- * @bupkisAssertionCategory collections
- */
-exports.collectionSizeBetweenAssertion = (0, create_js_1.createAssertion)([
-    zod_1.z.union([schema_js_1.MapSchema, schema_js_1.SetSchema]),
-    'to have size between',
-    zod_1.z.tuple([schema_js_1.NonNegativeIntegerSchema, schema_js_1.NonNegativeIntegerSchema]),
-], (collection, [min, max]) => {
-    const size = collection.size;
-    if (!(size >= min && size <= max)) {
-        return {
-            message: `Expected ${collection.constructor.name} to have size between ${min} and ${max}, got ${size}`,
-        };
-    }
-});
-//# sourceMappingURL=sync-collection.js.map