vest 5.0.0-dev-781e21 → 5.0.2-dev-d315d9

package/types/promisify.d.ts

@@ -1,12 +1,37 @@
-type SuiteSummary = {
+interface Done<F extends TFieldName> {
+    (...args: [
+        cb: (res: SuiteResult<F>) => void
+    ]): SuiteRunResult<F>;
+    (...args: [
+        fieldName: F,
+        cb: (res: SuiteResult<F>) => void
+    ]): SuiteRunResult<F>;
+}
+interface SuiteSelectors<F extends TFieldName> {
+    getErrors(fieldName: F): string[];
+    getErrors(): FailureMessages;
+    getWarnings(): FailureMessages;
+    getWarnings(fieldName: F): string[];
+    getErrorsByGroup(groupName: string, fieldName: F): string[];
+    getErrorsByGroup(groupName: string): FailureMessages;
+    getWarningsByGroup(groupName: string): FailureMessages;
+    getWarningsByGroup(groupName: string, fieldName: F): string[];
+    hasErrors(fieldName?: F): boolean;
+    hasWarnings(fieldName?: F): boolean;
+    hasErrorsByGroup(groupName: string, fieldName?: F): boolean;
+    hasWarningsByGroup(groupName: string, fieldName?: F): boolean;
+    isValid(fieldName?: F): boolean;
+    isValidByGroup(groupName: string, fieldName?: F): boolean;
+}
+type SuiteSummary<F extends TFieldName> = {
     groups: Groups;
-    tests: Tests;
+    tests: Tests<F>;
     valid: boolean;
 } & SummaryBase;
 type GroupTestSummary = SingleTestSummary;
 type Groups = Record<string, Group>;
 type Group = Record<string, GroupTestSummary>;
-type Tests = Record<string, SingleTestSummary>;
+type Tests<F extends TFieldName> = Record<F, SingleTestSummary>;
 type SingleTestSummary = SummaryBase & {
     errors: string[];
     warnings: string[];
@@ -18,37 +43,14 @@ type SummaryBase = {
     testCount: number;
 };
 type FailureMessages = Record<string, string[]>;
-type SuiteRunResult = SuiteResult & {
-    done: Done;
-};
-interface Done {
-    (...args: [
-        cb: (res: SuiteResult) => void
-    ]): SuiteRunResult;
-    (...args: [
-        fieldName: string,
-        cb: (res: SuiteResult) => void
-    ]): SuiteRunResult;
-}
-type SuiteName = string | void;
-interface SuiteSelectors {
-    getErrors(fieldName: string): 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;
-}
-type SuiteResult = SuiteSummary & SuiteSelectors & {
+type SuiteResult<F extends TFieldName> = SuiteSummary<F> & SuiteSelectors<F> & {
     suiteName: SuiteName;
 };
-declare const promisify: (validatorFn: (...args: any[]) => SuiteRunResult) => (...args: any[]) => Promise<SuiteResult>;
+type SuiteRunResult<F extends TFieldName> = SuiteResult<F> & {
+    done: Done<F>;
+};
+type SuiteName = string | undefined;
+type TFieldName<T extends string = string> = T;
+declare function promisify<F extends TFieldName>(validatorFn: (...args: any[]) => SuiteRunResult<F>): (...args: any[]) => Promise<SuiteResult<F>>;
 export { promisify as default };
+//# sourceMappingURL=promisify.d.ts.map

package/types/promisify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"promisify.d.ts","sourceRoot":"","sources":["../src/exports/promisify.ts","../src/hooks/optional/OptionalTypes.ts","../src/hooks/optional/optional.ts","../src/core/isolate/IsolateTypes.ts","../src/core/isolate/isolate.ts","../src/core/isolate/reconciler/Reconciler/Reconciler.ts","../src/core/isolate/reconciler/isSameProfileTest.ts","../src/core/isolate/reconciler/cancelOverriddenPendingTest.ts","../src/errors/ErrorStrings.ts","../src/suiteResult/Severity.ts","../src/core/isolate/walker.ts","../src/core/SuiteWalker/SuiteWalker.ts","../src/core/test/helpers/matchingFieldName.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/core/isolate/isIsolate.ts","../src/isolates/omitWhen.ts","../src/core/isolate/IsolateTest/IsolateTestReconciler.ts","../src/core/isolate/IsolateTest/SimpleStateMachine.ts","../src/core/isolate/IsolateTest/IsolateTestStateMachine.ts","../src/core/test/TestTypes.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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIA,iBAAS,SAAS,CAAC,CAAC,SAAS,UAAU,EACrC,WAAW,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,cAAc,CAAC,CAAC,CAAC,aAEjC,GAAG,EAAE,KAAG,QAAQ,YAAY,CAAC,CAAC,CAAC,CAQjD"}

package/types/vest.d.ts

@@ -1,13 +1,41 @@
 import { enforce } from 'n4s';
-type SuiteSummary = {
+import { CB } from "vest-utils";
+interface Done<F extends TFieldName> {
+    (...args: [
+        cb: (res: SuiteResult<F>) => void
+    ]): SuiteRunResult<F>;
+    (...args: [
+        fieldName: F,
+        cb: (res: SuiteResult<F>) => void
+    ]): SuiteRunResult<F>;
+}
+// eslint-disable-next-line max-lines-per-function, max-statements
+declare function suiteSelectors<F extends TFieldName>(summary: SuiteSummary<F>): SuiteSelectors<F>;
+interface SuiteSelectors<F extends TFieldName> {
+    getErrors(fieldName: F): string[];
+    getErrors(): FailureMessages;
+    getWarnings(): FailureMessages;
+    getWarnings(fieldName: F): string[];
+    getErrorsByGroup(groupName: string, fieldName: F): string[];
+    getErrorsByGroup(groupName: string): FailureMessages;
+    getWarningsByGroup(groupName: string): FailureMessages;
+    getWarningsByGroup(groupName: string, fieldName: F): string[];
+    hasErrors(fieldName?: F): boolean;
+    hasWarnings(fieldName?: F): boolean;
+    hasErrorsByGroup(groupName: string, fieldName?: F): boolean;
+    hasWarningsByGroup(groupName: string, fieldName?: F): boolean;
+    isValid(fieldName?: F): boolean;
+    isValidByGroup(groupName: string, fieldName?: F): boolean;
+}
+type SuiteSummary<F extends TFieldName> = {
     groups: Groups;
-    tests: Tests;
+    tests: Tests<F>;
     valid: boolean;
 } & SummaryBase;
 type GroupTestSummary = SingleTestSummary;
 type Groups = Record<string, Group>;
 type Group = Record<string, GroupTestSummary>;
-type Tests = Record<string, SingleTestSummary>;
+type Tests<F extends TFieldName> = Record<F, SingleTestSummary>;
 type SingleTestSummary = SummaryBase & {
     errors: string[];
     warnings: string[];
@@ -19,38 +47,110 @@ type SummaryBase = {
     testCount: number;
 };
 type FailureMessages = Record<string, string[]>;
-declare enum TestSeverity {
-    Error = "error",
-    Warning = "warning"
+type SuiteResult<F extends TFieldName> = SuiteSummary<F> & SuiteSelectors<F> & {
+    suiteName: SuiteName;
+};
+type SuiteRunResult<F extends TFieldName> = SuiteResult<F> & {
+    done: Done<F>;
+};
+type SuiteName = string | undefined;
+type TFieldName<T extends string = string> = T;
+type OptionalsInput<F extends TFieldName> = F | F[] | OptionalsObject<F>;
+type OptionalsObject<F extends TFieldName> = Record<F, (() => boolean) | boolean>;
+declare function optional<F extends TFieldName>(optionals: OptionalsInput<F>): void;
+declare enum IsolateTypes {
+    DEFAULT = "DEFAULT",
+    TEST = "TEST",
+    SUITE = "SUITE",
+    EACH = "EACH",
+    GROUP = "GROUP",
+    SKIP_WHEN = "SKIP_WHEN",
+    OMIT_WHEN = "OMIT_WHEN",
+    TEST_MEMO = "TEST_MEMO"
+}
+type IsolateKey = null | string;
+declare class Isolate<T extends IsolateTypes = IsolateTypes, _D = any> {
+    type: T;
+    children: Isolate[] | null;
+    keys: Record<string, Isolate>;
+    parent: Isolate | null;
+    output?: any;
+    key: IsolateKey;
+    static reconciler: typeof Reconciler;
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    constructor(type: T, _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;
+    static create<Callback extends CB = CB>(type: IsolateTypes, callback: Callback, data?: any): Isolate;
+    private static createImplementation;
+    static setNode(node: Isolate): void;
+    static is(node: any): boolean;
+}
+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;
+}
+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 class VestTest {
-    fieldName: string;
+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 IsolateTestInput = {
+    message?: string;
+    groupName?: string;
+    fieldName: TFieldName;
+    testFn: TestFn;
+    key?: IsolateKey;
+};
+declare class IsolateTest extends Isolate<IsolateTypes.TEST> {
+    children: null;
+    fieldName: TFieldName;
     testFn: TestFn;
-    asyncTest?: AsyncTest;
     groupName?: string;
     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(type: IsolateTypes.TEST, { fieldName, testFn, message, groupName, key }: IsolateTestInput);
+    static factory<Callback extends CB = CB>(callback: Callback, data: IsolateTestInput): IsolateTest;
+    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 +163,34 @@ declare class VestTest {
     isNonActionable(): boolean;
     isTested(): boolean;
     awaitsResolution(): boolean;
-    statusEquals(status: KStatus): boolean;
-}
-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[];
-    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;
+    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;
 }
-type SuiteResult = SuiteSummary & SuiteSelectors & {
-    suiteName: SuiteName;
-};
-type SuiteRunResult = SuiteResult & {
-    done: Done;
-};
-interface Done {
-    (...args: [
-        cb: (res: SuiteResult) => void
-    ]): SuiteRunResult;
-    (...args: [
-        fieldName: string,
-        cb: (res: SuiteResult) => void
-    ]): SuiteRunResult;
+declare enum TestSeverity {
+    Error = "error",
+    Warning = "warning"
 }
-type CreateProperties = {
-    get: () => SuiteResult;
+declare function createSuite<T extends CB, F extends TFieldName>(suiteName: SuiteName, suiteCallback: T): Suite<T, F>;
+declare function createSuite<T extends CB, F extends TFieldName>(suiteCallback: T): Suite<T, F>;
+type Suite<T extends CB, F extends TFieldName> = ((...args: Parameters<T>) => SuiteRunResult<F>) & SuiteMethods<F>;
+type SuiteMethods<F extends TFieldName> = {
+    get: () => SuiteResult<F>;
     reset: () => void;
-    resetField: (fieldName: string) => void;
-    remove: (fieldName: string) => void;
-};
-type Suite<T extends CB> = {
-    (...args: Parameters<T>): SuiteRunResult;
-} & CreateProperties;
-/**
- * Creates a new validation suite
- *
- * @example
- *
- * const suite = create((data = {}) => {
- *  test("username", "Username is required", () => {
- *    enforce(data.username).isNotBlank();
- *  });
- * });
- */
-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
-}
-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.
- *
- * @example
- *
- * optional('field_name');
- *
- * optional({
- *  username: () => allowUsernameEmpty,
- * });
- */
-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
-}
-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>;
-};
-type TestObjects = {
-    prev: VestTests;
-    current: VestTests;
-};
-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>;
-    };
-    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;
-    };
+    remove: (fieldName: F) => void;
+    resetField: (fieldName: F) => void;
 };
-declare const context: typeof _default;
 /**
  * Iterates over an array of items, allowing to run tests individually per item.
  *
@@ -244,6 +206,7 @@ declare const context: typeof _default;
  */
 declare function each<T>(list: T[], callback: (arg: T, index: number) => void): void;
 type ExclusionItem = string | string[] | undefined;
+type FieldExclusion<F extends TFieldName> = F | F[] | undefined;
 /**
  * Adds a field or a list of fields into the inclusion list
  *
@@ -251,7 +214,7 @@ type ExclusionItem = string | string[] | undefined;
  *
  * only('username');
  */
-declare function only(item: ExclusionItem): void;
+declare function only<F extends TFieldName>(item: FieldExclusion<F>): void;
 declare namespace only {
     var group: (item: ExclusionItem) => void;
 }
@@ -262,22 +225,13 @@ declare namespace only {
  *
  * skip('username');
  */
-declare function skip(item: ExclusionItem): void;
+declare function skip<F extends TFieldName>(item: FieldExclusion<F>): void;
 declare namespace skip {
     var group: (item: ExclusionItem) => void;
 }
-/**
- * Runs tests within a group so that they can be controlled or queried separately.
- *
- * @example
- *
- * group('group_name', () => {
- *  // Tests go here
- * });
- */
-declare function group(groupName: string, tests: () => void): void;
-declare function include(fieldName: string): {
-    when: (condition: string | boolean | ((draft: SuiteResult) => boolean)) => void;
+declare function group(groupName: string, callback: () => void): Isolate;
+declare function include<F extends TFieldName>(fieldName: F): {
+    when: (condition: F | TFieldName | boolean | ((draft: SuiteResult<F>) => boolean)) => void;
 };
 /**
  * Sets the suite to "eager" (fail fast) mode.
@@ -308,7 +262,7 @@ declare function eager(): void;
  *  test('username', 'User already taken', async () => await doesUserExist(username)
  * });
  */
-declare function omitWhen(conditional: boolean | ((draft: SuiteResult) => boolean), callback: CB): void;
+declare function omitWhen<F extends TFieldName>(conditional: boolean | ((draft: SuiteResult<F>) => boolean), callback: CB): void;
 /**
  * Conditionally skips running tests within the callback.
  *
@@ -318,30 +272,21 @@ 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;
-/**
- * Represents a single case in a validation suite.
- *
- * @example
- *
- * test("username", "Username is required", () => {
- *  enforce(data.username).isNotBlank();
- * });
- */
-declare const test: typeof testBase & {
+declare function skipWhen<F extends TFieldName>(condition: boolean | ((draft: SuiteResult<F>) => boolean), callback: CB): 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: {
-        (fieldName: string, test: TestFn, deps: unknown[]): VestTest;
-        (fieldName: string, message: string, test: TestFn, deps: unknown[]): VestTest;
+        (fieldName: string, test: TestFn, dependencies: unknown[]): IsolateTest;
+        (fieldName: string, message: string, test: TestFn, dependencies: unknown[]): IsolateTest;
     };
 };
 /**
  * Sets a running test to warn only mode.
  */
 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, eager, each };
+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/core/isolate/IsolateTypes.ts","../src/core/isolate/isolate.ts","../src/core/isolate/reconciler/Reconciler/Reconciler.ts","../src/core/isolate/reconciler/isSameProfileTest.ts","../src/core/isolate/reconciler/cancelOverriddenPendingTest.ts","../src/errors/ErrorStrings.ts","../src/suiteResult/Severity.ts","../src/core/isolate/walker.ts","../src/core/SuiteWalker/SuiteWalker.ts","../src/core/test/helpers/matchingFieldName.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/core/isolate/isIsolate.ts","../src/isolates/omitWhen.ts","../src/core/isolate/IsolateTest/IsolateTestReconciler.ts","../src/core/isolate/IsolateTest/SimpleStateMachine.ts","../src/core/isolate/IsolateTest/IsolateTestStateMachine.ts","../src/core/test/TestTypes.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","../src/hooks/optional/OptionalTypes.ts","../src/hooks/optional/optional.ts","../src/suite/createSuite.ts","../src/isolates/each.ts","../src/isolates/group.ts","../src/hooks/include.ts","../src/core/test/test.memo.ts","../src/core/test/testLevelFlowControl/verifyTestRun.ts","../src/core/test/testLevelFlowControl/runTest.ts","../src/core/test/testObjectIsolate.ts","../src/core/test/test.ts","../src/hooks/warn.ts"],"names":[],"mappings":"AAAA,OAAO,WAAW,MAAM,KAAK,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkB9B,OAAO,qIAeN,CAAC;AAEF,YAAY,iEAAiE,CAAC"}

package/CHANGELOG.md

@@ -1,87 +0,0 @@
-# vest - Changelog
-
-All notable changes to this project will be documented in this file.
-
-The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/) and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
-
-## 3.2.7 - 2021-07-17
-
-### Fixed and improved
-
-- .github/PULL_REQUEST_TEMPLATE.md
-- aec6cd6 chore: cleanup unused code (ealush)
-- 0103b38 lint: handling lint of all packages (ealush)
-- .gitignore
-- 03cf487 patch(n4s): add ruleReturn default values (ealush)
-- 76e8c98 fix(n4s): make enforce compound runners fall back to correct response (ealush)
-- ff91bd2 fix(n4s): make enforce chaining work (ealush)
-- c3fd912 chore: some lint fixes (ealush)
-- f6321cf add cli options support (ealush)
-- 49b6b84 Vest 4 Infra Setup (ealush)
-- ba6c296 patch: remove unused optional references from the state (ealush)
-
-## 3.2.6 - 2021-07-17
-
-### Fixed and improved
-
-- .github/PULL_REQUEST_TEMPLATE.md
-- aec6cd6 chore: cleanup unused code (ealush)
-- 0103b38 lint: handling lint of all packages (ealush)
-- .gitignore
-- 03cf487 patch(n4s): add ruleReturn default values (ealush)
-- 76e8c98 fix(n4s): make enforce compound runners fall back to correct response (ealush)
-- ff91bd2 fix(n4s): make enforce chaining work (ealush)
-- c3fd912 chore: some lint fixes (ealush)
-- f6321cf add cli options support (ealush)
-- 49b6b84 Vest 4 Infra Setup (ealush)
-- ba6c296 patch: remove unused optional references from the state (ealush)
-
-## 3.2.5 - 2021-07-17
-
-### Fixed and improved
-
-- .github/PULL_REQUEST_TEMPLATE.md
-- aec6cd6 chore: cleanup unused code (ealush)
-- 0103b38 lint: handling lint of all packages (ealush)
-- .gitignore
-- 03cf487 patch(n4s): add ruleReturn default values (ealush)
-- 76e8c98 fix(n4s): make enforce compound runners fall back to correct response (ealush)
-- ff91bd2 fix(n4s): make enforce chaining work (ealush)
-- c3fd912 chore: some lint fixes (ealush)
-- f6321cf add cli options support (ealush)
-- 49b6b84 Vest 4 Infra Setup (ealush)
-- ba6c296 patch: remove unused optional references from the state (ealush)
-
-## 1.0.31 - 2021-07-02
-
-### Fixed and improved
-
-- e6ea7d6 support global replaces (undefined)
-- 34e0414 improved conditions (undefined)
-- 26c28c6 all tests pass (undefined)
-- 33f4e46 release (undefined)
-- 6fe40c7 better bundle (undefined)
-- c2cfb65 better typing (undefined)
-- c6387ab before ts settings (undefined)
-- c0e9708 generate correct d.ts file (undefined)
-- packages/vest/types/vest.development.d.ts
-- 8e01b8e x (undefined)
-- afb3960 x (undefined)
-- e0a8463 add changelog support (undefined)
-- cc46c38 current (undefined)
-- 4a2073f patch(vest): changes (ealush)
-- c0a1705 patch(vest): changes (ealush)
-- 240386c better create generic (ealush)
-- b6db1c6 transform any to unknowns (ealush)
-- f2c20a7 add done integration tests (ealush)
-- ba56e33 produce methods (ealush)
-- 0638243 better produce integration tests (ealush)
-- 4098a11 getFailures as integration tests (ealush)
-- f56cf7f pd (ealush)
-- 2ea440e pd (ealush)
-- b3032ef relocate draftresult (ealush)
-- 962141f test getFailuresByGroup (ealush)
-- e163c56 test getFailures (ealush)
-- a92b6df test collectFailureMessages (ealush)
-- 81aad51 fix most tests (ealush)
-- c149e90 simplify collectFailureMessages (ealush)

package/testUtils/expandStateRef.ts

@@ -1,8 +0,0 @@
-export default function expandStateRef(stateRef) {
-  const state = {};
-  for (const key in stateRef) {
-    const [value] = stateRef[key]();
-    state[key] = value;
-  }
-  return state;
-}