bupkis 0.18.3 → 1.0.0

package/dist/assertion/impl/sync-basic.d.cts

@@ -0,0 +1,528 @@
+/**
+ * Basic type and primitive value assertions.
+ *
+ * These are the fundamental building blocks for type checking including
+ * strings, numbers, booleans, arrays, objects, functions, and other primitive
+ * JavaScript types.
+ *
+ * @packageDocumentation
+ * @groupDescription Basic Assertions
+ * Fundamental type checking and primitive value validation.
+ *
+ * @showGroups
+ */
+import { z } from 'zod';
+/**
+ * Asserts that the subject is a string value.
+ *
+ * @example
+ *
+ * ```ts
+ * expect('hello', 'to be a string'); // passes
+ * expect(42, 'to be a string'); // fails
+ * ```
+ *
+ * @group Basic Assertions
+ * @bupkisAnchor unknown-to-be-a-string
+ * @bupkisAssertionCategory primitives
+ */
+export declare const stringAssertion: import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be a string"], z.ZodString, never>;
+/**
+ * Asserts that the subject is a finite number value.
+ *
+ * @example
+ *
+ * ```ts
+ * expect(42, 'to be a number'); // passes
+ * expect(Infinity, 'to be a number'); // fails
+ * expect('42', 'to be a number'); // fails
+ * ```
+ *
+ * @group Basic Assertions
+ */
+export declare const numberAssertion: import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a number", "to be finite"]], z.ZodNumber, never>;
+/**
+ * Asserts that the subject is either positive or negative infinity.
+ *
+ * @example
+ *
+ * ```ts
+ * expect(Infinity, 'to be infinite'); // passes
+ * expect(-Infinity, 'to be infinite'); // passes
+ * expect(42, 'to be infinite'); // fails
+ * ```
+ *
+ * @group Basic Assertions
+ */
+export declare const infiniteAssertion: import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be infinite"], z.ZodUnion<[z.ZodLiteral<number>, z.ZodLiteral<number>]>, never>;
+/**
+ * Asserts that the subject is positive infinity.
+ *
+ * @example
+ *
+ * ```ts
+ * expect(Infinity, 'to be Infinity'); // passes
+ * expect(-Infinity, 'to be Infinity'); // fails
+ * ```
+ *
+ * @group Basic Assertions
+ */
+export declare const positiveInfinityAssertion: import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be Infinity"], z.ZodLiteral<number>, never>;
+/**
+ * Asserts that the subject is negative infinity.
+ *
+ * @example
+ *
+ * ```ts
+ * expect(-Infinity, 'to be -Infinity'); // passes
+ * expect(Infinity, 'to be -Infinity'); // fails
+ * ```
+ *
+ * @group Basic Assertions
+ */
+export declare const negativeInfinityAssertion: import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be -Infinity"], z.ZodLiteral<number>, never>;
+/**
+ * Asserts that the subject is a boolean value.
+ *
+ * @example
+ *
+ * ```ts
+ * expect(true, 'to be a boolean'); // passes
+ * expect('true', 'to be a boolean'); // fails
+ * ```
+ *
+ * @group Basic Assertions
+ */
+export declare const booleanAssertion: import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a boolean", "to be boolean", "to be a bool"]], z.ZodBoolean, never>;
+/**
+ * Asserts that the subject is a positive number.
+ *
+ * @example
+ *
+ * ```ts
+ * expect(42, 'to be positive'); // passes
+ * expect(-1, 'to be positive'); // fails
+ * expect(0, 'to be positive'); // fails
+ * ```
+ *
+ * @group Basic Assertions
+ */
+export declare const positiveAssertion: import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be positive", "to be a positive number"]], z.ZodNumber, never>;
+/**
+ * Asserts that the subject is a positive integer.
+ *
+ * @example
+ *
+ * ```ts
+ * expect(42, 'to be a positive integer'); // passes
+ * expect(-1, 'to be a positive integer'); // fails
+ * expect(42.5, 'to be a positive integer'); // fails
+ * ```
+ *
+ * @group Basic Assertions
+ */
+export declare const positiveIntegerAssertion: import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a positive integer", "to be a positive int"]], z.ZodNumber, never>;
+/**
+ * Asserts that the subject is a negative number.
+ *
+ * @example
+ *
+ * ```ts
+ * expect(-42, 'to be negative'); // passes
+ * expect(1, 'to be negative'); // fails
+ * expect(0, 'to be negative'); // fails
+ * ```
+ *
+ * @group Basic Assertions
+ */
+export declare const negativeAssertion: import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be negative", "to be a negative number"]], z.ZodNumber, never>;
+/**
+ * Asserts that the subject is a negative integer.
+ *
+ * @example
+ *
+ * ```ts
+ * expect(-42, 'to be a negative integer'); // passes
+ * expect(1, 'to be a negative integer'); // fails
+ * expect(-42.5, 'to be a negative integer'); // fails
+ * ```
+ *
+ * @group Basic Assertions
+ */
+export declare const negativeIntegerAssertion: import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a negative integer", "to be a negative int"]], z.ZodNumber, never>;
+/**
+ * Asserts that the subject is exactly the boolean value true.
+ *
+ * @example
+ *
+ * ```ts
+ * expect(true, 'to be true'); // passes
+ * expect(false, 'to be true'); // fails
+ * expect(1, 'to be true'); // fails
+ * ```
+ *
+ * @group Basic Assertions
+ */
+export declare const trueAssertion: import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be true"], z.ZodLiteral<true>, never>;
+/**
+ * Asserts that the subject is exactly the boolean value false.
+ *
+ * @example
+ *
+ * ```ts
+ * expect(false, 'to be false'); // passes
+ * expect(true, 'to be false'); // fails
+ * expect(0, 'to be false'); // fails
+ * ```
+ *
+ * @group Basic Assertions
+ */
+export declare const falseAssertion: import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be false"], z.ZodLiteral<false>, never>;
+/**
+ * Asserts that the subject is a BigInt value.
+ *
+ * @example
+ *
+ * ```ts
+ * expect(123n, 'to be a bigint'); // passes
+ * expect(123, 'to be a bigint'); // fails
+ * ```
+ *
+ * @group Basic Assertions
+ */
+export declare const bigintAssertion: import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a bigint", "to be a BigInt"]], z.ZodBigInt, never>;
+/**
+ * Asserts that the subject is a Symbol.
+ *
+ * @example
+ *
+ * ```ts
+ * expect(Symbol('test'), 'to be a symbol'); // passes
+ * expect('symbol', 'to be a symbol'); // fails
+ * ```
+ *
+ * @group Basic Assertions
+ */
+export declare const symbolAssertion: import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a symbol", "to be a Symbol"]], z.ZodSymbol, never>;
+/**
+ * Asserts that the subject is a function.
+ *
+ * @example
+ *
+ * ```ts
+ * expect(() => {}, 'to be a function'); // passes
+ * expect('function', 'to be a function'); // fails
+ * ```
+ *
+ * @group Basic Assertions
+ */
+export declare const functionAssertion: import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be a function"], z.ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, never>;
+/**
+ * Asserts that the subject is an async function.
+ *
+ * @example
+ *
+ * ```ts
+ * expect(async () => {}, 'to be an async function'); // passes
+ * expect(() => {}, 'to be an async function'); // fails
+ * ```
+ *
+ * @group Basic Assertions
+ */
+export declare const asyncFunctionAssertion: import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be an async function"], z.ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, never>;
+/**
+ * Asserts that the subject is NaN (Not a Number).
+ *
+ * @example
+ *
+ * ```ts
+ * expect(NaN, 'to be NaN'); // passes
+ * expect(42, 'to be NaN'); // fails
+ * expect('not a number', 'to be NaN'); // fails
+ * ```
+ *
+ * @group Basic Assertions
+ */
+export declare const nanAssertion: import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be NaN"], z.ZodNaN, never>;
+/**
+ * Asserts that the subject is an integer (safe integer).
+ *
+ * @example
+ *
+ * ```ts
+ * expect(42, 'to be an integer'); // passes
+ * expect(42.5, 'to be an integer'); // fails
+ * ```
+ *
+ * @group Basic Assertions
+ */
+export declare const integerAssertion: import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be an integer", "to be a safe integer", "to be an int", "to be a safe int"]], z.ZodNumber, never>;
+/**
+ * Asserts that the subject is null.
+ *
+ * @example
+ *
+ * ```ts
+ * expect(null, 'to be null'); // passes
+ * expect(undefined, 'to be null'); // fails
+ * ```
+ *
+ * @group Basic Assertions
+ */
+export declare const nullAssertion: import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be null"], z.ZodNull, never>;
+/**
+ * Asserts that the subject is undefined.
+ *
+ * @example
+ *
+ * ```ts
+ * expect(undefined, 'to be undefined'); // passes
+ * expect(null, 'to be undefined'); // fails
+ * ```
+ *
+ * @group Basic Assertions
+ */
+export declare const undefinedAssertion: import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be undefined"], z.ZodUndefined, never>;
+/**
+ * Asserts that the subject is an array.
+ *
+ * @example
+ *
+ * ```ts
+ * expect([1, 2, 3], 'to be an array'); // passes
+ * expect('array', 'to be an array'); // fails
+ * ```
+ *
+ * @group Basic Assertions
+ */
+export declare const arrayAssertion: import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be an array", "to be array"]], z.ZodArray<z.ZodUnknown>, never>;
+/**
+ * Asserts that the subject is a Date object.
+ *
+ * @example
+ *
+ * ```ts
+ * expect(new Date(), 'to be a date'); // passes
+ * expect('2023-01-01', 'to be a date'); // fails
+ * ```
+ *
+ * @group Basic Assertions
+ */
+export declare const dateAssertion: import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a date", "to be a Date"]], z.ZodDate, never>;
+/**
+ * Asserts that the subject is a class constructor (constructible function).
+ *
+ * @example
+ *
+ * ```ts
+ * expect(Date, 'to be a class'); // passes
+ * expect(() => {}, 'to be a class'); // fails
+ * ```
+ *
+ * @group Basic Assertions
+ */
+export declare const classAssertion: import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a class", "to be a constructor", "to be constructible"]], z.ZodCustom<import("../../types.js").Constructor, import("../../types.js").Constructor>, never>;
+/**
+ * Asserts that the subject is a primitive value (string, number, boolean, null,
+ * undefined, symbol, or bigint).
+ *
+ * @example
+ *
+ * ```ts
+ * expect('hello', 'to be a primitive'); // passes
+ * expect({}, 'to be a primitive'); // fails
+ * ```
+ *
+ * @group Basic Assertions
+ */
+export declare const primitiveAssertion: import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be a primitive"], z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodBigInt, z.ZodSymbol, z.ZodNull, z.ZodUndefined]>, never>;
+/**
+ * Asserts that the subject is a regular expression.
+ *
+ * @example
+ *
+ * ```ts
+ * expect(/test/, 'to be a RegExp'); // passes
+ * expect('test', 'to be a RegExp'); // fails
+ * ```
+ *
+ * @group Basic Assertions
+ */
+export declare const regexpAssertion: import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a RegExp", "to be a regex", "to be a regexp"]], z.ZodCustom<RegExp, RegExp>, never>;
+/**
+ * Asserts that the subject is truthy (not false, 0, '', null, undefined, or
+ * NaN).
+ *
+ * @example
+ *
+ * ```ts
+ * expect('hello', 'to be truthy'); // passes
+ * expect('', 'to be truthy'); // fails
+ * ```
+ *
+ * @group Basic Assertions
+ */
+export declare const truthyAssertion: import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be truthy", "to exist", "to be ok"]], z.ZodNonOptional<z.ZodAny>, never>;
+/**
+ * Asserts that the subject is falsy (false, 0, '', null, undefined, or NaN).
+ *
+ * @example
+ *
+ * ```ts
+ * expect('', 'to be falsy'); // passes
+ * expect('hello', 'to be falsy'); // fails
+ * ```
+ *
+ * @group Basic Assertions
+ */
+export declare const falsyAssertion: import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be falsy"], z.ZodNullable<z.ZodAny>, never>;
+/**
+ * Asserts that the subject is an object (non-null object type).
+ *
+ * @example
+ *
+ * ```ts
+ * expect({}, 'to be an object'); // passes
+ * expect(null, 'to be an object'); // fails
+ * expect('string', 'to be an object'); // fails
+ * ```
+ *
+ * @group Basic Assertions
+ */
+export declare const objectAssertion: import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be an object"], z.ZodNonOptional<z.ZodUnknown> & z.ZodType<object, unknown, z.core.$ZodTypeInternals<object, unknown>>, never>;
+/**
+ * Asserts that the subject is a record (plain object with string/symbol/number
+ * keys).
+ *
+ * @example
+ *
+ * ```ts
+ * expect({ key: 'value' }, 'to be a record'); // passes
+ * expect([], 'to be a record'); // fails
+ * ```
+ *
+ * @group Basic Assertions
+ */
+export declare const recordAssertion: import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a record", "to be a plain object"]], z.ZodRecord<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodSymbol]>, z.ZodUnknown>, never>;
+/**
+ * Asserts that an array is empty.
+ *
+ * @example
+ *
+ * ```ts
+ * expect([], 'to be empty'); // passes
+ * expect([1, 2], 'to be empty'); // fails
+ * ```
+ *
+ * @group Basic Assertions
+ */
+export declare const emptyArrayAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [z.ZodCustom<ArrayLike<unknown>, ArrayLike<unknown>>, "to be empty"], (subject: ArrayLike<unknown>) => {
+    actual: number;
+    expected: number;
+    message: string;
+} | undefined, readonly [z.ZodCustom<ArrayLike<unknown>, ArrayLike<unknown>>, import("../assertion-types.js").PhraseLiteralSlot<"to be empty">]>;
+/**
+ * Asserts that an object is empty (has no own properties).
+ *
+ * @example
+ *
+ * ```ts
+ * expect({}, 'to be empty'); // passes
+ * expect({ key: 'value' }, 'to be empty'); // fails
+ * ```
+ *
+ * @group Basic Assertions
+ */
+export declare const emptyObjectAssertion: import("../assertion-types.js").AssertionStandardSchemaSync<readonly [z.ZodRecord<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodSymbol]>, z.ZodUnknown>, "to be empty"], z.ZodRecord<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodSymbol]>, z.ZodUnknown>, readonly [z.ZodRecord<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodSymbol]>, z.ZodUnknown>, import("../assertion-types.js").PhraseLiteralSlot<"to be empty">]>;
+/**
+ * Asserts that the subject is an Error instance.
+ *
+ * @example
+ *
+ * ```ts
+ * expect(new Error('test'), 'to be an Error'); // passes
+ * expect('error', 'to be an Error'); // fails
+ * ```
+ *
+ * @group Basic Assertions
+ */
+export declare const errorAssertion: import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be an Error", "to be a Error"]], z.ZodCustom<Error, Error>, never>;
+/**
+ * Asserts that a string is empty.
+ *
+ * @example
+ *
+ * ```ts
+ * expect('', 'to be empty'); // passes
+ * expect('hello', 'to be empty'); // fails
+ * ```
+ *
+ * @group Basic Assertions
+ */
+export declare const emptyStringAssertion: import("../assertion-types.js").AssertionStandardSchemaSync<readonly [z.ZodString, "to be empty"], z.ZodString, readonly [z.ZodString, import("../assertion-types.js").PhraseLiteralSlot<"to be empty">]>;
+/**
+ * Asserts that a string is non-empty.
+ *
+ * @example
+ *
+ * ```ts
+ * expect('hello', 'to be non-empty'); // passes
+ * expect('', 'to be non-empty'); // fails
+ * ```
+ *
+ * @group Basic Assertions
+ */
+export declare const nonEmptyStringAssertion: import("../assertion-types.js").AssertionStandardSchemaSync<readonly [z.ZodString, "to be non-empty"], z.ZodString, readonly [z.ZodString, import("../assertion-types.js").PhraseLiteralSlot<"to be non-empty">]>;
+/**
+ * Asserts that the subject is defined (not undefined).
+ *
+ * @example
+ *
+ * ```ts
+ * expect(null, 'to be defined'); // passes
+ * expect(undefined, 'to be defined'); // fails
+ * ```
+ *
+ * @group Basic Assertions
+ */
+export declare const definedAssertion: import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be defined"], z.ZodNonOptional<z.ZodUnknown>, never>;
+/**
+ * Asserts that the subject is a Set instance.
+ *
+ * @example
+ *
+ * ```ts
+ * expect(new Set(), 'to be a Set'); // passes
+ * expect([], 'to be a Set'); // fails
+ * ```
+ *
+ * @group Basic Assertions
+ */
+export declare const setAssertion: import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be a Set"], z.ZodCustom<Set<unknown>, Set<unknown>>, never>;
+/**
+ * Asserts that the subject is a WeakMap instance.
+ *
+ * @example
+ *
+ * ```ts
+ * expect(new WeakMap(), 'to be a WeakMap'); // passes
+ * expect(new Map(), 'to be a WeakMap'); // fails
+ * ```
+ *
+ * @group Basic Assertions
+ */
+export declare const weakMapAssertion: import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be a WeakMap"], z.ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>>, never>;
+/**
+ * Asserts that the subject is a WeakSet instance.
+ *
+ * @example
+ *
+ * ```ts
+ * expect(new WeakSet(), 'to be a WeakSet'); // passes
+ * expect(new Set(), 'to be a WeakSet'); // fails
+ * ```
+ *
+ * @group Basic Assertions
+ */
+export declare const weakSetAssertion: import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be a WeakSet"], z.ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>>, never>;
+//# sourceMappingURL=sync-basic.d.ts.map

package/dist/assertion/impl/sync-basic.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync-basic.d.ts","sourceRoot":"","sources":["../../../src/assertion/impl/sync-basic.ts"],"names":[],"mappings":"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"}