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

package/types/parser.d.ts

@@ -1,28 +1,157 @@
-type SuiteSummary = {
-    groups: Groups;
-    tests: Tests;
+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
+    ]): SuiteRunResult<F, G>;
+    (...args: [
+        fieldName: F,
+        cb: (res: SuiteResult<F, G>) => void
+    ]): SuiteRunResult<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 FailureMessages = Record<string, string[]>;
+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>;
 };
-declare function parse(summary: SuiteSummary): ParsedVestObject;
-interface ParsedVestObject {
-    valid(fieldName?: string): boolean;
-    tested(fieldName?: string): boolean;
-    invalid(fieldName?: string): boolean;
-    untested(fieldName?: string): boolean;
-    warning(fieldName?: string): boolean;
+type SuiteName = string | undefined;
+type TFieldName<T extends string = string> = T;
+type TGroupName<G extends string = string> = G;
+declare function parse<F extends TFieldName, G extends TGroupName>(summary: SuiteSummary<F, G>): ParsedVestObject<F>;
+interface ParsedVestObject<F extends TFieldName> {
+    valid(fieldName?: F): boolean;
+    tested(fieldName?: F): boolean;
+    invalid(fieldName?: F): boolean;
+    untested(fieldName?: F): boolean;
+    warning(fieldName?: F): boolean;
 }
 export { parse };
+//# sourceMappingURL=parser.d.ts.map

package/types/parser.d.ts.map

@@ -0,0 +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/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,54 +1,150 @@
-type SuiteSummary = {
-    groups: Groups;
-    tests: Tests;
+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
+    ]): SuiteRunResult<F, G>;
+    (...args: [
+        fieldName: F,
+        cb: (res: SuiteResult<F, G>) => void
+    ]): SuiteRunResult<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 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, G extends TGroupName> = SuiteSummary<F, G> & SuiteSelectors<F, G> & {
     suiteName: SuiteName;
 };
-declare const promisify: (validatorFn: (...args: any[]) => SuiteRunResult) => (...args: any[]) => Promise<SuiteResult>;
+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;
+declare function promisify<F extends TFieldName, G extends TGroupName>(validatorFn: (...args: any[]) => SuiteRunResult<F, G>): (...args: any[]) => Promise<SuiteResult<F, G>>;
 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/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"}