vest 5.0.0-dev-781e21 → 5.0.0-dev-9c596e

package/types/vest.d.ts

@@ -1,56 +1,166 @@
 import { enforce } from 'n4s';
-type SuiteSummary = {
-    groups: Groups;
-    tests: Tests;
+import { CB } from "vest-utils";
+declare enum Severity {
+    WARNINGS = "warnings",
+    ERRORS = "errors"
+}
+type TestFn = () => TestResult;
+type AsyncTest = Promise<string | void | false>;
+type TestResult = AsyncTest | boolean | void;
+type WithFieldName<F extends TFieldName = TFieldName> = {
+    fieldName: F;
+};
+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>;
+}
+// eslint-disable-next-line max-lines-per-function, max-statements
+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: 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;
+}
+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;
-} & SummaryBase;
+}
 type GroupTestSummary = SingleTestSummary;
-type Groups = Record<string, Group>;
-type Group = Record<string, GroupTestSummary>;
-type Tests = Record<string, 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 SummaryBase = {
-    errorCount: number;
-    warnCount: number;
-    testCount: number;
+type SummaryFailure<F extends TFieldName, G extends TGroupName> = WithFieldName<F> & {
+    groupName: G | undefined;
+    message: string | undefined;
 };
 type FailureMessages = Record<string, string[]>;
-declare enum TestSeverity {
-    Error = "error",
-    Warning = "warning"
+type SuiteResult<F extends TFieldName, G extends TGroupName> = SuiteSummary<F, G> & SuiteSelectors<F, G> & {
+    suiteName: SuiteName;
+};
+type SuiteRunResult<F extends TFieldName, G extends TGroupName> = SuiteResult<F, G> & {
+    done: Done<F, G>;
+};
+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;
+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 VestTest {
-    fieldName: string;
-    testFn: TestFn;
-    asyncTest?: AsyncTest;
+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;
-    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 +173,105 @@ 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;
-    reset: () => void;
-    resetField: (fieldName: string) => void;
-    remove: (fieldName: string) => void;
-};
-type Suite<T extends CB> = {
-    (...args: Parameters<T>): SuiteRunResult;
-} & CreateProperties;
+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>;
+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 OptionalFields = Record<string, OptionalFieldDeclaration>;
-type TestCallbacks = {
-    fieldCallbacks: Record<string, Array<(res: SuiteResult) => void>>;
-    doneCallbacks: Array<(res: SuiteResult) => void>;
+type TestMemo<F extends TFieldName> = {
+    (fieldName: F, ...args: ParametersWithoutMessage): IsolateTest;
+    (fieldName: F, ...args: ParametersWithMessage): IsolateTest;
 };
-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>;
+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<T extends CB, F extends TFieldName, G extends TGroupName> = ((...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>;
 /**
  * Iterates over an array of items, allowing to run tests individually per item.
  *
@@ -243,42 +286,15 @@ declare const context: typeof _default;
  * })
  */
 declare function each<T>(list: T[], callback: (arg: T, index: number) => void): void;
-type ExclusionItem = string | string[] | undefined;
-/**
- * Adds a field or a list of fields into the inclusion list
- *
- * @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
- *
- * @example
- *
- * 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.
- *
- * @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<G extends TGroupName>(groupName: G, callback: () => void): Isolate;
+// @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 {
+    ALL = "ALL",
+    EAGER = "EAGER"
+}
 /**
  * Sets the suite to "eager" (fail fast) mode.
  * Eager mode will skip running subsequent tests of a failing fields.
@@ -298,7 +314,8 @@ declare function include(fieldName: string): {
  *  });
  * });
  */
-declare function eager(): void;
+// @vx-allow use-use
+declare function mode(mode: Modes): void;
 /**
  * Conditionally omits tests from the suite.
  *
@@ -308,7 +325,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 +336,15 @@ 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 & {
-    memo: {
-        (fieldName: string, test: TestFn, deps: unknown[]): VestTest;
-        (fieldName: string, message: string, test: TestFn, deps: unknown[]): VestTest;
-    };
-};
+// @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.
  */
+// @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/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"}

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;
-}