@fgv/ts-utils-jest 5.0.0-22 → 5.0.0-24

package/src/types/index.ts

@@ -1,107 +0,0 @@
-/// <reference types="jest"/>
-
-// eslint-disable-next-line @typescript-eslint/naming-convention, @typescript-eslint/no-explicit-any
-export type Function = (...args: any[]) => any;
-
-// eslint-disable-next-line @typescript-eslint/no-unused-vars,no-unused-vars
-import { ResultDetailType, ResultValueType } from '@fgv/ts-utils';
-
-/* eslint-disable @typescript-eslint/no-unused-vars,no-unused-vars */
-declare global {
-  // eslint-disable-next-line @typescript-eslint/no-namespace
-  namespace jest {
-    // eslint-disable-next-line @typescript-eslint/naming-convention
-    interface Matchers<R, T> {
-      /**
-       * Use .toSucceed to verify that a Result\<T\> is a success
-       */
-      toSucceed(): R;
-
-      /**
-       * Use .toSucceedWith to verify that a Result\<T\> is a success
-       * and that the result value matches the supplied value
-       * @param expected -
-       */
-      toSucceedWith(expected: ResultValueType<T> | RegExp): R;
-
-      /**
-       * Use .toSucceedWithDetail to verify that a DetailedResult\<T, TD\> is
-       * a success and that the result value and detail matches the supplied
-       * values
-       * @param expected -
-       * @param detail -
-       */
-      toSucceedWithDetail(expected: ResultValueType<T>, detail: ResultDetailType<T> | undefined): R;
-
-      /**
-       * Use .toSucceedAndSatisfy to verify that a Result\<T\> is a success
-       * and that the supplied test function returns true (or void)
-       * for the resulting value
-       * @param test -
-       */
-      toSucceedAndSatisfy(test: (value: ResultValueType<T>) => boolean | void): R;
-
-      /**
-       * Use .toSucceedAndMatchInlineSnapshot to verify that a Result\<T\> is a success
-       * and that the result value matches an inline snapshot
-       */
-      toSucceedAndMatchInlineSnapshot(snapshot: string | undefined): R;
-
-      /**
-       * Use .toSucceedAndMatchSnapshot to verify that a Result\<T\> is a success
-       * and that the result value matches a stored snapshot
-       */
-      toSucceedAndMatchSnapshot(): R;
-
-      /**
-       * Use .toFail to verify that a Result\<T\> is a failure
-       */
-      toFail(): R;
-
-      /**
-       * Use .toFailWith to verify that a Result\<T\> is a failure
-       * that matches a supplied string, RegExp or undefined value
-       * @param message -
-       */
-      toFailWith(expected: string | RegExp | undefined): R;
-
-      /**
-       * Use .toFailWithDetail to verify that a DetailedResult\<T\> is
-       * a failure that matches both a supplied expected failure value
-       * (string, RegExp or undefined) and a supplied failure detail.
-       * @param message -
-       * @param detail -
-       */
-      toFailWithDetail<TDetail>(message: string | RegExp, detail: TDetail): R;
-      toFailWithDetail(message: string | RegExp | undefined, detail: ResultDetailType<T>): R;
-
-      /**
-       * Use .toFailTest to test a custom matcher by
-       * verifying that a test case fails.
-       */
-      toFailTest(): R;
-
-      /**
-       * Use .toFailTestWith to test a custom matcher by
-       * verifying that a test case fails as expected and
-       * reports an error matching a stored snapshot.
-       */
-      toFailTestAndMatchSnapshot(): R;
-
-      /**
-       * Use .toFailTestWith to test a custom matcher by
-       * verifying that a test case fails as expected and
-       * reports an error matching a supplied value.
-       * @param expected -
-       */
-      toFailTestWith(expected: string | string[] | RegExp): R;
-
-      /**
-       * Use .toSucceedWith to verify that a Result\<T\> is a success
-       * and that the result value matches the supplied value
-       * @param expected -
-       */
-      toHaveBeenCalledWithArgumentsMatching(expected: unknown): R;
-    }
-  }
-}

package/src/utils/colorHelpers.ts

@@ -1,82 +0,0 @@
-/**
- * Utility functions for handling ANSI color codes in test output.
- *
- * @packageDocumentation
- */
-
-/**
- * Regular expression to match ANSI color/style escape sequences.
- *
- * This matches:
- * - ESC character (ASCII 27) followed by `[`
- * - `[0-9;]*` - Zero or more digits and semicolons (parameters)
- * - `[a-zA-Z]` - Single letter command (m for SGR, K for erase, etc.)
- *
- * Examples of what this matches:
- * - `\u001b[31m` - Red foreground
- * - `\u001b[39m` - Default foreground
- * - `\u001b[2m` - Dim/faint
- * - `\u001b[22m` - Normal intensity
- *
- * Using a pre-compiled regex literal to satisfy ESLint security requirements.
- * We use the unicode escape sequence \\u001b instead of \\x1b to avoid control-regex warnings.
- */
-// eslint-disable-next-line @rushstack/security/no-unsafe-regexp, no-control-regex
-const ANSI_COLOR_REGEX: RegExp = /\u001b\[[0-9;]*[a-zA-Z]/g;
-
-/**
- * Strips ANSI color/style escape sequences from a string.
- *
- * This function removes all ANSI escape sequences commonly used for
- * terminal colors and text styling, making the output suitable for
- * color-agnostic snapshot testing.
- *
- * @param text - The text that may contain ANSI escape sequences
- * @returns The text with all ANSI escape sequences removed
- *
- * @example
- * ```typescript
- * const coloredText = '\u001b[31mError:\u001b[39m Something failed';
- * const plainText = stripAnsiColors(coloredText);
- * console.log(plainText); // "Error: Something failed"
- * ```
- *
- * @example
- * ```typescript
- * // Common usage in Jest matchers
- * const formattedOutput = matcherUtils.printReceived(value);
- * const cleanOutput = stripAnsiColors(formattedOutput);
- * expect(cleanOutput).toMatchSnapshot();
- * ```
- *
- * @public
- */
-export function stripAnsiColors(text: string): string {
-  return text.replace(ANSI_COLOR_REGEX, '');
-}
-
-/**
- * Creates a wrapper function that strips ANSI colors from any string-returning function.
- *
- * This is useful for wrapping Jest matcher utility functions to make them
- * color-agnostic for snapshot testing.
- *
- * @param fn - A function that returns a string (potentially with ANSI colors)
- * @returns A wrapped function that returns the same string with colors stripped
- *
- * @example
- * ```typescript
- * import { printReceived } from 'jest-matcher-utils';
- *
- * const printReceivedClean = createColorStripWrapper(printReceived);
- * const output = printReceivedClean(someValue); // No colors
- * ```
- *
- * @public
- */
-export function createColorStripWrapper<T extends (...args: unknown[]) => string>(fn: T): T {
-  return ((...args: Parameters<T>) => {
-    const result = fn(...args);
-    return stripAnsiColors(result);
-  }) as T;
-}

package/src/utils/matcherHelpers.ts

@@ -1,64 +0,0 @@
-import { printExpected, printReceived } from 'jest-matcher-utils';
-import { DetailedResult, Result } from '../ts-utils';
-import { createColorStripWrapper } from './colorHelpers';
-
-// Create color-stripped versions of Jest matcher utilities
-const printExpectedClean: typeof printExpected = createColorStripWrapper(printExpected);
-const printReceivedClean: typeof printReceived = createColorStripWrapper(printReceived);
-
-function printExpectedValue<T>(outcome: string, expected?: T): string {
-  return expected !== undefined ? `  ${outcome} with ${printExpectedClean(expected)}` : `  ${outcome}`;
-}
-
-export function printExpectedResult<T>(expect: 'success' | 'failure', isNot: boolean, expected?: T): string {
-  return [
-    'Expected:',
-    isNot
-      ? expect === 'success'
-        ? printExpectedValue('Success', expected)
-        : printExpectedValue('Failure', expected)
-      : expect === 'success'
-      ? printExpectedValue('Not success', expected)
-      : printExpectedValue('Not failure', expected)
-  ].join('\n');
-}
-
-export function printExpectedDetailedResult<T, TD>(
-  expect: 'success' | 'failure',
-  isNot: boolean,
-  expectedMessage?: T,
-  expectedDetail?: TD
-): string {
-  /* c8 ignore next */
-  return [
-    'Expected:',
-    isNot
-      ? expect === 'success'
-        ? printExpectedValue('Success', expectedMessage)
-        : printExpectedValue('Failure', expectedMessage)
-      : expect === 'success'
-      ? printExpectedValue('Not success', expectedMessage)
-      : printExpectedValue('Not failure', expectedMessage),
-    `  Detail: "${printExpectedClean(expectedDetail)}"`
-  ].join('\n');
-}
-
-export function printReceivedResult<T>(received: Result<T>): string {
-  return [
-    'Received:',
-    received.isSuccess()
-      ? `  Success with ${printReceivedClean(received.value)}`
-      : `  Failure with "${received.message}"`
-  ].join('\n');
-}
-
-export function printReceivedDetailedResult<T, TD>(received: DetailedResult<T, TD>): string {
-  return [
-    'Received:',
-    received.isSuccess()
-      ? `  Success with "${printReceivedClean(received.value)}"\n  Detail: "${printReceivedClean(
-          received.detail
-        )}"`
-      : `  Failure with "${received.message}"\n  Detail: "${printReceivedClean(received.detail)}"`
-  ].join('\n');
-}

package/src/utils/snapshotResolver.ts

@@ -1,28 +0,0 @@
-import path from 'path';
-
-export function resolveSnapshotPath(
-  testPath: string,
-  snapshotExtension: string,
-  snapshotFolderName: string
-): string {
-  const snapshotPath = path.join(
-    path.join(path.dirname(testPath), '__snapshots__', snapshotFolderName),
-    path.basename(testPath) + snapshotExtension
-  );
-  return snapshotPath;
-}
-
-export function resolveTestPath(snapshotFilePath: string, snapshotExtension: string): string {
-  const testPath = path.join(
-    path.dirname(path.dirname(path.dirname(snapshotFilePath))),
-    path.basename(snapshotFilePath, snapshotExtension)
-  );
-  return testPath;
-}
-
-export const testPathForConsistencyCheck: string = path.posix.join(
-  'consistency_check',
-  '__tests__',
-  'subdir',
-  'example.test.js'
-);