vest 5.0.0-dev-9c596e → 5.0.0-dev-ec989a

package/types/parser.d.ts

@@ -1,10 +1,92 @@
+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"
+}
+// @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;
+    asyncTest?: AsyncTest;
+    id: string;
+    severity: TestSeverity;
+    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;
+    // Selectors
+    warns(): boolean;
+    isPending(): boolean;
+    isOmitted(): boolean;
+    isUntested(): boolean;
+    isFailing(): boolean;
+    isCanceled(): boolean;
+    isSkipped(): boolean;
+    isPassing(): boolean;
+    isWarning(): boolean;
+    hasFailures(): boolean;
+    isNonActionable(): boolean;
+    isTested(): boolean;
+    awaitsResolution(): 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
@@ -53,10 +135,6 @@ type SingleTestSummary = SummaryBase & {
     warnings: string[];
     valid: boolean;
 };
-type SummaryFailure<F extends TFieldName, G extends TGroupName> = WithFieldName<F> & {
-    groupName: G | undefined;
-    message: string | undefined;
-};
 type FailureMessages = Record<string, string[]>;
 type SuiteResult<F extends TFieldName, G extends TGroupName> = SuiteSummary<F, G> & SuiteSelectors<F, G> & {
     suiteName: SuiteName;

package/types/parser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../src/exports/parser.ts","../src/errors/ErrorStrings.ts","../src/suiteResult/Severity.ts","../src/core/test/TestTypes.ts","../src/core/VestBus/Events.ts","../src/core/isolate/walker.ts","../src/core/isolate/reconciler/Reconciler/Reconciler.ts","../src/core/isolate/Isolate.ts","../src/hooks/optional/OptionalTypes.ts","../src/core/isolate/IsolateSuite/IsolateSuite.ts","../src/core/test/helpers/matchingFieldName.ts","../src/core/isolate/reconciler/isSameProfileTest.ts","../src/core/isolate/reconciler/cancelOverriddenPendingTest.ts","../src/hooks/optional/optional.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/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/SimpleStateMachine.ts","../src/core/isolate/IsolateTest/IsolateTestStateMachine.ts","../src/core/test/helpers/shouldUseErrorMessage.ts","../src/core/isolate/IsolateTest/IsolateTest.ts","../src/suite/runCallbacks.ts","../src/core/VestBus/VestBus.ts","../src/core/context/PersistedContext.ts","../src/suiteResult/done/deferDoneCallback.ts","../src/suiteResult/done/shouldSkipDoneRegistration.ts","../src/suiteResult/suiteRunResult.ts","../src/suiteResult/SuiteResultTypes.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AASA,iBAAgB,KAAK,CAAC,CAAC,SAAS,UAAU,EAAE,CAAC,SAAS,UAAU,EAC9D,OAAO,EAAE,YAAY,CAAC,CAAC,EAAE,CAAC,CAAC,GAC1B,gBAAgB,CAAC,CAAC,CAAC,CA4CrB;AAED,UAAU,gBAAgB,CAAC,CAAC,SAAS,UAAU;IAC7C,KAAK,CAAC,SAAS,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC;IAC9B,MAAM,CAAC,SAAS,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC;IAC/B,OAAO,CAAC,SAAS,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC;IAChC,QAAQ,CAAC,SAAS,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC;IACjC,OAAO,CAAC,SAAS,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC;CACjC"}
+{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../src/exports/parser.ts","../src/errors/ErrorStrings.ts","../src/suiteResult/Severity.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/hooks/optional/OptionalTypes.ts","../src/core/isolate/IsolateSuite/IsolateSuite.ts","../src/hooks/optional/optional.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"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AASA,iBAAgB,KAAK,CAAC,CAAC,SAAS,UAAU,EAAE,CAAC,SAAS,UAAU,EAC9D,OAAO,EAAE,YAAY,CAAC,CAAC,EAAE,CAAC,CAAC,GAC1B,gBAAgB,CAAC,CAAC,CAAC,CA4CrB;AAED,UAAU,gBAAgB,CAAC,CAAC,SAAS,UAAU;IAC7C,KAAK,CAAC,SAAS,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC;IAC9B,MAAM,CAAC,SAAS,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC;IAC/B,OAAO,CAAC,SAAS,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC;IAChC,QAAQ,CAAC,SAAS,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC;IACjC,OAAO,CAAC,SAAS,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC;CACjC"}

package/types/promisify.d.ts

@@ -1,10 +1,92 @@
+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"
+}
+// @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;
+    asyncTest?: AsyncTest;
+    id: string;
+    severity: TestSeverity;
+    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;
+    // Selectors
+    warns(): boolean;
+    isPending(): boolean;
+    isOmitted(): boolean;
+    isUntested(): boolean;
+    isFailing(): boolean;
+    isCanceled(): boolean;
+    isSkipped(): boolean;
+    isPassing(): boolean;
+    isWarning(): boolean;
+    hasFailures(): boolean;
+    isNonActionable(): boolean;
+    isTested(): boolean;
+    awaitsResolution(): 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
@@ -53,10 +135,6 @@ type SingleTestSummary = SummaryBase & {
     warnings: string[];
     valid: boolean;
 };
-type SummaryFailure<F extends TFieldName, G extends TGroupName> = WithFieldName<F> & {
-    groupName: G | undefined;
-    message: string | undefined;
-};
 type FailureMessages = Record<string, string[]>;
 type SuiteResult<F extends TFieldName, G extends TGroupName> = SuiteSummary<F, G> & SuiteSelectors<F, G> & {
     suiteName: SuiteName;

package/types/promisify.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"promisify.d.ts","sourceRoot":"","sources":["../src/exports/promisify.ts","../src/errors/ErrorStrings.ts","../src/suiteResult/Severity.ts","../src/core/test/TestTypes.ts","../src/core/VestBus/Events.ts","../src/core/isolate/walker.ts","../src/core/isolate/reconciler/Reconciler/Reconciler.ts","../src/core/isolate/Isolate.ts","../src/hooks/optional/OptionalTypes.ts","../src/core/isolate/IsolateSuite/IsolateSuite.ts","../src/core/test/helpers/matchingFieldName.ts","../src/core/isolate/reconciler/isSameProfileTest.ts","../src/core/isolate/reconciler/cancelOverriddenPendingTest.ts","../src/hooks/optional/optional.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/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/SimpleStateMachine.ts","../src/core/isolate/IsolateTest/IsolateTestStateMachine.ts","../src/core/test/helpers/shouldUseErrorMessage.ts","../src/core/isolate/IsolateTest/IsolateTest.ts","../src/suite/runCallbacks.ts","../src/core/VestBus/VestBus.ts","../src/core/context/PersistedContext.ts","../src/suiteResult/done/deferDoneCallback.ts","../src/suiteResult/done/shouldSkipDoneRegistration.ts","../src/suiteResult/suiteRunResult.ts","../src/suiteResult/SuiteResultTypes.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAUA,iBAAS,SAAS,CAAC,CAAC,SAAS,UAAU,EAAE,CAAC,SAAS,UAAU,EAC3D,WAAW,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,aAEpC,GAAG,EAAE,KAAG,QAAQ,YAAY,CAAC,EAAE,CAAC,CAAC,CAAC,CAKpD"}
+{"version":3,"file":"promisify.d.ts","sourceRoot":"","sources":["../src/exports/promisify.ts","../src/errors/ErrorStrings.ts","../src/suiteResult/Severity.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/hooks/optional/OptionalTypes.ts","../src/core/isolate/IsolateSuite/IsolateSuite.ts","../src/hooks/optional/optional.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"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAUA,iBAAS,SAAS,CAAC,CAAC,SAAS,UAAU,EAAE,CAAC,SAAS,UAAU,EAC3D,WAAW,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,aAEpC,GAAG,EAAE,KAAG,QAAQ,YAAY,CAAC,EAAE,CAAC,CAAC,CAAC,CAKpD"}

package/types/vest.d.ts

@@ -1,15 +1,93 @@
 import { enforce } from 'n4s';
+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"
+}
+// @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;
+    asyncTest?: AsyncTest;
+    id: string;
+    severity: TestSeverity;
+    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;
+    // Selectors
+    warns(): boolean;
+    isPending(): boolean;
+    isOmitted(): boolean;
+    isUntested(): boolean;
+    isFailing(): boolean;
+    isCanceled(): boolean;
+    isSkipped(): boolean;
+    isPassing(): boolean;
+    isWarning(): boolean;
+    hasFailures(): boolean;
+    isNonActionable(): boolean;
+    isTested(): boolean;
+    awaitsResolution(): 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
@@ -60,10 +138,6 @@ type SingleTestSummary = SummaryBase & {
     warnings: string[];
     valid: boolean;
 };
-type SummaryFailure<F extends TFieldName, G extends TGroupName> = WithFieldName<F> & {
-    groupName: G | undefined;
-    message: string | undefined;
-};
 type FailureMessages = Record<string, string[]>;
 type SuiteResult<F extends TFieldName, G extends TGroupName> = SuiteSummary<F, G> & SuiteSelectors<F, G> & {
     suiteName: SuiteName;
@@ -78,120 +152,6 @@ 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;
-declare class Reconciler {
-    static reconciler(currentNode: Isolate, historicNode: Isolate | null): Isolate;
-    static reconcile<Callback extends CB = CB>(node: Isolate, callback: Callback): [
-        Isolate,
-        ReturnType<Callback>
-    ];
-    static removeAllNextNodesInIsolate(): void;
-    static handleCollision(newNode: Isolate, prevNode: Isolate): Isolate;
-    static nodeReorderDetected(newNode: Isolate, prevNode: Isolate): boolean;
-    static onNodeReorder(newNode: Isolate, prevNode: Isolate): Isolate;
-    static handleIsolateNodeWithKey(node: Isolate): Isolate;
-}
-type IsolateKey = null | string;
-declare class Isolate<_D = any> {
-    children: Isolate[] | null;
-    keys: Record<string, Isolate>;
-    parent: Isolate | null;
-    output?: any;
-    key: IsolateKey;
-    allowReorder: boolean;
-    static reconciler: typeof Reconciler;
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/no-empty-function
-    constructor(_data?: _D);
-    setParent(parent: Isolate | null): this;
-    saveOutput(output: any): this;
-    setKey(key: string | null): this;
-    usesKey(): boolean;
-    addChild(child: Isolate): void;
-    removeChild(node: Isolate): void;
-    slice(at: number): void;
-    at(at: number): Isolate | null;
-    cursor(): number;
-    shouldAllowReorder(): boolean;
-    get rootNode(): Isolate;
-    static create<Callback extends CB = CB>(callback: Callback, data?: any): Isolate;
-    private static createImplementation;
-    static setNode(node: Isolate): void;
-    static is(node: any): boolean;
-}
-declare class IsolateTestReconciler extends Reconciler {
-    static reconciler(currentNode: Isolate, historyNode: Isolate | null): Isolate;
-    static nodeReorderDetected(newNode: IsolateTest, prevNode?: Isolate): boolean;
-    static handleCollision(newNode: IsolateTest, prevNode?: Isolate): IsolateTest;
-    static onNodeReorder(newNode: IsolateTest, prevNode?: Isolate): IsolateTest;
-    static pickNode(historyNode: IsolateTest, currentNode: IsolateTest): Isolate;
-    static handleNoHistoryNode(testNode: IsolateTest): IsolateTest;
-}
-declare enum TestStatus {
-    UNTESTED = "UNTESTED",
-    SKIPPED = "SKIPPED",
-    FAILED = "FAILED",
-    WARNING = "WARNING",
-    PASSING = "PASSING",
-    PENDING = "PENDING",
-    CANCELED = "CANCELED",
-    OMITTED = "OMITTED"
-}
-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;
-    asyncTest?: AsyncTest;
-    id: string;
-    severity: TestSeverity;
-    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;
-    // Selectors
-    warns(): boolean;
-    isPending(): boolean;
-    isOmitted(): boolean;
-    isUntested(): boolean;
-    isFailing(): boolean;
-    isCanceled(): boolean;
-    isSkipped(): boolean;
-    isPassing(): boolean;
-    isWarning(): boolean;
-    hasFailures(): boolean;
-    isNonActionable(): boolean;
-    isTested(): boolean;
-    awaitsResolution(): 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 enum TestSeverity {
-    Error = "error",
-    Warning = "warning"
-}
 type FieldExclusion<F extends TFieldName> = F | F[] | undefined;
 type GroupExclusion<G extends TGroupName> = G | G[] | undefined;
 /**
@@ -263,15 +223,15 @@ type TTypedMethods<F extends TFieldName, G extends TGroupName> = {
     };
     group: (groupName: G, callback: () => void) => Isolate;
 };
-type Suite<T extends CB, F extends TFieldName, G extends TGroupName> = ((...args: Parameters<T>) => SuiteRunResult<F, G>) & SuiteMethods<F, G>;
+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>;
-declare function createSuite<T extends CB, F extends TFieldName = string, G extends TGroupName = string>(suiteName: SuiteName, suiteCallback: T): Suite<T, F, G>;
-declare function createSuite<T extends CB, F extends TFieldName = string, G extends TGroupName = string>(suiteCallback: T): Suite<T, F, G>;
+} & 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.
  *
@@ -287,32 +247,52 @@ declare function createSuite<T extends CB, F extends TFieldName = string, G exte
  */
 declare function each<T>(list: T[], callback: (arg: T, index: number) => void): void;
 declare function group<G extends TGroupName>(groupName: G, callback: () => void): Isolate;
+/**
+ * Conditionally includes a field for testing, based on specified criteria.
+ *
+ * @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
+ *
+ * include('confirm').when(someValue);
+ * // Includes the "confirm" field for testing when the value of `someValue` is true
+ *
+ * include('confirm').when(() => someValue);
+ * // Includes the "confirm" field for testing when the callback function returns true
+ *
+ * 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
+ */
 // @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",
-    EAGER = "EAGER"
+    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.
  */
 // @vx-allow use-use
 declare function mode(mode: Modes): void;
@@ -338,10 +318,42 @@ declare function omitWhen<F extends TFieldName, G extends TGroupName>(conditiona
  */
 // @vx-allow use-use
 declare function skipWhen<F extends TFieldName, G extends TGroupName>(condition: boolean | ((draft: SuiteResult<F, G>) => boolean), callback: CB): void;
-declare function staticSuite<T extends CB, F extends TFieldName = string, G extends TGroupName = string>(suiteCallback: T): StaticSuite<T, F, G>;
-type StaticSuite<T extends CB, F extends TFieldName = string, G extends TGroupName = string> = ((...args: Parameters<T>) => SuiteRunResult<F, G>) & TTypedMethods<F, G>;
 /**
- * Sets a running test to warn only mode.
+ * 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';
+ *
+ * const suite = staticSuite(data => {
+ *   test('username', 'username is required', () => {
+ *     enforce(data.username).isNotEmpty();
+ *   });
+ * });
+ *
+ * suite(data);
+ */
+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 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;

package/types/vest.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vest.d.ts","sourceRoot":"","sources":["../src/vest.ts","../src/core/isolate/walker.ts","../src/core/VestBus/Events.ts","../src/errors/ErrorStrings.ts","../src/suiteResult/Severity.ts","../src/core/test/TestTypes.ts","../src/core/isolate/reconciler/Reconciler/Reconciler.ts","../src/core/test/helpers/matchingFieldName.ts","../src/core/isolate/reconciler/isSameProfileTest.ts","../src/core/isolate/reconciler/cancelOverriddenPendingTest.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/hooks/optional/OptionalTypes.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/SimpleStateMachine.ts","../src/core/isolate/IsolateTest/IsolateTestStateMachine.ts","../src/core/test/helpers/shouldUseErrorMessage.ts","../src/core/isolate/IsolateTest/IsolateTest.ts","../src/core/isolate/IsolateTest/TestWalker.ts","../src/suiteResult/done/deferDoneCallback.ts","../src/suiteResult/done/shouldSkipDoneRegistration.ts","../src/suiteResult/suiteRunResult.ts","../src/suiteResult/SuiteResultTypes.ts","../src/suite/runCallbacks.ts","../src/core/VestBus/VestBus.ts","../src/core/context/PersistedContext.ts","../src/core/isolate/Isolate.ts","../src/core/isolate/IsolateSuite/IsolateSuite.ts","../src/hooks/optional/optional.ts","../src/hooks/include.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/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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuB9B,OAAO,wJAiBN,CAAC;AAEF,YAAY,iEAAiE,CAAC"}
+{"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"}