@voxpelli/typed-utils/lib/assert.d.ts

My personal (type-enabled) utils / helpers

/**
 * @param {boolean} condition
 * @param {string} message
 * @returns {asserts condition}
 */
export function assert(condition: boolean, message: string): asserts condition;
/**
 * @template T
 * @param {unknown} actual
 * @param {T} expected
 * @param {string} [message]
 * @returns {asserts actual is T}
 * @see https://nodejs.org/api/assert.html#assertstrictequalactual-expected-message
 * @see https://www.chaijs.com/api/assert/#method_strictequal
 * @see https://www.npmjs.com/package/jest-diff
 */
export function assertStrictEqual<T>(actual: unknown, expected: T, message?: string): asserts actual is T;
/**
 * @param {unknown} obj
 * @returns {asserts obj is Record<string, unknown>}
 */
export function assertObject(obj: unknown): asserts obj is Record<string, unknown>;
/**
 * @template {string} K
 * @param {unknown} obj
 * @param {K} key
 * @returns {asserts obj is Record<K, unknown>}
 */
export function assertObjectWithKey<K extends string>(obj: unknown, key: K): asserts obj is Record<K, unknown>;
/**
 * @template {keyof LiteralTypes} T
 * @param {unknown} value
 * @param {T | T[]} type
 * @param {string} [message]
 * @returns {asserts value is LiteralTypes[T]}
 */
export function assertType<T extends keyof LiteralTypes>(value: unknown, type: T | T[], message?: string): asserts value is LiteralTypes[T];
/**
 * @template {string} K
 * @template {keyof LiteralTypes} T
 * @param {unknown} obj
 * @param {K} key
 * @param {T | T[]} type
 * @returns {asserts obj is Record<K, LiteralTypes[T]>}
 */
export function assertKeyWithType<K extends string, T extends keyof LiteralTypes>(obj: unknown, key: K, type: T | T[]): asserts obj is Record<K, LiteralTypes[T]>;
/**
 * @template {string} K
 * @template {keyof LiteralTypes} T
 * @param {unknown} obj
 * @param {K} key
 * @param {T | T[]} type
 * @returns {asserts obj is Partial<Record<K, LiteralTypes[T]>>}
 */
export function assertOptionalKeyWithType<K extends string, T extends keyof LiteralTypes>(obj: unknown, key: K, type: T | T[]): asserts obj is Partial<Record<K, LiteralTypes[T]>>;
/**
 * @template {string} K
 * @template T
 * @param {unknown} obj
 * @param {K} key
 * @param {T} value
 * @returns {asserts obj is Record<K, T>}
 */
export function assertKeyWithValue<K extends string, T>(obj: unknown, key: K, value: T): asserts obj is Record<K, T>;
/**
 * @template {keyof LiteralTypes} T
 * @param {unknown} value
 * @param {T | T[]} type
 * @param {string} [message]
 * @returns {asserts value is Array<LiteralTypes[T]>}
 */
export function assertArrayOfLiteralType<T extends keyof LiteralTypes>(value: unknown, type: T | T[], message?: string): asserts value is Array<LiteralTypes[T]>;
/**
 * @template {keyof LiteralTypes} T
 * @param {unknown} obj
 * @param {T | T[]} type
 * @returns {asserts obj is Record<string, LiteralTypes[T]>}
 */
export function assertObjectValueType<T extends keyof LiteralTypes>(obj: unknown, type: T | T[]): asserts obj is Record<string, LiteralTypes[T]>;
/** @import { LiteralTypes } from './types/literal-types.d.ts' */
/** @typedef {((...args: any[]) => any) | (new (...args: any[]) => any)} StackStartFn */
export class TypeHelpersAssertionError extends Error {
    /**
     * @param {string} message
     * @param {{ stackStartFn?: StackStartFn | undefined }} [options]
     */
    constructor(message: string, { stackStartFn }?: {
        stackStartFn?: StackStartFn | undefined;
    });
}
/**
 * @template [Actual=unknown]
 * @template [Expected=unknown]
 * @template [Operator=string]
 * @see https://nodejs.org/api/assert.html#class-assertassertionerror
 * @see https://www.chaijs.com/api/assert/#method_strictequal
 * @see https://github.com/voxpelli/node-test-pretty-reporter#rendering-diffs-from-assertions
 */
export class TypeHelpersAssertionEqualityError<Actual = unknown, Expected = unknown, Operator = string> extends TypeHelpersAssertionError {
    /**
     * @param {Actual} actual
     * @param {Expected} expected
     * @param {Operator} operator
     * @param {string} message
     * @param {{
     *   diff?: 'simple' | 'full' | undefined,
     *   showDiff?: boolean | undefined,
     *   stackStartFn?: StackStartFn | undefined,
     * }} [options]
     */
    constructor(actual: Actual, expected: Expected, operator: Operator, message: string, { diff, showDiff, stackStartFn, }?: {
        diff?: "simple" | "full" | undefined;
        showDiff?: boolean | undefined;
        stackStartFn?: StackStartFn | undefined;
    });
    /** @type {Actual} */
    actual: Actual;
    /** @type {'simple' | 'full'} */
    diff: "simple" | "full";
    /** @type {Expected} */
    expected: Expected;
    /** @type {Operator} */
    operator: Operator;
    /** @type {boolean} */
    showDiff: boolean;
}
export type StackStartFn = ((...args: any[]) => any) | (new (...args: any[]) => any);
import type { LiteralTypes } from './types/literal-types.d.ts';
//# sourceMappingURL=assert.d.ts.map