@dereekb/util 12.6.21 → 13.0.0

package/test/src/lib/jest/jest.d.ts

@@ -0,0 +1,55 @@
+import { type TestFixtureInstance, type TestFixture, type TestContextFixtureClearInstanceFunction, type TestContextFixture, AbstractTestContextFixture, AbstractChildTestContextFixture, type BuildTestsWithContextFunction, type TestContextFactory, type TestContextBuilderFunction, type TestContextBuilderConfig, testContextBuilder, type UseContextFixture, useTestContextFixture } from '../shared/shared';
+/**
+ * @deprecated Use TestFixtureInstance from shared instead. This is kept for backwards compatibility.
+ */
+export type JestTestFixtureInstance<I> = TestFixtureInstance<I>;
+/**
+ * @deprecated Use TestFixture from shared instead. This is kept for backwards compatibility.
+ */
+export type JestTestFixture<I> = TestFixture<I>;
+/**
+ * @deprecated Use TestContextFixtureClearInstanceFunction from shared instead. This is kept for backwards compatibility.
+ */
+export type JestTestContextFixtureClearInstanceFunction = TestContextFixtureClearInstanceFunction;
+/**
+ * @deprecated Use TestContextFixture from shared instead. This is kept for backwards compatibility.
+ */
+export type JestTestContextFixture<I> = TestContextFixture<I>;
+/**
+ * @deprecated Use AbstractTestContextFixture from shared instead. This is kept for backwards compatibility.
+ */
+export declare abstract class AbstractJestTestContextFixture<I> extends AbstractTestContextFixture<I> {
+}
+/**
+ * @deprecated Use AbstractChildTestContextFixture from shared instead. This is kept for backwards compatibility.
+ */
+export declare abstract class AbstractChildJestTestContextFixture<I, P extends TestContextFixture<any>> extends AbstractChildTestContextFixture<I, P> {
+}
+/**
+ * @deprecated Use BuildTestsWithContextFunction from shared instead. This is kept for backwards compatibility.
+ */
+export type JestBuildTestsWithContextFunction<F> = BuildTestsWithContextFunction<F>;
+/**
+ * @deprecated Use TestContextFactory from shared instead. This is kept for backwards compatibility.
+ */
+export type JestTestContextFactory<F> = TestContextFactory<F>;
+/**
+ * @deprecated Use TestContextBuilderFunction from shared instead. This is kept for backwards compatibility.
+ */
+export type JestTestContextBuilderFunction<I, F extends TestContextFixture<I>, C> = TestContextBuilderFunction<I, F, C>;
+/**
+ * @deprecated Use TestContextBuilderConfig from shared instead. This is kept for backwards compatibility.
+ */
+export type JestTestContextBuilderConfig<I, F extends TestContextFixture<I>, C> = TestContextBuilderConfig<I, F, C>;
+/**
+ * @deprecated Use testContextBuilder from shared instead. This is kept for backwards compatibility.
+ */
+export declare const jestTestContextBuilder: typeof testContextBuilder;
+/**
+ * @deprecated Use UseContextFixture from shared instead. This is kept for backwards compatibility.
+ */
+export type UseJestContextFixture<C extends TestContextFixture<I>, I> = UseContextFixture<C, I>;
+/**
+ * @deprecated Use useContextFixture from shared instead. This is kept for backwards compatibility.
+ */
+export declare const useJestContextFixture: typeof useTestContextFixture;

package/test/src/lib/jest/jest.fail.d.ts

@@ -0,0 +1,72 @@
+/**
+ * https://github.com/facebook/jest/issues/11698
+ *
+ * Since fail() was silently removed, we redefine it.
+ */
+import { type TestDoneCallback, failWithTestDoneCallback, type TestProvidesCallbackWithDone, type TestProvidesCallback } from '../shared';
+import { ExpectedFailError, failSuccessfullyError, failSuccessfully, UnexpectedSuccessFailureError, failDueToSuccessError, ExpectedErrorOfSpecificTypeError, failTest, failDueToSuccess, EXPECT_ERROR_DEFAULT_HANDLER, type ExpectFailAssertionFunction, expectFailAssertErrorType, expectFail, expectSuccessfulFail, type ShouldFailDoneCallback, type ShouldFailProvidesCallbackWithDone, type ShouldFailProvidesCallbackWithResult, type ShouldFailProvidesCallback, type FakeDoneHandler } from '../shared/shared.fail';
+/**
+ * @deprecated Use TestDoneCallback from shared instead. This is kept for backwards compatibility.
+ */
+export type JestDoneCallback = TestDoneCallback;
+/**
+ * @deprecated Use failWithTestDoneCallback from shared instead. This is kept for backwards compatibility.
+ */
+export declare const failWithJestDoneCallback: typeof failWithTestDoneCallback;
+/**
+ * @deprecated Use TestProvidesCallbackWithDone from shared instead. This is kept for backwards compatibility.
+ */
+export type JestProvidesCallbackWithDone = TestProvidesCallbackWithDone;
+/**
+ * @deprecated Use TestProvidesCallback from shared instead. This is kept for backwards compatibility.
+ */
+export type JestProvidesCallback = TestProvidesCallback;
+/**
+ * @deprecated Use ExpectedFailError from shared instead. This is kept for backwards compatibility.
+ */
+export declare class JestExpectedFailError extends ExpectedFailError {
+}
+/**
+ * @deprecated Use UnexpectedSuccessFailureError from shared instead. This is kept for backwards compatibility.
+ */
+export declare class JestUnexpectedSuccessFailureError extends UnexpectedSuccessFailureError {
+}
+/**
+ * @deprecated Use ExpectedErrorOfSpecificTypeError from shared instead. This is kept for backwards compatibility.
+ */
+export declare class JestExpectedErrorOfSpecificTypeError extends ExpectedErrorOfSpecificTypeError {
+}
+/**
+ * @deprecated Use failWithTestDoneCallback with failDueToSuccessError from shared instead. This is kept for backwards compatibility.
+ */
+export declare function failWithDoneDueToSuccess(done: TestDoneCallback): void;
+export { failSuccessfullyError, failSuccessfully, failDueToSuccessError, failTest, failDueToSuccess, EXPECT_ERROR_DEFAULT_HANDLER };
+/**
+ * @deprecated Use ExpectFailAssertionFunction from shared instead. This is kept for backwards compatibility.
+ */
+export type JestExpectFailAssertionFunction = ExpectFailAssertionFunction;
+/**
+ * @deprecated Use expectFailAssertErrorType from shared instead. This is kept for backwards compatibility.
+ */
+export declare const jestExpectFailAssertErrorType: typeof expectFailAssertErrorType;
+export { expectFail, expectSuccessfulFail };
+/**
+ * @deprecated Use ShouldFailDoneCallback from shared instead. This is kept for backwards compatibility.
+ */
+export type JestShouldFailDoneCallback = ShouldFailDoneCallback;
+/**
+ * @deprecated Use ShouldFailProvidesCallbackWithDone from shared instead. This is kept for backwards compatibility.
+ */
+export type JestShouldFailProvidesCallbackWithDone = ShouldFailProvidesCallbackWithDone;
+/**
+ * @deprecated Use ShouldFailProvidesCallbackWithResult from shared instead. This is kept for backwards compatibility.
+ */
+export type JestShouldFailProvidesCallbackWithResult = ShouldFailProvidesCallbackWithResult;
+/**
+ * @deprecated Use ShouldFailProvidesCallback from shared instead. This is kept for backwards compatibility.
+ */
+export type JestShouldFailProvidesCallback = ShouldFailProvidesCallback;
+/**
+ * @deprecated Use FakeDoneHandler from shared instead. This is kept for backwards compatibility.
+ */
+export type JestFakeDoneHandler = FakeDoneHandler;

package/test/src/lib/jest/jest.function.d.ts

@@ -0,0 +1,41 @@
+import { type UseTestFunctionFixtureFunctionGetter, type UseTestFunctionFixture, type TestFunctionFixtureBuildTests, useTestFunctionFixture, type UseTestFunctionMapObject, type UseTestFunctionMapFixture, type UseTestFunctionMapFixtureGetterFunctions, type UseTestFunctionMapFixtureFunctions, type TestFunctionFixtureMapBuildTests, useTestFunctionMapFixture } from '../shared/shared.function';
+/**
+ * @deprecated Use UseTestFunctionFixtureFunctionGetter from shared instead. This is kept for backwards compatibility.
+ */
+export type UseJestFunctionFixtureFunctionGetter<I extends (...args: any[]) => O, O = any> = UseTestFunctionFixtureFunctionGetter<I, O>;
+/**
+ * @deprecated Use UseTestFunctionFixture from shared instead. This is kept for backwards compatibility.
+ */
+export type UseJestFunctionFixture<I extends (...args: any[]) => O, O = any> = UseTestFunctionFixture<I, O>;
+/**
+ * @deprecated Use TestFunctionFixtureBuildTests from shared instead. This is kept for backwards compatibility.
+ */
+export type JestFunctionFixtureBuildTests<I> = TestFunctionFixtureBuildTests<I>;
+/**
+ * @deprecated Use useTestFunctionFixture from shared instead. This is kept for backwards compatibility.
+ */
+export declare const useJestFunctionFixture: typeof useTestFunctionFixture;
+/**
+ * @deprecated Use UseTestFunctionMapObject from shared instead. This is kept for backwards compatibility.
+ */
+export type UseJestFunctionMapObject = UseTestFunctionMapObject;
+/**
+ * @deprecated Use UseTestFunctionMapFixture from shared instead. This is kept for backwards compatibility.
+ */
+export type UseJestFunctionMapFixture<T extends UseTestFunctionMapObject> = UseTestFunctionMapFixture<T>;
+/**
+ * @deprecated Use UseTestFunctionMapFixtureGetterFunctions from shared instead. This is kept for backwards compatibility.
+ */
+export type UseJestFunctionMapFixtureGetterFunctions<T extends UseTestFunctionMapObject> = UseTestFunctionMapFixtureGetterFunctions<T>;
+/**
+ * @deprecated Use UseTestFunctionMapFixtureFunctions from shared instead. This is kept for backwards compatibility.
+ */
+export type UseJestFunctionMapFixtureFunctions<T extends UseTestFunctionMapObject> = UseTestFunctionMapFixtureFunctions<T>;
+/**
+ * @deprecated Use TestFunctionFixtureMapBuildTests from shared instead. This is kept for backwards compatibility.
+ */
+export type JestFunctionFixtureMapBuildTests<T extends UseTestFunctionMapObject> = TestFunctionFixtureMapBuildTests<T>;
+/**
+ * @deprecated Use useTestFunctionMapFixture from shared instead. This is kept for backwards compatibility.
+ */
+export declare const useJestFunctionMapFixture: typeof useTestFunctionMapFixture;

package/test/src/lib/jest/jest.wrap.d.ts

@@ -0,0 +1,24 @@
+import { type AbstractWrappedFixtureWithInstance, type WrapTestContextConfig, wrapTestContextFactory, type InstanceWrapTestContextConfig, instanceWrapTestContextFactory, type TestWrappedContextFactoryBuilder } from '../shared/shared.wrap';
+/**
+ * @deprecated Use TestWrappedContextFactoryBuilder from shared instead. This is kept for backwards compatibility.
+ */
+export type JestTestWrappedContextFactoryBuilder<W, F> = TestWrappedContextFactoryBuilder<W, F>;
+/**
+ * @deprecated Use WrapTestContextConfig from shared instead. This is kept for backwards compatibility.
+ */
+export type JestWrapTestContextConfig<W, F, E = any> = WrapTestContextConfig<W, F, E>;
+/**
+ * Wraps the input JestTestContextFactory to emit another type of Fixture for tests.
+ *
+ * @deprecated Use wrapTestContextFactory from shared instead. This is kept for backwards compatibility.
+ * @returns
+ */
+export declare const wrapJestTestContextFactory: typeof wrapTestContextFactory;
+/**
+ * @deprecated Use InstanceWrapTestContextConfig from shared instead. This is kept for backwards compatibility.
+ */
+export type InstanceJestWrapTestContextConfig<I, W extends AbstractWrappedFixtureWithInstance<I, F>, F> = InstanceWrapTestContextConfig<I, W, F>;
+/**
+ * @deprecated Use instanceWrapTestContextFactory from shared instead. This is kept for backwards compatibility.
+ */
+export declare const instanceWrapJestTestContextFactory: typeof instanceWrapTestContextFactory;

package/test/src/lib/shared/index.d.ts

@@ -0,0 +1,4 @@
+export * from './shared';
+export * from './shared.wrap';
+export * from './shared.function';
+export * from './shared.fail';

package/test/src/lib/shared/shared.d.ts

@@ -0,0 +1,154 @@
+import { type PromiseOrValue, type PromiseReference } from '@dereekb/util';
+/**
+ * A done callback function used by test frameworks to signal that a test has completed.
+ *
+ * Most modern test frameworks have deprecated the "done" callback in favor of async/await.
+ */
+export type TestDoneCallback = ((...args: any[]) => any) & {
+    /**
+     * NOTE: Not available in all test frameworks, but here for legacy purposes.
+     *
+     * @param error
+     */
+    fail(error?: string | {
+        message: string;
+    }): any;
+};
+/**
+ * Passes the error to the TestDoneCallback.
+ * @param done
+ * @param e
+ */
+export declare function failWithTestDoneCallback(done: TestDoneCallback, e?: unknown): void;
+export type TestProvidesCallbackWithDone = (cb: TestDoneCallback) => void | undefined;
+export type TestProvidesCallback = TestProvidesCallbackWithDone | (() => Promise<unknown>);
+export type TestDoneCallbackRef = Omit<TestDoneCallback, 'fail'> & {
+    readonly _promise: PromiseReference<void>;
+    readonly done: TestDoneCallback;
+};
+/**
+ * Creates a new TestDoneCallbackRef.
+ *
+ * Used to create a promise reference that can be used to assert that a test function was called.
+ */
+export declare function testDoneCallbackRef(): TestDoneCallbackRef;
+/**
+ * Wraps a callback-based test (using done) for Vitest compatibility.
+ * Converts the callback pattern to a Promise-based pattern.
+ *
+ * This also supports calling the input test with async, but still only returns when done is called.
+ *
+ * @example
+ *
+ * // Before (Jasmine/Jest style):
+ * it('test name', (done) => {
+ *   // async test code
+ *   done();
+ * });
+ *
+ * // After (Vitest compatible):
+ * it('test name', callbackTest((done) => {
+ *   // async test code
+ *   done();
+ * }));
+ */
+export declare function callbackTest(testFn: TestProvidesCallbackWithDone | ((cb: TestDoneCallback) => PromiseOrValue<void | undefined>)): () => Promise<void>;
+/**
+ * A fixture instance that is generated new for each test run.
+ */
+export type TestFixtureInstance<I> = I;
+/**
+ * The test fixture is used as a singleton across tests used in a single context.
+ *
+ * This allows us to define tests while referencing the instance.
+ */
+export interface TestFixture<I> {
+    readonly instance: TestFixtureInstance<I>;
+}
+export type TestContextFixtureClearInstanceFunction = () => void;
+/**
+ * TestFixture with additional functions that the TestContextFactory sees for managing the instance.
+ *
+ * The fixture is used as a reference point for the Instance that is changed between each test.
+ */
+export interface TestContextFixture<I> extends TestFixture<I> {
+    /**
+     * Sets the instance before the tests run, and returns a function to clean the instance later.
+     *
+     * If called again before the instance is finished being used, this should throw an exception.
+     *
+     * @param instance
+     */
+    setInstance(instance: I): TestContextFixtureClearInstanceFunction;
+}
+/**
+ * Abstract TestContextFixture instance.
+ */
+export declare abstract class AbstractTestContextFixture<I> implements TestContextFixture<I> {
+    private _instance?;
+    get instance(): I;
+    setInstance(instance: I): TestContextFixtureClearInstanceFunction;
+}
+/**
+ * Abstract TestContextFixture instance with a parent.
+ */
+export declare abstract class AbstractChildTestContextFixture<I, P extends TestContextFixture<any>> extends AbstractTestContextFixture<I> {
+    readonly parent: P;
+    constructor(parent: P);
+}
+export type BuildTestsWithContextFunction<F> = (fixture: F) => void;
+/**
+ * Used for tests to execute a number of tests using the fixture.
+ *
+ * The fixture is automatically setup and torn down each test per the configuration with a clean fixture instance.
+ */
+export type TestContextFactory<F> = (buildTests: BuildTestsWithContextFunction<F>) => void;
+/**
+ * Used to configure a TestContextFactory for building tests.
+ */
+export type TestContextBuilderFunction<I, F extends TestContextFixture<I>, C> = (config?: Partial<C>) => TestContextFactory<F>;
+export interface TestContextBuilderConfig<I, F extends TestContextFixture<I>, C> {
+    /**
+     * Builds a config given the optional, partial input config. This is used across all tests.
+     */
+    buildConfig: (config?: Partial<C>) => C;
+    /**
+     * Builds a new fixture to use across all encapsulated tests.
+     */
+    buildFixture: (config: C) => F;
+    /**
+     * Arbitrary before each function, called before the instance is setup.
+     */
+    beforeEach?: () => Promise<void>;
+    /**
+     * Use for building an instance.
+     *
+     * When the promise resolves it should be ready to be used by the test being executed.
+     */
+    setupInstance: (config: C) => Promise<I>;
+    /**
+     * Use for cleaning up the instance before the next test.
+     */
+    teardownInstance: (instance: I, config: C) => Promise<void>;
+    /**
+     * Arbitrary after each function.
+     */
+    afterEach?: () => Promise<void>;
+}
+/**
+ * Creates a TestContextBuilderFunction given the input builder.
+ *
+ * @param builder
+ * @returns
+ */
+export declare function testContextBuilder<I, F extends TestContextFixture<I>, C>(builder: TestContextBuilderConfig<I, F, C>): TestContextBuilderFunction<I, F, C>;
+export interface UseContextFixture<C extends TestContextFixture<I>, I> {
+    readonly fixture: C;
+    readonly buildTests: BuildTestsWithContextFunction<C>;
+    initInstance(): PromiseOrValue<I>;
+    destroyInstance?(instance: I): PromiseOrValue<void>;
+}
+/**
+ * Creates a test context and configurations that will initialize an instance
+ */
+export declare function useTestContextFixture<C extends TestContextFixture<I>, I>(config: UseContextFixture<C, I>): void;

package/test/src/lib/shared/shared.fail.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Testing utilities for handling expected failures and errors.
+ */
+import { type PromiseReference, type PromiseOrValue, type ClassType, type Maybe, type ClassLikeType } from '@dereekb/util';
+import { BaseError } from 'make-error';
+import { type TestDoneCallback } from './shared';
+/**
+ * Error thrown by fail() and used by expectError()
+ */
+export declare class ExpectedFailError extends BaseError {
+}
+export declare function failSuccessfullyError(message?: string): ExpectedFailError;
+export declare function failSuccessfully(message?: string): never;
+/**
+ * Error thrown when success occurs when it should not have.
+ */
+export declare class UnexpectedSuccessFailureError extends BaseError {
+}
+export declare function failDueToSuccessError(message?: string): UnexpectedSuccessFailureError;
+/**
+ * Error thrown when the error type was different than the expected type.
+ */
+export declare class ExpectedErrorOfSpecificTypeError extends BaseError {
+    readonly encounteredType: unknown;
+    readonly expectedType?: Maybe<ClassLikeType | string>;
+    constructor(encounteredType: unknown, expectedType?: Maybe<ClassLikeType | string>);
+}
+export declare function failTest(message?: string): never;
+export declare function failDueToSuccess(): never;
+export declare function EXPECT_ERROR_DEFAULT_HANDLER(e: unknown): void;
+/**
+ * Used to assert additional information about the expected error.
+ *
+ * Can assert within this function, or return a boolean. A boolean returning false means the test should throw an ExpectedErrorOfSpecificTypeError.
+ */
+export type ExpectFailAssertionFunction = (error: unknown) => PromiseOrValue<Maybe<boolean> | void>;
+/**
+ * Creates an ExpectFailAssertionFunction that asserts the encountered error is of the expected type using the instanceof keyword.
+ *
+ * Throws an ExpectedErrorOfSpecificTypeError on failures.
+ *
+ * @param expectedType
+ * @returns
+ */
+export declare function expectFailAssertErrorType(expectedType: ClassType | ClassLikeType | typeof Error | any): ExpectFailAssertionFunction;
+/**
+ * Function that expects any failure to be thrown, then throws an ExpectedFailError.
+ *
+ * @param errorFn
+ * @param handleError
+ */
+export declare function expectFail(errorFn: () => void, assertFailType?: ExpectFailAssertionFunction): void;
+export declare function expectFail(errorFn: () => Promise<void>, assertFailType?: ExpectFailAssertionFunction): Promise<void>;
+/**
+ * Function that expects an ExpectedFailError to be thrown.
+ *
+ * @param errorFn
+ * @param handleError
+ */
+export declare function expectSuccessfulFail(errorFn: () => void, handleError?: (e: unknown) => void): void;
+export declare function expectSuccessfulFail(errorFn: () => Promise<void>, handleError?: (e: unknown) => void): Promise<void>;
+export interface ShouldFailDoneCallback extends TestDoneCallback {
+    failSuccessfully(): void;
+}
+export type ShouldFailProvidesCallbackWithDone = (cb: ShouldFailDoneCallback) => void | undefined;
+export type ShouldFailProvidesCallbackWithResult = () => PromiseOrValue<unknown>;
+export type ShouldFailProvidesCallback = ShouldFailProvidesCallbackWithDone | ShouldFailProvidesCallbackWithResult;
+/**
+ * Used to wrap a testing function and watch for ExpectedFailError errors in order to pass the test. Other exceptions are treated normally as failures.
+ *
+ * This is typically used in conjunction with failSuccessfully(), expectSuccessfulFail(), or expectFail().
+ *
+ * @param fn
+ * @param strict
+ * @returns
+ */
+export declare function shouldFail(fn: ShouldFailProvidesCallback): () => Promise<unknown>;
+export declare function itShouldFail(fn: ShouldFailProvidesCallback): void;
+export declare function itShouldFail(describe: string, fn: ShouldFailProvidesCallback): void;
+export interface FakeDoneHandler extends TestDoneCallback, PromiseReference {
+    _ref: PromiseReference;
+}
+export declare function fakeDoneHandler(): FakeDoneHandler;

package/test/src/lib/shared/shared.function.d.ts

@@ -0,0 +1,25 @@
+import { type Getter } from '@dereekb/util';
+export type UseTestFunctionFixtureFunctionGetter<I extends (...args: any[]) => O, O = any> = Getter<I>;
+export interface UseTestFunctionFixture<I extends (...args: any[]) => O, O = any> {
+    fn: Getter<I>;
+}
+export type TestFunctionFixtureBuildTests<I> = (fn: I) => void;
+/**
+ * Creates a test context and configurations that provides a function to build tests based on the configuration.
+ */
+export declare function useTestFunctionFixture<I extends (...args: any[]) => O, O = any>(config: UseTestFunctionFixture<I, O>, buildTests: TestFunctionFixtureBuildTests<I>): void;
+export type UseTestFunctionMapObject = Record<string, (...args: any[]) => any>;
+export type UseTestFunctionMapFixture<T extends UseTestFunctionMapObject> = {
+    fns: UseTestFunctionMapFixtureGetterFunctions<T>;
+};
+export type UseTestFunctionMapFixtureGetterFunctions<T extends UseTestFunctionMapObject> = {
+    [K in keyof T]: T[K] extends UseTestFunctionFixtureFunctionGetter<infer I, infer O> ? T[K] : never;
+};
+export type UseTestFunctionMapFixtureFunctions<T extends UseTestFunctionMapObject> = {
+    [K in keyof T]: T[K] extends UseTestFunctionFixtureFunctionGetter<infer I, infer O> ? I : never;
+};
+export type TestFunctionFixtureMapBuildTests<T extends UseTestFunctionMapObject> = (fixture: UseTestFunctionMapFixtureFunctions<T>) => void;
+/**
+ * Creates a test context and configurations that provides a function to build tests based on the configuration.
+ */
+export declare function useTestFunctionMapFixture<T extends UseTestFunctionMapObject>(config: UseTestFunctionMapFixture<T>, buildTests: TestFunctionFixtureMapBuildTests<T>): void;

package/test/src/lib/{jest.wrap.d.ts → shared/shared.wrap.d.ts}

@@ -1,20 +1,20 @@
-import { AbstractJestTestContextFixture, type JestTestContextFactory } from './jest';
+import { AbstractTestContextFixture, type TestContextFactory } from './shared';
 export declare abstract class AbstractWrappedFixture<F> {
     readonly fixture: F;
     constructor(fixture: F);
 }
-export declare abstract class AbstractWrappedFixtureWithInstance<I, F> extends AbstractJestTestContextFixture<I> {
+export declare abstract class AbstractWrappedFixtureWithInstance<I, F> extends AbstractTestContextFixture<I> {
     readonly parent: F;
     constructor(parent: F);
 }
 /**
- * Used to wrap a JestTestContextFactory of one fixture type to another.
+ * Used to wrap a TestContextFactory of one fixture type to another.
  *
  * This is useful for cases where the base fixture may be used in a lot of places and contexts, but the wrapped version can configure
  * tests more specifically.
  */
-export type JestTestWrappedContextFactoryBuilder<W, F> = (factory: JestTestContextFactory<F>) => JestTestContextFactory<W>;
-export interface JestWrapTestContextConfig<W, F, E = any> {
+export type TestWrappedContextFactoryBuilder<W, F> = (factory: TestContextFactory<F>) => TestContextFactory<W>;
+export interface WrapTestContextConfig<W, F, E = any> {
     /**
      * Wraps the fixture. This occurs once before any tests execute.
      */
@@ -35,12 +35,12 @@ export interface JestWrapTestContextConfig<W, F, E = any> {
     teardownWrap?: (wrap: W, effect: E) => Promise<void>;
 }
 /**
- * Wraps the input JestTestContextFactory to emit another type of Fixture for tests.
+ * Wraps the input TestContextFactory to emit another type of Fixture for tests.
  *
  * @returns
  */
-export declare function wrapJestTestContextFactory<W, F, E = any>(config: JestWrapTestContextConfig<W, F, E>): (factory: JestTestContextFactory<F>) => JestTestContextFactory<W>;
-export interface InstanceJestWrapTestContextConfig<I, W extends AbstractWrappedFixtureWithInstance<I, F>, F> extends Pick<JestWrapTestContextConfig<W, F>, 'wrapFixture'> {
+export declare function wrapTestContextFactory<W, F, E = any>(config: WrapTestContextConfig<W, F, E>): (factory: TestContextFactory<F>) => TestContextFactory<W>;
+export interface InstanceWrapTestContextConfig<I, W extends AbstractWrappedFixtureWithInstance<I, F>, F> extends Pick<WrapTestContextConfig<W, F>, 'wrapFixture'> {
     /**
      * Creates a new instance for the tests.
      */
@@ -58,4 +58,4 @@ export interface InstanceJestWrapTestContextConfig<I, W extends AbstractWrappedF
      */
     teardownInstance?: (instance: I) => void | Promise<void>;
 }
-export declare function instanceWrapJestTestContextFactory<I, W extends AbstractWrappedFixtureWithInstance<I, F>, F>(config: InstanceJestWrapTestContextConfig<I, W, F>): (factory: JestTestContextFactory<F>) => JestTestContextFactory<W>;
+export declare function instanceWrapTestContextFactory<I, W extends AbstractWrappedFixtureWithInstance<I, F>, F>(config: InstanceWrapTestContextConfig<I, W, F>): (factory: TestContextFactory<F>) => TestContextFactory<W>;

package/index.esm.d.ts

@@ -1 +0,0 @@
-export * from "./src/index";

package/src/lib/page/page.calculator.d.ts

@@ -1,29 +0,0 @@
-import { type PageNumber, type Page } from './page';
-/**
- * @deprecated
- */
-export interface PageCalculatorConfig {
-    pageSize: number;
-    limitKey?: string;
-    skipKey?: string;
-}
-/**
- * Page calculation context for calculating the amount to skip/etc.
- *
- * @deprecated
- */
-export declare class PageCalculator {
-    readonly pageSize: number;
-    readonly limitKey: string;
-    readonly skipKey: string;
-    constructor(config: PageCalculatorConfig);
-    get limit(): number;
-    calcWithPage(page?: Page): {
-        [x: string]: number;
-    };
-    calc(page?: PageNumber): {
-        [x: string]: number;
-    };
-    calcSkipWithPage(page?: Page): number;
-    calcSkip(page?: PageNumber): number;
-}