vest 4.6.0 → 4.6.2-dev-b07a89

package/types/enforce/schema.d.ts

@@ -1,144 +1,2 @@
-type DropFirst<T extends unknown[]> = T extends [
-    unknown,
-    ...infer U
-] ? U : never;
-type Stringable = string | ((...args: any[]) => string);
-type CB = (...args: any[]) => any;
-type EnforceCustomMatcher<F extends CB, R> = (...args: DropFirst<Parameters<F>>) => R;
-type RuleReturn = boolean | {
-    pass: boolean;
-    message?: Stringable;
-};
-type RuleDetailedResult = {
-    pass: boolean;
-    message?: string;
-};
-type Args = any[];
-type BaseRules = typeof baseRules;
-type KBaseRules = keyof BaseRules;
-declare function condition(value: any, callback: (value: any) => RuleReturn): RuleReturn;
-declare function endsWith(value: string, arg1: string): boolean;
-declare function equals(value: unknown, arg1: unknown): boolean;
-declare function greaterThanOrEquals(value: string | number, gte: string | number): boolean;
-declare function inside(value: unknown, arg1: string | unknown[]): boolean;
-declare function isBetween(value: number | string, min: number | string, max: number | string): boolean;
-declare function isBlank(value: unknown): boolean;
-declare function isKeyOf(key: string | symbol | number, obj: any): boolean;
-declare function isNaN(value: unknown): boolean;
-declare function isNegative(value: number | string): boolean;
-declare function isNumber(value: unknown): value is number;
-declare function isTruthy(value: unknown): boolean;
-declare function isValueOf(value: any, objectToCheck: any): boolean;
-declare function lessThan(value: string | number, lt: string | number): boolean;
-declare function lessThanOrEquals(value: string | number, lte: string | number): boolean;
-declare function longerThanOrEquals(value: string | unknown[], arg1: string | number): boolean;
-declare function matches(value: string, regex: RegExp | string): boolean;
-declare function shorterThan(value: string | unknown[], arg1: string | number): boolean;
-declare function shorterThanOrEquals(value: string | unknown[], arg1: string | number): boolean;
-declare function startsWith(value: string, arg1: string): boolean;
-declare const baseRules: {
-    condition: typeof condition;
-    doesNotEndWith: (value: string, arg1: string) => boolean;
-    doesNotStartWith: (value: string, arg1: string) => boolean;
-    endsWith: typeof endsWith;
-    equals: typeof equals;
-    greaterThan: typeof import("packages/vest-utils/types/vest-utils").greaterThan;
-    greaterThanOrEquals: typeof greaterThanOrEquals;
-    gt: typeof import("packages/vest-utils/types/vest-utils").greaterThan;
-    gte: typeof greaterThanOrEquals;
-    inside: typeof inside;
-    isArray: typeof import("packages/vest-utils/types/vest-utils").isArray;
-    isBetween: typeof isBetween;
-    isBlank: typeof isBlank;
-    isBoolean: typeof import("packages/vest-utils/types/vest-utils").isBoolean;
-    isEmpty: typeof import("packages/vest-utils/types/vest-utils").isEmpty;
-    isEven: (value: any) => boolean;
-    isFalsy: (value: unknown) => boolean;
-    isKeyOf: typeof isKeyOf;
-    isNaN: typeof isNaN;
-    isNegative: typeof isNegative;
-    isNotArray: (value: unknown) => boolean;
-    isNotBetween: (value: string | number, min: string | number, max: string | number) => boolean;
-    isNotBlank: (value: unknown) => boolean;
-    isNotBoolean: (value: unknown) => boolean;
-    isNotEmpty: (value: unknown) => boolean;
-    isNotKeyOf: (key: string | number | symbol, obj: any) => boolean;
-    isNotNaN: (value: unknown) => boolean;
-    isNotNull: (value: unknown) => boolean;
-    isNotNullish: (value: any) => boolean;
-    isNotNumber: (value: unknown) => boolean;
-    isNotNumeric: (value: string | number) => boolean;
-    isNotString: (v: unknown) => boolean;
-    isNotUndefined: (value?: unknown) => boolean;
-    isNotValueOf: (value: any, objectToCheck: any) => boolean;
-    isNull: typeof import("packages/vest-utils/types/vest-utils").isNull;
-    isNullish: typeof import("packages/vest-utils/types/vest-utils").isNullish;
-    isNumber: typeof isNumber;
-    isNumeric: typeof import("packages/vest-utils/types/vest-utils").isNumeric;
-    isOdd: (value: any) => boolean;
-    isPositive: typeof import("packages/vest-utils/types/vest-utils").isPositive;
-    isString: typeof import("packages/vest-utils/types/vest-utils").isStringValue;
-    isTruthy: typeof isTruthy;
-    isUndefined: typeof import("packages/vest-utils/types/vest-utils").isUndefined;
-    isValueOf: typeof isValueOf;
-    lengthEquals: typeof import("packages/vest-utils/types/vest-utils").lengthEquals;
-    lengthNotEquals: (value: string | unknown[], arg1: string | number) => boolean;
-    lessThan: typeof lessThan;
-    lessThanOrEquals: typeof lessThanOrEquals;
-    longerThan: typeof import("packages/vest-utils/types/vest-utils").longerThan;
-    longerThanOrEquals: typeof longerThanOrEquals;
-    lt: typeof lessThan;
-    lte: typeof lessThanOrEquals;
-    matches: typeof matches;
-    notEquals: (value: unknown, arg1: unknown) => boolean;
-    notInside: (value: unknown, arg1: string | unknown[]) => boolean;
-    notMatches: (value: string, regex: string | RegExp) => boolean;
-    numberEquals: typeof import("packages/vest-utils/types/vest-utils").numberEquals;
-    numberNotEquals: (value: string | number, eq: string | number) => boolean;
-    shorterThan: typeof shorterThan;
-    shorterThanOrEquals: typeof shorterThanOrEquals;
-    startsWith: typeof startsWith;
-};
-type Rules<E> = n4s.EnforceCustomMatchers<Rules<E> & E> & Record<string, (...args: Args) => Rules<E> & E> & {
-    [P in KBaseRules]: (...args: DropFirst<Parameters<BaseRules[P]>> | Args) => Rules<E> & E;
-};
-/* eslint-disable @typescript-eslint/no-namespace, @typescript-eslint/no-empty-interface */
-declare global {
-    namespace n4s {
-        interface IRules<E> extends Rules<E> {
-        }
-    }
-}
-type LazyRules = n4s.IRules<LazyRuleMethods>;
-type Lazy = LazyRules & LazyRuleMethods & 
-// This is a "catch all" hack to make TS happy while not
-// losing type hints
-Record<string, CB>;
-type LazyRuleMethods = LazyRuleRunners & {
-    message: (message: LazyMessage) => Lazy;
-};
-type LazyRuleRunners = {
-    test: (value: unknown) => boolean;
-    run: (value: unknown) => RuleDetailedResult;
-};
-type LazyMessage = string | ((value: unknown, originalMessage?: Stringable) => string);
-declare function isArrayOf(inputArray: any[], currentRule: LazyRuleRunners): RuleDetailedResult;
-interface ShapeObject extends Record<string, any>, Record<string, LazyRuleRunners> {
-}
-declare function loose(inputObject: Record<string, any>, shapeObject: ShapeObject): RuleDetailedResult;
-declare function optional(value: any, ruleChain: Lazy): RuleDetailedResult;
-declare function shape(inputObject: Record<string, any>, shapeObject: ShapeObject): RuleDetailedResult;
-// Help needed improving the typings of this file.
-// Ideally, we'd be able to extend ShapeObject, but that's not possible.
-declare function partial<T extends Record<any, any>>(shapeObject: T): T;
-declare global {
-    namespace n4s {
-        interface EnforceCustomMatchers<R> {
-            isArrayOf: EnforceCustomMatcher<typeof isArrayOf, R>;
-            loose: EnforceCustomMatcher<typeof loose, R>;
-            shape: EnforceCustomMatcher<typeof shape, R>;
-            optional: EnforceCustomMatcher<typeof optional, R>;
-        }
-    }
-}
-export { partial };
+export {};
+//# sourceMappingURL=schema.d.ts.map

package/types/enforce/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/exports/enforce@schema.ts"],"names":[],"mappings":""}

package/types/parser.d.ts

@@ -26,3 +26,4 @@ interface ParsedVestObject {
     warning(fieldName?: string): 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/core/suite/produce/summaryGenerators/SuiteSummaryTypes.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;AAMA,iBAAgB,KAAK,CAAC,OAAO,EAAE,YAAY,GAAG,gBAAgB,CAuC7D;AAED,UAAU,gBAAgB;IACxB,KAAK,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;IACnC,MAAM,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;IACpC,OAAO,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;IACrC,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;IACtC,OAAO,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;CACtC"}

package/types/promisify.d.ts

@@ -52,3 +52,4 @@ type SuiteResult = SuiteSummary & SuiteSelectors & {
 };
 declare const promisify: (validatorFn: (...args: any[]) => SuiteRunResult) => (...args: any[]) => Promise<SuiteResult>;
 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/core/suite/produce/summaryGenerators/SuiteSummaryTypes.ts","../src/core/test/lib/shouldUseErrorAsMessage.ts","../src/hooks/optionalFields.ts","../src/core/state/createStateRef.ts","../src/hooks/mode/Modes.ts","../src/core/isolate/isolateCursor.ts","../src/core/isolate/generateIsolate.ts","../src/core/ctx/ctx.ts","../src/core/state/stateHooks.ts","../src/core/test/VestTest.ts","../src/core/isolate/IsolateTypes.ts","../src/core/isolate/isolateHooks.ts","../src/core/test/key.ts","../src/core/isolate/isolate.ts","../src/core/suite/produce/summaryGenerators/helpers/matchingFieldName.ts","../src/core/suite/hasRemainingTests.ts","../src/core/suite/produce/produceSuiteRunResult.ts","../src/core/test/omitOptionalFields.ts","../src/core/test/lib/removeTestFromState.ts","../src/core/suite/produce/runCallbacks.ts","../src/core/vestBus.ts","../src/core/suite/create.ts","../src/core/suite/produce/Severity.ts","../src/core/suite/produce/summaryGenerators/helpers/matchingGroupName.ts","../src/core/suite/produce/summaryGenerators/helpers/nonMatchingSeverityProfile.ts","../src/core/suite/produce/summaryGenerators/hasFailuresByTestObjects.ts","../src/core/suite/produce/summaryGenerators/shouldAddValidProperty.ts","../src/core/suite/produce/summaryGenerators/genTestsSummary.ts","../src/core/suite/produce/summarySelectors/collectFailures.ts","../src/core/suite/produce/summarySelectors/suiteSelectors.ts","../src/core/suite/produce/produceSuiteResult.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAKA,QAAA,MAAM,SAAS,0BACW,GAAG,EAAE,KAAK,cAAc,eACtC,GAAG,EAAE,KAAG,QAAQ,WAAW,CAOpC,CAAC"}

package/types/vest.d.ts

@@ -1,4 +1,6 @@
 import { enforce } from 'n4s';
+import { CB, nestedArray } from "vest-utils";
+import { UseState } from "vast";
 type SuiteSummary = {
     groups: Groups;
     tests: Tests;
@@ -69,7 +71,6 @@ 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 {
@@ -152,13 +153,6 @@ 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.
  *
@@ -204,13 +198,8 @@ type TestObjects = {
     prev: VestTests;
     current: VestTests;
 };
-type VestTests = NestedArray<VestTest>;
-declare const _default: {
-    run: <R>(ctxRef: Partial<CTXType>, fn: (context: CTXType) => R) => R;
-    bind: <Fn extends (...args: any[]) => any>(ctxRef: Partial<CTXType>, fn: Fn) => Fn;
-    use: () => CTXType | undefined;
-    useX: (errorMessage?: string | undefined) => CTXType;
-};
+type VestTests = nestedArray.NestedArray<VestTest>;
+declare const _default: import("context").CtxCascadeApi<CTXType>;
 type CTXType = {
     isolate: Isolate;
     stateRef?: StateRef;
@@ -347,6 +336,7 @@ declare const test: typeof testBase & {
  * Sets a running test to warn only mode.
  */
 declare function warn(): void;
-declare const VERSION = "4.6.0";
+declare const VERSION = "4.6.2-dev-b07a89";
 export { suiteSelectors, test, create, each, only, skip, warn, group, optional, skipWhen, omitWhen, enforce, VERSION, context, include, eager };
 export type { SuiteResult, SuiteRunResult, SuiteSummary, VestTest, 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/suite/produce/summaryGenerators/SuiteSummaryTypes.ts","../src/core/test/lib/shouldUseErrorAsMessage.ts","../src/hooks/optionalFields.ts","../src/core/isolate/isolateCursor.ts","../src/core/isolate/IsolateTypes.ts","../src/hooks/mode/Modes.ts","../src/core/isolate/generateIsolate.ts","../src/core/ctx/ctx.ts","../src/core/isolate/isolateHooks.ts","../src/core/test/key.ts","../src/core/isolate/isolate.ts","../src/core/suite/produce/summaryGenerators/helpers/matchingFieldName.ts","../src/core/suite/hasRemainingTests.ts","../src/core/suite/produce/produceSuiteRunResult.ts","../src/core/test/omitOptionalFields.ts","../src/core/test/lib/removeTestFromState.ts","../src/core/suite/produce/runCallbacks.ts","../src/core/vestBus.ts","../src/core/suite/create.ts","../src/core/suite/produce/Severity.ts","../src/core/suite/produce/summaryGenerators/helpers/matchingGroupName.ts","../src/core/suite/produce/summaryGenerators/helpers/nonMatchingSeverityProfile.ts","../src/core/suite/produce/summaryGenerators/hasFailuresByTestObjects.ts","../src/core/suite/produce/summaryGenerators/shouldAddValidProperty.ts","../src/core/suite/produce/summaryGenerators/genTestsSummary.ts","../src/core/suite/produce/summarySelectors/collectFailures.ts","../src/core/suite/produce/summarySelectors/suiteSelectors.ts","../src/core/suite/produce/produceSuiteResult.ts","../src/core/state/createStateRef.ts","../src/core/state/stateHooks.ts","../src/core/test/VestTest.ts","../src/core/isolate/isolates/each.ts","../src/hooks/hookErrors.ts","../src/core/isolate/isolates/skipWhen.ts","../src/hooks/exclusive.ts","../src/core/isolate/isolates/group.ts","../src/hooks/include.ts","../src/hooks/mode/mode.ts","../src/core/isolate/isolates/omitWhen.ts","../src/core/test/lib/isSameProfileTest.ts","../src/core/test/lib/cancelOverriddenPendingTest.ts","../src/core/test/runAsyncTest.ts","../src/core/test/runSyncTest.ts","../src/core/test/lib/registerTest.ts","../src/core/test/lib/useTestAtCursor.ts","../src/core/test/lib/registerPrevRunTest.ts","../src/core/test/test.memo.ts","../src/core/test/test.ts","../src/hooks/warn.ts"],"names":[],"mappings":"AAAA,OAAO,WAAW,MAAM,KAAK,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoB9B,QAAA,MAAM,OAAO,qBAAqB,CAAC;AAEnC,OAAO,wIAiBN,CAAC;AAEF,YAAY,8DAA8D,CAAC"}