bupkis 0.18.0 → 0.18.2

package/dist/expect.d.cts

@@ -1,138 +0,0 @@
-import { type AnyAsyncAssertions, type AnySyncAssertions } from "./assertion/assertion-types.cjs";
-import { type Expect, type ExpectAsync, type ExpectAsyncFunction, type ExpectAsyncProps, type ExpectFunction, type ExpectSyncProps } from "./types.cjs";
-/**
- * Creates an asynchronous expect function by extending a parent expectAsync
- * function with additional assertions.
- *
- * This overload combines assertions from an existing parent expectAsync
- * function with new assertions, creating a unified expectAsync function that
- * supports both sets of assertions. The resulting function inherits all type
- * information from both the parent and new assertions, providing complete
- * TypeScript intellisense and type safety for Promise-based testing scenarios.
- *
- * @example
- *
- * ```typescript
- * const baseExpectAsync = createExpectAsyncFunction(basicAsyncAssertions);
- * const extendedExpectAsync = createExpectAsyncFunction(
- *   customAsyncAssertions,
- *   baseExpectAsync,
- * );
- *
- * // Can use both basic and custom async assertions
- * await extendedExpectAsync(promise, 'to resolve'); // From basic assertions
- * await extendedExpectAsync(promise, 'to resolve with custom data'); // From custom assertions
- * ```
- *
- * @param assertions - Array of new asynchronous assertion objects to add
- * @param expect - Parent expectAsync function whose assertions will be
- *   inherited
- * @returns ExpectAsync function with combined assertion types from both parent
- *   and new assertions
- * @throws {@link AssertionError} When an assertion fails in normal
- *   (non-negated) mode
- * @throws {@link NegatedAssertionError} When a negated assertion fails
- * @throws {Error} When no matching assertion can be found for the provided
- *   arguments
- */
-export declare function createExpectAsyncFunction<T extends AnyAsyncAssertions, U extends ExpectAsync<AnyAsyncAssertions>>(assertions: T, expect: U): ExpectAsyncFunction<T & U['assertions']>;
-/**
- * Creates a new asynchronous expect function with the provided assertions.
- *
- * This overload creates a standalone expectAsync function from the provided
- * assertions without inheriting from any parent function. This is typically
- * used to create the initial expectAsync function or when you want a clean
- * slate without any inherited assertions for Promise-based testing.
- *
- * @example
- *
- * ```typescript
- * const expectAsync = createExpectAsyncFunction(asyncAssertions);
- * await expectAsync(promise, 'to resolve');
- * await expectAsync(rejectedPromise, 'to reject');
- * await expectAsync(promise, 'to resolve to', expectedValue);
- * ```
- *
- * @param assertions - Array of asynchronous assertion objects that define the
- *   available assertion phrases and Promise-based logic
- * @returns An asynchronous expect function that can execute the provided
- *   assertions using natural language syntax
- * @throws {@link AssertionError} When an assertion fails in normal
- *   (non-negated) mode
- * @throws {@link NegatedAssertionError} When a negated assertion fails
- * @throws {Error} When no matching assertion can be found for the provided
- *   arguments
- */
-export declare function createExpectAsyncFunction<T extends AnyAsyncAssertions>(assertions: T): ExpectAsyncFunction<T>;
-/**
- * Creates a synchronous expect function by extending a parent expect function
- * with additional assertions.
- *
- * This overload combines assertions from an existing parent expect function
- * with new assertions, creating a unified expect function that supports both
- * sets of assertions. The resulting function inherits all type information from
- * both the parent and new assertions, providing complete TypeScript
- * intellisense and type safety.
- *
- * @example
- *
- * ```typescript
- * const baseExpect = createExpectSyncFunction(basicAssertions);
- * const extendedExpect = createExpectSyncFunction(
- *   customAssertions,
- *   baseExpect,
- * );
- *
- * // Can use both basic and custom assertions
- * extendedExpect(42, 'to be a number'); // From basic assertions
- * extendedExpect(obj, 'to have custom prop'); // From custom assertions
- * ```
- *
- * @param assertions - Array of new synchronous assertion objects to add
- * @param expect - Parent expect function whose assertions will be inherited
- * @returns Expect function with combined assertion types from both parent and
- *   new assertions
- * @throws {@link AssertionError} When an assertion fails in normal
- *   (non-negated) mode
- * @throws {@link NegatedAssertionError} When a negated assertion fails
- * @throws {Error} When no matching assertion can be found for the provided
- *   arguments
- */
-export declare function createExpectSyncFunction<Assertions extends AnySyncAssertions, ParentExpect extends Expect<AnySyncAssertions>>(assertions: Assertions, expect: ParentExpect): ExpectFunction<Assertions & ParentExpect['assertions']>;
-/**
- * Creates a new synchronous expect function with the provided assertions.
- *
- * This overload creates a standalone expect function from the provided
- * assertions without inheriting from any parent function. This is typically
- * used to create the initial expect function or when you want a clean slate
- * without any inherited assertions.
- *
- * @example
- *
- * ```typescript
- * const expect = createExpectSyncFunction(basicAssertions);
- * expect(42, 'to be a number');
- * expect('hello', 'to be a string');
- * expect([], 'to be empty');
- * ```
- *
- * @param assertions - Array of synchronous assertion objects that define the
- *   available assertion phrases and logic
- * @returns A synchronous expect function that can execute the provided
- *   assertions using natural language syntax
- * @throws {@link AssertionError} When an assertion fails in normal
- *   (non-negated) mode
- * @throws {@link NegatedAssertionError} When a negated assertion fails
- * @throws {Error} When no matching assertion can be found for the provided
- *   arguments
- */
-export declare function createExpectSyncFunction<Assertions extends AnySyncAssertions>(assertions: Assertions): ExpectFunction<Assertions>;
-/**
- * Used by a {@link UseFn} to create base properties of {@link Expect}.
- */
-export declare function createBaseExpect<T extends AnySyncAssertions, U extends AnyAsyncAssertions>(syncAssertions: T, asyncAssertions: U, type: 'sync'): ExpectSyncProps<T, U>;
-/**
- * Used by a {@link UseFn} to create base properties of {@link ExpectAsync}.
- */
-export declare function createBaseExpect<T extends AnySyncAssertions, U extends AnyAsyncAssertions>(syncAssertions: T, asyncAssertions: U, type: 'async'): ExpectAsyncProps<U, T>;
-//# sourceMappingURL=expect.d.ts.map

package/dist/expect.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"expect.d.ts","sourceRoot":"","sources":["../src/expect.ts"],"names":[],"mappings":"AAGA,OAAO,EAEL,KAAK,kBAAkB,EAEvB,KAAK,iBAAiB,EASvB,wCAAuC;AAUxC,OAAO,EACL,KAAK,MAAM,EACX,KAAK,WAAW,EAChB,KAAK,mBAAmB,EACxB,KAAK,gBAAgB,EACrB,KAAK,cAAc,EACnB,KAAK,eAAe,EAIrB,oBAAmB;AAKpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,yBAAyB,CACvC,CAAC,SAAS,kBAAkB,EAC5B,CAAC,SAAS,WAAW,CAAC,kBAAkB,CAAC,EACzC,UAAU,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,GAAG,mBAAmB,CAAC,CAAC,GAAG,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC;AAEtE;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,yBAAyB,CAAC,CAAC,SAAS,kBAAkB,EACpE,UAAU,EAAE,CAAC,GACZ,mBAAmB,CAAC,CAAC,CAAC,CAAC;AA+M1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,wBAAwB,CACtC,UAAU,SAAS,iBAAiB,EACpC,YAAY,SAAS,MAAM,CAAC,iBAAiB,CAAC,EAE9C,UAAU,EAAE,UAAU,EACtB,MAAM,EAAE,YAAY,GACnB,cAAc,CAAC,UAAU,GAAG,YAAY,CAAC,YAAY,CAAC,CAAC,CAAC;AAE3D;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,wBAAwB,CAAC,UAAU,SAAS,iBAAiB,EAC3E,UAAU,EAAE,UAAU,GACrB,cAAc,CAAC,UAAU,CAAC,CAAC;AA+jB9B;;GAEG;AACH,wBAAgB,gBAAgB,CAC9B,CAAC,SAAS,iBAAiB,EAC3B,CAAC,SAAS,kBAAkB,EAC5B,cAAc,EAAE,CAAC,EAAE,eAAe,EAAE,CAAC,EAAE,IAAI,EAAE,MAAM,GAAG,eAAe,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAC9E;;GAEG;AACH,wBAAgB,gBAAgB,CAC9B,CAAC,SAAS,iBAAiB,EAC3B,CAAC,SAAS,kBAAkB,EAC5B,cAAc,EAAE,CAAC,EAAE,eAAe,EAAE,CAAC,EAAE,IAAI,EAAE,OAAO,GAAG,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC"}

package/dist/expect.d.ts

@@ -1,138 +0,0 @@
-import { type AnyAsyncAssertions, type AnySyncAssertions } from "./assertion/assertion-types.js";
-import { type Expect, type ExpectAsync, type ExpectAsyncFunction, type ExpectAsyncProps, type ExpectFunction, type ExpectSyncProps } from "./types.js";
-/**
- * Creates an asynchronous expect function by extending a parent expectAsync
- * function with additional assertions.
- *
- * This overload combines assertions from an existing parent expectAsync
- * function with new assertions, creating a unified expectAsync function that
- * supports both sets of assertions. The resulting function inherits all type
- * information from both the parent and new assertions, providing complete
- * TypeScript intellisense and type safety for Promise-based testing scenarios.
- *
- * @example
- *
- * ```typescript
- * const baseExpectAsync = createExpectAsyncFunction(basicAsyncAssertions);
- * const extendedExpectAsync = createExpectAsyncFunction(
- *   customAsyncAssertions,
- *   baseExpectAsync,
- * );
- *
- * // Can use both basic and custom async assertions
- * await extendedExpectAsync(promise, 'to resolve'); // From basic assertions
- * await extendedExpectAsync(promise, 'to resolve with custom data'); // From custom assertions
- * ```
- *
- * @param assertions - Array of new asynchronous assertion objects to add
- * @param expect - Parent expectAsync function whose assertions will be
- *   inherited
- * @returns ExpectAsync function with combined assertion types from both parent
- *   and new assertions
- * @throws {@link AssertionError} When an assertion fails in normal
- *   (non-negated) mode
- * @throws {@link NegatedAssertionError} When a negated assertion fails
- * @throws {Error} When no matching assertion can be found for the provided
- *   arguments
- */
-export declare function createExpectAsyncFunction<T extends AnyAsyncAssertions, U extends ExpectAsync<AnyAsyncAssertions>>(assertions: T, expect: U): ExpectAsyncFunction<T & U['assertions']>;
-/**
- * Creates a new asynchronous expect function with the provided assertions.
- *
- * This overload creates a standalone expectAsync function from the provided
- * assertions without inheriting from any parent function. This is typically
- * used to create the initial expectAsync function or when you want a clean
- * slate without any inherited assertions for Promise-based testing.
- *
- * @example
- *
- * ```typescript
- * const expectAsync = createExpectAsyncFunction(asyncAssertions);
- * await expectAsync(promise, 'to resolve');
- * await expectAsync(rejectedPromise, 'to reject');
- * await expectAsync(promise, 'to resolve to', expectedValue);
- * ```
- *
- * @param assertions - Array of asynchronous assertion objects that define the
- *   available assertion phrases and Promise-based logic
- * @returns An asynchronous expect function that can execute the provided
- *   assertions using natural language syntax
- * @throws {@link AssertionError} When an assertion fails in normal
- *   (non-negated) mode
- * @throws {@link NegatedAssertionError} When a negated assertion fails
- * @throws {Error} When no matching assertion can be found for the provided
- *   arguments
- */
-export declare function createExpectAsyncFunction<T extends AnyAsyncAssertions>(assertions: T): ExpectAsyncFunction<T>;
-/**
- * Creates a synchronous expect function by extending a parent expect function
- * with additional assertions.
- *
- * This overload combines assertions from an existing parent expect function
- * with new assertions, creating a unified expect function that supports both
- * sets of assertions. The resulting function inherits all type information from
- * both the parent and new assertions, providing complete TypeScript
- * intellisense and type safety.
- *
- * @example
- *
- * ```typescript
- * const baseExpect = createExpectSyncFunction(basicAssertions);
- * const extendedExpect = createExpectSyncFunction(
- *   customAssertions,
- *   baseExpect,
- * );
- *
- * // Can use both basic and custom assertions
- * extendedExpect(42, 'to be a number'); // From basic assertions
- * extendedExpect(obj, 'to have custom prop'); // From custom assertions
- * ```
- *
- * @param assertions - Array of new synchronous assertion objects to add
- * @param expect - Parent expect function whose assertions will be inherited
- * @returns Expect function with combined assertion types from both parent and
- *   new assertions
- * @throws {@link AssertionError} When an assertion fails in normal
- *   (non-negated) mode
- * @throws {@link NegatedAssertionError} When a negated assertion fails
- * @throws {Error} When no matching assertion can be found for the provided
- *   arguments
- */
-export declare function createExpectSyncFunction<Assertions extends AnySyncAssertions, ParentExpect extends Expect<AnySyncAssertions>>(assertions: Assertions, expect: ParentExpect): ExpectFunction<Assertions & ParentExpect['assertions']>;
-/**
- * Creates a new synchronous expect function with the provided assertions.
- *
- * This overload creates a standalone expect function from the provided
- * assertions without inheriting from any parent function. This is typically
- * used to create the initial expect function or when you want a clean slate
- * without any inherited assertions.
- *
- * @example
- *
- * ```typescript
- * const expect = createExpectSyncFunction(basicAssertions);
- * expect(42, 'to be a number');
- * expect('hello', 'to be a string');
- * expect([], 'to be empty');
- * ```
- *
- * @param assertions - Array of synchronous assertion objects that define the
- *   available assertion phrases and logic
- * @returns A synchronous expect function that can execute the provided
- *   assertions using natural language syntax
- * @throws {@link AssertionError} When an assertion fails in normal
- *   (non-negated) mode
- * @throws {@link NegatedAssertionError} When a negated assertion fails
- * @throws {Error} When no matching assertion can be found for the provided
- *   arguments
- */
-export declare function createExpectSyncFunction<Assertions extends AnySyncAssertions>(assertions: Assertions): ExpectFunction<Assertions>;
-/**
- * Used by a {@link UseFn} to create base properties of {@link Expect}.
- */
-export declare function createBaseExpect<T extends AnySyncAssertions, U extends AnyAsyncAssertions>(syncAssertions: T, asyncAssertions: U, type: 'sync'): ExpectSyncProps<T, U>;
-/**
- * Used by a {@link UseFn} to create base properties of {@link ExpectAsync}.
- */
-export declare function createBaseExpect<T extends AnySyncAssertions, U extends AnyAsyncAssertions>(syncAssertions: T, asyncAssertions: U, type: 'async'): ExpectAsyncProps<U, T>;
-//# sourceMappingURL=expect.d.ts.map

package/dist/expect.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"expect.d.ts","sourceRoot":"","sources":["../src/expect.ts"],"names":[],"mappings":"AAGA,OAAO,EAEL,KAAK,kBAAkB,EAEvB,KAAK,iBAAiB,EASvB,uCAAuC;AAUxC,OAAO,EACL,KAAK,MAAM,EACX,KAAK,WAAW,EAChB,KAAK,mBAAmB,EACxB,KAAK,gBAAgB,EACrB,KAAK,cAAc,EACnB,KAAK,eAAe,EAIrB,mBAAmB;AAKpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,yBAAyB,CACvC,CAAC,SAAS,kBAAkB,EAC5B,CAAC,SAAS,WAAW,CAAC,kBAAkB,CAAC,EACzC,UAAU,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,GAAG,mBAAmB,CAAC,CAAC,GAAG,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC;AAEtE;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,yBAAyB,CAAC,CAAC,SAAS,kBAAkB,EACpE,UAAU,EAAE,CAAC,GACZ,mBAAmB,CAAC,CAAC,CAAC,CAAC;AA+M1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,wBAAwB,CACtC,UAAU,SAAS,iBAAiB,EACpC,YAAY,SAAS,MAAM,CAAC,iBAAiB,CAAC,EAE9C,UAAU,EAAE,UAAU,EACtB,MAAM,EAAE,YAAY,GACnB,cAAc,CAAC,UAAU,GAAG,YAAY,CAAC,YAAY,CAAC,CAAC,CAAC;AAE3D;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,wBAAwB,CAAC,UAAU,SAAS,iBAAiB,EAC3E,UAAU,EAAE,UAAU,GACrB,cAAc,CAAC,UAAU,CAAC,CAAC;AA+jB9B;;GAEG;AACH,wBAAgB,gBAAgB,CAC9B,CAAC,SAAS,iBAAiB,EAC3B,CAAC,SAAS,kBAAkB,EAC5B,cAAc,EAAE,CAAC,EAAE,eAAe,EAAE,CAAC,EAAE,IAAI,EAAE,MAAM,GAAG,eAAe,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAC9E;;GAEG;AACH,wBAAgB,gBAAgB,CAC9B,CAAC,SAAS,iBAAiB,EAC3B,CAAC,SAAS,kBAAkB,EAC5B,cAAc,EAAE,CAAC,EAAE,eAAe,EAAE,CAAC,EAAE,IAAI,EAAE,OAAO,GAAG,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC"}