vest 5.0.0-dev-781e21 → 5.0.0-dev-ec989a

package/types/vest.d.ts

@@ -1,56 +1,58 @@
 import { enforce } from 'n4s';
-type SuiteSummary = {
-    groups: Groups;
-    tests: Tests;
-    valid: boolean;
-} & SummaryBase;
-type GroupTestSummary = SingleTestSummary;
-type Groups = Record<string, Group>;
-type Group = Record<string, GroupTestSummary>;
-type Tests = Record<string, SingleTestSummary>;
-type SingleTestSummary = SummaryBase & {
-    errors: string[];
-    warnings: string[];
-    valid: boolean;
-};
-type SummaryBase = {
-    errorCount: number;
-    warnCount: number;
-    testCount: number;
-};
-type FailureMessages = Record<string, string[]>;
+import { Isolate, IsolateKey } from "vest-runtime";
+import { CB } from "vest-utils";
+declare enum Severity {
+    WARNINGS = "warnings",
+    ERRORS = "errors"
+}
 declare enum TestSeverity {
     Error = "error",
     Warning = "warning"
 }
-declare class VestTest {
-    fieldName: string;
-    testFn: TestFn;
-    asyncTest?: AsyncTest;
+// @vx-allow use-use
+declare function IsolateTestReconciler(currentNode: Isolate, historyNode: Isolate | null): Isolate;
+declare enum TestStatus {
+    UNTESTED = "UNTESTED",
+    SKIPPED = "SKIPPED",
+    FAILED = "FAILED",
+    WARNING = "WARNING",
+    PASSING = "PASSING",
+    PENDING = "PENDING",
+    CANCELED = "CANCELED",
+    OMITTED = "OMITTED"
+}
+type TestFn = () => TestResult;
+type AsyncTest = Promise<string | void | false>;
+type TestResult = AsyncTest | boolean | void;
+type WithFieldName<F extends TFieldName = TFieldName> = {
+    fieldName: F;
+};
+type IsolateTestInput = {
+    message?: string;
     groupName?: string;
+    fieldName: TFieldName;
+    testFn: TestFn;
+    key?: IsolateKey;
+};
+declare class IsolateTest<F extends TFieldName = TFieldName, G extends TGroupName = TGroupName> extends Isolate {
+    children: null;
+    fieldName: F;
+    testFn: TestFn;
+    groupName?: G;
     message?: string;
-    key?: null | string;
+    asyncTest?: AsyncTest;
     id: string;
     severity: TestSeverity;
-    status: KStatus;
-    constructor(fieldName: string, testFn: TestFn, { message, groupName, key }?: {
-        message?: string;
-        groupName?: string;
-        key?: string;
-    });
+    private stateMachine;
+    static reconciler: typeof IsolateTestReconciler;
+    constructor({ fieldName, testFn, message, groupName, key }: IsolateTestInput);
+    static create<Callback extends CB = CB>(callback: Callback, data: IsolateTestInput): IsolateTest;
+    static cast<F extends TFieldName = TFieldName, G extends TGroupName = TGroupName>(isolate: Isolate): IsolateTest<F, G>;
+    get status(): TestStatus;
+    setStatus(status: TestStatus, payload?: any): void;
     run(): TestResult;
-    setStatus(status: KStatus): void;
+    // Selectors
     warns(): boolean;
-    setPending(): void;
-    fail(): void;
-    done(): void;
-    warn(): void;
-    isFinalStatus(): boolean;
-    skip(force?: boolean): void;
-    cancel(): void;
-    reset(): void;
-    omit(): void;
-    valueOf(): boolean;
     isPending(): boolean;
     isOmitted(): boolean;
     isUntested(): boolean;
@@ -63,172 +65,173 @@ declare class VestTest {
     isNonActionable(): boolean;
     isTested(): boolean;
     awaitsResolution(): boolean;
-    statusEquals(status: KStatus): boolean;
+    statusEquals(status: TestStatus): boolean;
+    // State modifiers
+    setPending(): void;
+    fail(): void;
+    pass(): void;
+    warn(): void;
+    skip(force?: boolean): void;
+    cancel(): void;
+    reset(): void;
+    omit(): void;
+    valueOf(): boolean;
+    isAsyncTest(): boolean;
+    static is(value: any): value is IsolateTest;
+    static isX(value: any): asserts value is IsolateTest;
+}
+declare class SummaryFailure<F extends TFieldName, G extends TGroupName> implements WithFieldName<F> {
+    fieldName: F;
+    message: string | undefined;
+    groupName: G | undefined;
+    constructor(fieldName: F, message: string | undefined, groupName: G | undefined);
+    static fromTestObject<F extends TFieldName, G extends TGroupName>(testObject: IsolateTest<F, G>): SummaryFailure<F, G>;
+    toString(): string;
+}
+interface Done<F extends TFieldName, G extends TGroupName> {
+    (...args: [
+        cb: (res: SuiteResult<F, G>) => void
+    ]): SuiteRunResult<F, G>;
+    (...args: [
+        fieldName: F,
+        cb: (res: SuiteResult<F, G>) => void
+    ]): SuiteRunResult<F, G>;
 }
-type AsyncTest = Promise<string | void>;
-type TestResult = AsyncTest | boolean | void;
-type TestFn = () => TestResult;
-type KStatus = "UNTESTED" | "SKIPPED" | "FAILED" | "WARNING" | "PASSING" | "PENDING" | "CANCELED" | "OMITTED";
-type CB = (...args: any[]) => any;
 // eslint-disable-next-line max-lines-per-function, max-statements
-declare function suiteSelectors(summary: SuiteSummary): SuiteSelectors;
-interface SuiteSelectors {
-    getErrors(fieldName: string): string[];
+declare function suiteSelectors<F extends TFieldName, G extends TGroupName>(summary: SuiteSummary<F, G>): SuiteSelectors<F, G>;
+interface SuiteSelectors<F extends TFieldName, G extends TGroupName> {
+    getWarning(fieldName?: F): void | string | SummaryFailure<F, G>;
+    getError(fieldName?: F): void | string | SummaryFailure<F, G>;
+    getErrors(fieldName: F): string[];
     getErrors(): FailureMessages;
     getWarnings(): FailureMessages;
-    getWarnings(fieldName: string): string[];
-    getErrorsByGroup(groupName: string, fieldName: string): string[];
-    getErrorsByGroup(groupName: string): FailureMessages;
-    getWarningsByGroup(groupName: string): FailureMessages;
-    getWarningsByGroup(groupName: string, fieldName: string): string[];
-    hasErrors(fieldName?: string): boolean;
-    hasWarnings(fieldName?: string): boolean;
-    hasErrorsByGroup(groupName: string, fieldName?: string): boolean;
-    hasWarningsByGroup(groupName: string, fieldName?: string): boolean;
-    isValid(fieldName?: string): boolean;
-    isValidByGroup(groupName: string, fieldName?: string): boolean;
+    getWarnings(fieldName: F): string[];
+    getErrorsByGroup(groupName: G, fieldName: F): string[];
+    getErrorsByGroup(groupName: G): FailureMessages;
+    getWarningsByGroup(groupName: G): FailureMessages;
+    getWarningsByGroup(groupName: G, fieldName: F): string[];
+    hasErrors(fieldName?: F): boolean;
+    hasWarnings(fieldName?: F): boolean;
+    hasErrorsByGroup(groupName: G, fieldName?: F): boolean;
+    hasWarningsByGroup(groupName: G, fieldName?: F): boolean;
+    isValid(fieldName?: F): boolean;
+    isValidByGroup(groupName: G, fieldName?: F): boolean;
 }
-type SuiteResult = SuiteSummary & SuiteSelectors & {
-    suiteName: SuiteName;
+declare class SummaryBase {
+    errorCount: number;
+    warnCount: number;
+    testCount: number;
+}
+declare class SuiteSummary<F extends TFieldName, G extends TGroupName> extends SummaryBase {
+    [Severity.ERRORS]: SummaryFailure<F, G>[];
+    [Severity.WARNINGS]: SummaryFailure<F, G>[];
+    groups: Groups<G, F>;
+    tests: Tests<F>;
+    valid: boolean;
+}
+type GroupTestSummary = SingleTestSummary;
+type Groups<G extends TGroupName, F extends TFieldName> = Record<G, Group<F>>;
+type Group<F extends TFieldName> = Record<F, GroupTestSummary>;
+type Tests<F extends TFieldName> = Record<F, SingleTestSummary>;
+type SingleTestSummary = SummaryBase & {
+    errors: string[];
+    warnings: string[];
+    valid: boolean;
 };
-type SuiteRunResult = SuiteResult & {
-    done: Done;
+type FailureMessages = Record<string, string[]>;
+type SuiteResult<F extends TFieldName, G extends TGroupName> = SuiteSummary<F, G> & SuiteSelectors<F, G> & {
+    suiteName: SuiteName;
 };
-interface Done {
-    (...args: [
-        cb: (res: SuiteResult) => void
-    ]): SuiteRunResult;
-    (...args: [
-        fieldName: string,
-        cb: (res: SuiteResult) => void
-    ]): SuiteRunResult;
-}
-type CreateProperties = {
-    get: () => SuiteResult;
-    reset: () => void;
-    resetField: (fieldName: string) => void;
-    remove: (fieldName: string) => void;
+type SuiteRunResult<F extends TFieldName, G extends TGroupName> = SuiteResult<F, G> & {
+    done: Done<F, G>;
 };
-type Suite<T extends CB> = {
-    (...args: Parameters<T>): SuiteRunResult;
-} & CreateProperties;
+type SuiteName = string | undefined;
+type TFieldName<T extends string = string> = T;
+type TGroupName<G extends string = string> = G;
+type OptionalsInput<F extends TFieldName> = F | F[] | OptionalsObject<F>;
+type OptionalsObject<F extends TFieldName> = Record<F, (() => boolean) | boolean>;
+// @vx-allow use-use
+declare function optional<F extends TFieldName>(optionals: OptionalsInput<F>): void;
+type FieldExclusion<F extends TFieldName> = F | F[] | undefined;
+type GroupExclusion<G extends TGroupName> = G | G[] | undefined;
 /**
- * Creates a new validation suite
+ * Adds a field or a list of fields into the inclusion list
  *
  * @example
  *
- * const suite = create((data = {}) => {
- *  test("username", "Username is required", () => {
- *    enforce(data.username).isNotBlank();
- *  });
- * });
+ * only('username');
  */
-declare function create<T extends CB>(suiteName: SuiteName, suiteCallback: T): Suite<T>;
-declare function create<T extends CB>(suiteCallback: T): Suite<T>;
-type SuiteName = string | void;
-type IsolateCursor = {
-    current: () => number;
-    next: () => void;
-};
-declare enum IsolateTypes {
-    DEFAULT = 0,
-    SUITE = 1,
-    EACH = 2,
-    SKIP_WHEN = 3,
-    OMIT_WHEN = 4,
-    GROUP = 5
-}
-type IsolateKeys = {
-    current: Record<string, VestTest>;
-    prev: Record<string, VestTest>;
-};
-type Isolate = {
-    type: IsolateTypes;
-    keys: IsolateKeys;
-    path: number[];
-    cursor: IsolateCursor;
-};
-declare enum Modes {
-    ALL = 0,
-    EAGER = 1
+// @vx-allow use-use
+declare function only<F extends TFieldName>(item: FieldExclusion<F>): void;
+declare namespace only {
+    var group: <G extends string>(item: GroupExclusion<G>) => void;
 }
-type NestedArray<T> = Array<NestedArray<T> | T>;
-type SetStateInput<S> = S | ((prevState: S) => S);
-type StateHandlerReturn<S> = [
-    S,
-    (nextState: SetStateInput<S>) => void
-];
-type UseState<S> = () => StateHandlerReturn<S>;
 /**
- * Marks a field as optional, either just by name, or by a given condition.
+ * Adds a field or a list of fields into the exclusion list
  *
  * @example
  *
- * optional('field_name');
- *
- * optional({
- *  username: () => allowUsernameEmpty,
- * });
+ * skip('username');
  */
-declare function optional(optionals: OptionalsInput): void;
-type OptionalsInput = string | string[] | OptionalsObject;
-type OptionalsObject = Record<string, (() => boolean) | boolean>;
-type ImmediateOptionalFieldDeclaration = {
-    type: OptionalFieldTypes.Immediate;
-    rule: boolean | (() => boolean);
-    applied: boolean;
-};
-type DelayedOptionalFieldDeclaration = {
-    type: OptionalFieldTypes.Delayed;
-    applied: boolean;
-    rule: null;
-};
-type OptionalFieldDeclaration = ImmediateOptionalFieldDeclaration | DelayedOptionalFieldDeclaration;
-declare enum OptionalFieldTypes {
-    Immediate = 0,
-    Delayed = 1
+// @vx-allow use-use
+declare function skip<F extends TFieldName>(item: FieldExclusion<F>): void;
+declare namespace skip {
+    var group: <G extends string>(item: GroupExclusion<G>) => void;
 }
-type StateRef = {
-    optionalFields: UseState<OptionalFields>;
-    suiteId: UseState<string>;
-    suiteName: UseState<SuiteName>;
-    testCallbacks: UseState<TestCallbacks>;
-    testObjects: UseState<TestObjects>;
-};
-type OptionalFields = Record<string, OptionalFieldDeclaration>;
-type TestCallbacks = {
-    fieldCallbacks: Record<string, Array<(res: SuiteResult) => void>>;
-    doneCallbacks: Array<(res: SuiteResult) => void>;
+declare function vestTest<F extends TFieldName>(fieldName: F, message: string, cb: TestFn): IsolateTest;
+declare function vestTest<F extends TFieldName>(fieldName: F, cb: TestFn): IsolateTest;
+declare function vestTest<F extends TFieldName>(fieldName: F, message: string, cb: TestFn, key: IsolateKey): IsolateTest;
+declare function vestTest<F extends TFieldName>(fieldName: F, cb: TestFn, key: IsolateKey): IsolateTest;
+declare const test: typeof vestTest & {
+    memo: TestMemo<string>;
 };
-type TestObjects = {
-    prev: VestTests;
-    current: VestTests;
+type TestMemo<F extends TFieldName> = {
+    (fieldName: F, ...args: ParametersWithoutMessage): IsolateTest;
+    (fieldName: F, ...args: ParametersWithMessage): IsolateTest;
 };
-type VestTests = NestedArray<VestTest>;
-declare const _default: import("context").CtxCascadeApi<CTXType>;
-type CTXType = {
-    isolate: Isolate;
-    stateRef?: StateRef;
-    exclusion: {
-        tests: Record<string, boolean>;
-        groups: Record<string, boolean>;
+type ParametersWithoutMessage = [
+    test: TestFn,
+    dependencies: unknown[]
+];
+type ParametersWithMessage = [
+    message: string,
+    test: TestFn,
+    dependencies: unknown[]
+];
+type TTypedMethods<F extends TFieldName, G extends TGroupName> = {
+    include: (fieldName: F) => {
+        when: (condition: boolean | F | ((draft: SuiteResult<F, G>) => boolean)) => void;
     };
-    inclusion: Record<string, boolean | (() => boolean)>;
-    currentTest?: VestTest;
-    groupName?: string;
-    skipped?: boolean;
-    omitted?: boolean;
-    mode: [
-        Modes
-    ];
-    bus?: {
-        on: (event: string, handler: CB) => {
-            off: () => void;
-        };
-        emit: (event: string, ...args: any[]) => void;
+    omitWhen: (conditional: boolean | ((draft: SuiteResult<F, G>) => boolean), callback: CB) => void;
+    only: {
+        (item: FieldExclusion<F>): void;
+        group(item: GroupExclusion<G>): void;
+    };
+    optional: (optionals: OptionalsInput<F>) => void;
+    skip: {
+        (item: FieldExclusion<F>): void;
+        group(item: GroupExclusion<G>): void;
+    };
+    skipWhen: (condition: boolean | ((draft: SuiteResult<F, G>) => boolean), callback: CB) => void;
+    test: {
+        (fieldName: F, message: string, cb: TestFn): IsolateTest;
+        (fieldName: F, cb: TestFn): IsolateTest;
+        (fieldName: F, message: string, cb: TestFn, key: IsolateKey): IsolateTest;
+        (fieldName: F, cb: TestFn, key: IsolateKey): IsolateTest;
+    } & {
+        memo: TestMemo<F>;
     };
+    group: (groupName: G, callback: () => void) => Isolate;
 };
-declare const context: typeof _default;
+type Suite<F extends TFieldName, G extends TGroupName, T extends CB = CB> = ((...args: Parameters<T>) => SuiteRunResult<F, G>) & SuiteMethods<F, G>;
+type SuiteMethods<F extends TFieldName, G extends TGroupName> = {
+    get: () => SuiteResult<F, G>;
+    reset: () => void;
+    remove: (fieldName: F) => void;
+    resetField: (fieldName: F) => void;
+} & TTypedMethods<F, G> & SuiteSelectors<F, G>;
+declare function createSuite<F extends TFieldName = string, G extends TGroupName = string, T extends CB = CB>(suiteName: SuiteName, suiteCallback: T): Suite<F, G, T>;
+declare function createSuite<F extends TFieldName = string, G extends TGroupName = string, T extends CB = CB>(suiteCallback: T): Suite<F, G, T>;
 /**
  * Iterates over an array of items, allowing to run tests individually per item.
  *
@@ -243,62 +246,56 @@ declare const context: typeof _default;
  * })
  */
 declare function each<T>(list: T[], callback: (arg: T, index: number) => void): void;
-type ExclusionItem = string | string[] | undefined;
+declare function group<G extends TGroupName>(groupName: G, callback: () => void): Isolate;
 /**
- * Adds a field or a list of fields into the inclusion list
+ * Conditionally includes a field for testing, based on specified criteria.
  *
- * @example
- *
- * only('username');
- */
-declare function only(item: ExclusionItem): void;
-declare namespace only {
-    var group: (item: ExclusionItem) => void;
-}
-/**
- * Adds a field or a list of fields into the exclusion list
+ * @param {string} fieldName - The name of the field to include for testing.
  *
  * @example
+ * include('confirm').when('password');
+ * // Includes the "confirm" field for testing when the "password" field is included
  *
- * skip('username');
- */
-declare function skip(item: ExclusionItem): void;
-declare namespace skip {
-    var group: (item: ExclusionItem) => void;
-}
-/**
- * Runs tests within a group so that they can be controlled or queried separately.
+ * include('confirm').when(someValue);
+ * // Includes the "confirm" field for testing when the value of `someValue` is true
  *
- * @example
+ * include('confirm').when(() => someValue);
+ * // Includes the "confirm" field for testing when the callback function returns true
  *
- * group('group_name', () => {
- *  // Tests go here
- * });
+ * include('username').when(result => result.hasErrors('username'));
+ * // Includes the "username" field for testing when there are errors associated with it in the current suite result
  */
-declare function group(groupName: string, tests: () => void): void;
-declare function include(fieldName: string): {
-    when: (condition: string | boolean | ((draft: SuiteResult) => boolean)) => void;
+// @vx-allow use-use
+declare function include<F extends TFieldName, G extends TGroupName>(fieldName: F): {
+    when: (condition: F | TFieldName | boolean | ((draft: SuiteResult<F, G>) => boolean)) => void;
 };
+declare enum Modes {
+    EAGER = "EAGER",
+    ALL = "ALL",
+    ONE = "ONE"
+}
 /**
- * Sets the suite to "eager" (fail fast) mode.
- * Eager mode will skip running subsequent tests of a failing fields.
+ * Sets the current execution mode for the current suite.
+ *
+ * Supported modes:
+ * - `EAGER` - (default) Runs all tests, but stops on first failure for each given field.
+ * - `ALL` - Runs all tests, regardless of failures.
+ * - `ONE` - Stops suite execution on first failure of any field.
  *
  * @example
- *  // in the following example, the second test of username will not run
- *  // if the first test of username failed.
- * const suite = create((data) => {
- *  eager();
+ * ```js
+ * import {Modes, create} from 'vest';
  *
- *  test('username', 'username is required', () => {
- *   enforce(data.username).isNotBlank();
- *  });
+ * const suite = create('suite_name', () => {
+ *  vest.mode(Modes.ALL);
  *
- *  test('username', 'username is too short', () => {
- *   enforce(data.username).longerThan(2);
- *  });
+ *  // ...
  * });
+ * ```
+ * @param 'ALL' | 'EAGER' | 'ONE' mode - The mode to set.
  */
-declare function eager(): void;
+// @vx-allow use-use
+declare function mode(mode: Modes): void;
 /**
  * Conditionally omits tests from the suite.
  *
@@ -308,7 +305,8 @@ declare function eager(): void;
  *  test('username', 'User already taken', async () => await doesUserExist(username)
  * });
  */
-declare function omitWhen(conditional: boolean | ((draft: SuiteResult) => boolean), callback: CB): void;
+// @vx-allow use-use
+declare function omitWhen<F extends TFieldName, G extends TGroupName>(conditional: boolean | ((draft: SuiteResult<F, G>) => boolean), callback: CB): void;
 /**
  * Conditionally skips running tests within the callback.
  *
@@ -318,30 +316,47 @@ declare function omitWhen(conditional: boolean | ((draft: SuiteResult) => boolea
  *  test('username', 'User already taken', async () => await doesUserExist(username)
  * });
  */
-declare function skipWhen(conditional: boolean | ((draft: SuiteResult) => boolean), callback: CB): void;
-declare function testBase(fieldName: string, message: string, cb: TestFn): VestTest;
-declare function testBase(fieldName: string, cb: TestFn): VestTest;
-declare function testBase(fieldName: string, message: string, cb: TestFn, key: string): VestTest;
-declare function testBase(fieldName: string, cb: TestFn, key: string): VestTest;
+// @vx-allow use-use
+declare function skipWhen<F extends TFieldName, G extends TGroupName>(condition: boolean | ((draft: SuiteResult<F, G>) => boolean), callback: CB): void;
 /**
- * Represents a single case in a validation suite.
+ * Creates a static suite for server-side validation.
+ *
+ * @param {Function} validationFn - The validation function that defines the suite's tests.
+ * @returns {Function} - A function that runs the validations defined in the suite.
  *
  * @example
+ * import { staticSuite, test, enforce } from 'vest';
  *
- * test("username", "Username is required", () => {
- *  enforce(data.username).isNotBlank();
+ * const suite = staticSuite(data => {
+ *   test('username', 'username is required', () => {
+ *     enforce(data.username).isNotEmpty();
+ *   });
  * });
+ *
+ * suite(data);
  */
-declare const test: typeof testBase & {
-    memo: {
-        (fieldName: string, test: TestFn, deps: unknown[]): VestTest;
-        (fieldName: string, message: string, test: TestFn, deps: unknown[]): VestTest;
-    };
-};
+declare function staticSuite<F extends TFieldName = string, G extends TGroupName = string, T extends CB = CB>(suiteCallback: T): StaticSuite<F, G, T>;
+type StaticSuite<F extends TFieldName = string, G extends TGroupName = string, T extends CB = CB> = ((...args: Parameters<T>) => SuiteRunResult<F, G>) & TTypedMethods<F, G>;
 /**
- * Sets a running test to warn only mode.
+ * Sets the severity level of a test to `warn`, allowing it to fail without marking the suite as invalid.
+ * Use this function within the body of a test to create warn-only tests.
+ *
+ * @returns {void}
+ *
+ * @example
+ *   test('password', 'Your password strength is: WEAK', () => {
+ *     warn();
+ *
+ *     enforce(data.password).matches(/0-9/);
+ *   });
+ *
+ * @limitations
+ * - The `warn` function should only be used within the body of a `test` function.
+ * - When using `warn()` in an async test, it should be called in the synchronous portion of the test, not after an `await` call or in the Promise body.
+ * - It is recommended to call `warn()` at the top of the test function.
  */
+// @vx-allow use-use
 declare function warn(): void;
-declare const VERSION = "5.0.0-dev-781e21";
-export { suiteSelectors, test, create, each, only, skip, warn, group, optional, skipWhen, omitWhen, enforce, VERSION, context, include, eager };
-export type { SuiteResult, SuiteRunResult, SuiteSummary, VestTest, Suite };
+export { createSuite as create, test, group, optional, enforce, skip, skipWhen, omitWhen, only, warn, include, suiteSelectors, each, mode, staticSuite, Modes };
+export type { SuiteResult, SuiteRunResult, SuiteSummary, IsolateTest, Suite };
+//# sourceMappingURL=vest.d.ts.map

package/types/vest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vest.d.ts","sourceRoot":"","sources":["../src/vest.ts","../src/suiteResult/Severity.ts","../src/errors/ErrorStrings.ts","../src/core/test/TestTypes.ts","../src/core/test/helpers/matchingFieldName.ts","../src/core/isolate/IsolateTest/isSameProfileTest.ts","../src/core/isolate/IsolateTest/cancelOverriddenPendingTest.ts","../src/core/isolate/IsolateTest/TestWalker.ts","../src/core/test/helpers/matchingGroupName.ts","../src/core/test/helpers/nonMatchingSeverityProfile.ts","../src/suiteResult/selectors/hasFailuresByTestObjects.ts","../src/hooks/mode.ts","../src/core/context/SuiteContext.ts","../src/core/Runtime.ts","../src/suiteResult/selectors/shouldAddValidProperty.ts","../src/suiteResult/selectors/produceSuiteSummary.ts","../src/suiteResult/selectors/collectFailures.ts","../src/suiteResult/selectors/suiteSelectors.ts","../src/suiteResult/suiteResult.ts","../src/isolates/skipWhen.ts","../src/hooks/exclusive.ts","../src/isolates/omitWhen.ts","../src/core/test/testLevelFlowControl/verifyTestRun.ts","../src/core/isolate/IsolateTest/IsolateTestReconciler.ts","../src/core/isolate/IsolateTest/IsolateTestStateMachine.ts","../src/core/test/helpers/shouldUseErrorMessage.ts","../src/core/isolate/IsolateTest/IsolateTest.ts","../src/suiteResult/SummaryFailure.ts","../src/suiteResult/done/deferDoneCallback.ts","../src/suiteResult/done/shouldSkipDoneRegistration.ts","../src/suiteResult/suiteRunResult.ts","../src/suiteResult/SuiteResultTypes.ts","../src/hooks/optional/OptionalTypes.ts","../src/core/isolate/IsolateSuite/IsolateSuite.ts","../src/hooks/optional/optional.ts","../src/hooks/include.ts","../src/core/VestBus/BusEvents.ts","../src/core/test/testLevelFlowControl/runTest.ts","../src/core/test/test.memo.ts","../src/core/test/test.ts","../src/suite/getTypedMethods.ts","../src/suite/SuiteTypes.ts","../src/hooks/optional/omitOptionalFields.ts","../src/suite/runCallbacks.ts","../src/core/VestBus/VestBus.ts","../src/suite/validateParams/validateSuiteParams.ts","../src/suite/createSuite.ts","../src/core/isolate/IsolateEach/IsolateEach.ts","../src/isolates/each.ts","../src/isolates/group.ts","../src/suite/staticSuite.ts","../src/hooks/warn.ts"],"names":[],"mappings":"AAAA,OAAO,WAAW,MAAM,KAAK,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwB9B,OAAO,wJAiBN,CAAC;AAEF,YAAY,iEAAiE,CAAC"}