vest 4.3.0 → 4.3.1

package/types/enforce/schema.d.ts

@@ -2,19 +2,19 @@ type DropFirst<T extends unknown[]> = T extends [
     unknown,
     ...infer U
 ] ? U : never;
-type TStringable = string | ((...args: any[]) => string);
-type TRuleReturn = boolean | {
+type Stringable = string | ((...args: any[]) => string);
+type RuleReturn = boolean | {
     pass: boolean;
-    message?: TStringable;
+    message?: Stringable;
 };
-type TRuleDetailedResult = {
+type RuleDetailedResult = {
     pass: boolean;
     message?: string;
 };
-type TArgs = any[];
-type TBaseRules = typeof baseRules;
-type KBaseRules = keyof TBaseRules;
-declare function condition(value: any, callback: (value: any) => TRuleReturn): TRuleReturn;
+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 greaterThan(value: number | string, gt: number | string): boolean;
@@ -113,37 +113,37 @@ declare const baseRules: {
     shorterThanOrEquals: typeof shorterThanOrEquals;
     startsWith: typeof startsWith;
 };
-type TRules<E = Record<string, unknown>> = n4s.EnforceCustomMatchers<TRules<E> & E> & Record<string, (...args: TArgs) => TRules<E> & E> & {
-    [P in KBaseRules]: (...args: DropFirst<Parameters<TBaseRules[P]>> | TArgs) => TRules<E> & E;
+type Rules<E = Record<string, unknown>> = 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 TRules<E> {
+        interface IRules<E> extends Rules<E> {
         }
     }
 }
-type TLazyRules = n4s.IRules<TLazyRuleMethods>;
-type TLazy = TLazyRules & TLazyRuleMethods & 
+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, (...args: any[]) => any>;
-type TLazyRuleMethods = TLazyRuleRunners & {
-    message: (message: TLazyMessage) => TLazy;
+type LazyRuleMethods = LazyRuleRunners & {
+    message: (message: LazyMessage) => Lazy;
 };
-type TLazyRuleRunners = {
+type LazyRuleRunners = {
     test: (value: unknown) => boolean;
-    run: (value: unknown) => TRuleDetailedResult;
+    run: (value: unknown) => RuleDetailedResult;
 };
-type TLazyMessage = string | ((value: unknown, originalMessage?: TStringable) => string);
-declare function isArrayOf(inputArray: any[], currentRule: TLazyRuleRunners): TRuleDetailedResult;
-interface IShapeObject extends Record<string, any>, Record<string, TLazyRuleRunners> {
+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: IShapeObject): TRuleDetailedResult;
-declare function optional(value: any, ruleChain: TLazy): TRuleDetailedResult;
-declare function shape(inputObject: Record<string, any>, shapeObject: IShapeObject): TRuleDetailedResult;
+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 IShapeObject, but that's not possible.
+// 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 {

package/types/promisify.d.ts

@@ -19,13 +19,14 @@ type SummaryBase = {
     warnCount: number;
     testCount: number;
 };
-declare function getErrors(): Record<string, string[]>;
+type FailureMessages = Record<string, string[]>;
+declare function getErrors(): FailureMessages;
 declare function getErrors(fieldName?: string): string[];
-declare function getWarnings(): Record<string, string[]>;
+declare function getWarnings(): FailureMessages;
 declare function getWarnings(fieldName?: string): string[];
-declare function getErrorsByGroup(groupName: string): Record<string, string[]>;
+declare function getErrorsByGroup(groupName: string): FailureMessages;
 declare function getErrorsByGroup(groupName: string, fieldName: string): string[];
-declare function getWarningsByGroup(groupName: string): Record<string, string[]>;
+declare function getWarningsByGroup(groupName: string): FailureMessages;
 declare function getWarningsByGroup(groupName: string, fieldName: string): string[];
 declare function hasErrors(fieldName?: string): boolean;
 declare function hasWarnings(fieldName?: string): boolean;
@@ -48,9 +49,9 @@ type SuiteResult = ReturnType<typeof genTestsSummary> & {
     getWarningsByGroup: typeof getWarningsByGroup;
 };
 type SuiteRunResult = SuiteResult & {
-    done: IDone;
+    done: Done;
 };
-interface IDone {
+interface Done {
     (...args: [
         cb: (res: SuiteResult) => void
     ]): SuiteRunResult;

package/types/vest.d.ts

@@ -5,20 +5,20 @@ declare enum TestSeverity {
 }
 declare class VestTest {
     fieldName: string;
-    testFn: TTestFn;
-    asyncTest?: TAsyncTest;
+    testFn: TestFn;
+    asyncTest?: AsyncTest;
     groupName?: string;
     message?: string;
     key?: null | string;
     id: string;
     severity: TestSeverity;
     status: KStatus;
-    constructor(fieldName: string, testFn: TTestFn, { message, groupName, key }?: {
+    constructor(fieldName: string, testFn: TestFn, { message, groupName, key }?: {
         message?: string;
         groupName?: string;
         key?: string;
     });
-    run(): TTestResult;
+    run(): TestResult;
     setStatus(status: KStatus): void;
     warns(): boolean;
     setPending(): void;
@@ -44,10 +44,11 @@ declare class VestTest {
     isWarning(): boolean;
     statusEquals(status: KStatus): boolean;
 }
-type TAsyncTest = Promise<string | void>;
-type TTestResult = TAsyncTest | boolean | void;
-type TTestFn = () => TTestResult;
+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[]) => void;
 /**
  * Reads the testObjects list and gets full validation result from it.
  */
@@ -69,13 +70,14 @@ type SummaryBase = {
     warnCount: number;
     testCount: number;
 };
-declare function getErrors(): Record<string, string[]>;
+type FailureMessages = Record<string, string[]>;
+declare function getErrors(): FailureMessages;
 declare function getErrors(fieldName?: string): string[];
-declare function getWarnings(): Record<string, string[]>;
+declare function getWarnings(): FailureMessages;
 declare function getWarnings(fieldName?: string): string[];
-declare function getErrorsByGroup(groupName: string): Record<string, string[]>;
+declare function getErrorsByGroup(groupName: string): FailureMessages;
 declare function getErrorsByGroup(groupName: string, fieldName: string): string[];
-declare function getWarningsByGroup(groupName: string): Record<string, string[]>;
+declare function getWarningsByGroup(groupName: string): FailureMessages;
 declare function getWarningsByGroup(groupName: string, fieldName: string): string[];
 declare function hasErrors(fieldName?: string): boolean;
 declare function hasWarnings(fieldName?: string): boolean;
@@ -98,9 +100,9 @@ type SuiteResult = ReturnType<typeof genTestsSummary> & {
     getWarningsByGroup: typeof getWarningsByGroup;
 };
 type SuiteRunResult = SuiteResult & {
-    done: IDone;
+    done: Done;
 };
-interface IDone {
+interface Done {
     (...args: [
         cb: (res: SuiteResult) => void
     ]): SuiteRunResult;
@@ -115,7 +117,6 @@ type CreateProperties = {
     resetField: (fieldName: string) => void;
     remove: (fieldName: string) => void;
 };
-type CB = (...args: any[]) => void;
 type Suite<T extends CB> = {
     (...args: Parameters<T>): SuiteRunResult;
 } & CreateProperties;
@@ -158,35 +159,35 @@ declare enum Modes {
 }
 type NestedArray<T> = Array<NestedArray<T> | T>;
 // eslint-disable-next-line max-lines-per-function
-declare function createState(onStateChange?: (...args: unknown[]) => unknown): TCreateStateReturn;
-type TStateInput<S> = S | ((prevState?: S) => S);
-type TSetStateInput<S> = S | ((prevState: S) => S);
-type TState = ReturnType<typeof createState>;
-type TStateHandlerReturn<S> = [
+declare function createState(onStateChange?: (...args: unknown[]) => unknown): CreateStateReturn;
+type StateInput<S> = S | ((prevState?: S) => S);
+type SetStateInput<S> = S | ((prevState: S) => S);
+type State = ReturnType<typeof createState>;
+type StateHandlerReturn<S> = [
     S,
-    (nextState: TSetStateInput<S>) => void
+    (nextState: SetStateInput<S>) => void
 ];
-type TCreateStateReturn = {
+type CreateStateReturn = {
     reset: () => void;
-    registerStateKey: <S>(initialState?: TStateInput<S> | undefined, onUpdate?: (() => void) | undefined) => () => TStateHandlerReturn<S>;
+    registerStateKey: <S>(initialState?: StateInput<S> | undefined, onUpdate?: (() => void) | undefined) => () => StateHandlerReturn<S>;
 };
-declare function createStateRef(state: TState, { suiteId, suiteName }: {
+declare function createStateRef(state: State, { suiteId, suiteName }: {
     suiteId: string;
     suiteName?: void | string;
 }): {
-    optionalFields: () => TStateHandlerReturn<Record<string, boolean | (() => boolean)>>;
-    suiteId: () => TStateHandlerReturn<string>;
-    suiteName: () => TStateHandlerReturn<string | void>;
-    testCallbacks: () => TStateHandlerReturn<{
+    optionalFields: () => StateHandlerReturn<Record<string, boolean | (() => boolean)>>;
+    suiteId: () => StateHandlerReturn<string>;
+    suiteName: () => StateHandlerReturn<string | void>;
+    testCallbacks: () => StateHandlerReturn<{
         fieldCallbacks: Record<string, ((res: SuiteResult) => void)[]>;
         doneCallbacks: ((res: SuiteResult) => void)[];
     }>;
-    testObjects: () => TStateHandlerReturn<{
+    testObjects: () => StateHandlerReturn<{
         prev: NestedArray<VestTest>;
         current: NestedArray<VestTest>;
     }>;
 };
-type TStateRef = ReturnType<typeof createStateRef>;
+type StateRef = ReturnType<typeof createStateRef>;
 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;
@@ -199,7 +200,7 @@ type CTXType = {
         keys: IsolateKeys;
     };
     testCursor: ReturnType<typeof createCursor>;
-    stateRef?: TStateRef;
+    stateRef?: StateRef;
     exclusion: {
         tests: Record<string, boolean>;
         groups: Record<string, boolean>;
@@ -213,11 +214,12 @@ type CTXType = {
         Modes
     ];
     bus?: {
-        on: (event: string, handler: (...args: any[]) => void) => {
+        on: (event: string, handler: CB) => {
             off: () => void;
         };
         emit: (event: string, ...args: any[]) => void;
     };
+    summary?: SuiteSummary;
 };
 declare const context: typeof _default;
 /**
@@ -234,7 +236,7 @@ declare const context: typeof _default;
  * })
  */
 declare function each<T>(list: T[], callback: (arg: T, index: number) => void): void;
-type TExclusionItem = string | string[] | undefined;
+type ExclusionItem = string | string[] | undefined;
 /**
  * Adds a field or a list of fields into the inclusion list
  *
@@ -242,9 +244,9 @@ type TExclusionItem = string | string[] | undefined;
  *
  * only('username');
  */
-declare function only(item: TExclusionItem): void;
+declare function only(item: ExclusionItem): void;
 declare namespace only {
-    var group: (item: TExclusionItem) => void;
+    var group: (item: ExclusionItem) => void;
 }
 /**
  * Adds a field or a list of fields into the exclusion list
@@ -253,9 +255,9 @@ declare namespace only {
  *
  * skip('username');
  */
-declare function skip(item: TExclusionItem): void;
+declare function skip(item: ExclusionItem): void;
 declare namespace skip {
-    var group: (item: TExclusionItem) => void;
+    var group: (item: ExclusionItem) => void;
 }
 /**
  * Runs tests within a group so that they can be controlled or queried separately.
@@ -299,7 +301,7 @@ declare function eager(): void;
  *  test('username', 'User already taken', async () => await doesUserExist(username)
  * });
  */
-declare function omitWhen(conditional: boolean | ((draft: SuiteResult) => boolean), callback: (...args: any[]) => void): void;
+declare function omitWhen(conditional: boolean | ((draft: SuiteResult) => boolean), callback: CB): void;
 /**
  * Marks a field as optional, either just by name, or by a given condition.
  *
@@ -311,9 +313,9 @@ declare function omitWhen(conditional: boolean | ((draft: SuiteResult) => boolea
  *  username: () => allowUsernameEmpty,
  * });
  */
-declare function optional(optionals: TOptionalsInput): void;
-type TOptionalsInput = string | string[] | TOptionalsObject;
-type TOptionalsObject = Record<string, () => boolean>;
+declare function optional(optionals: OptionalsInput): void;
+type OptionalsInput = string | string[] | OptionalsObject;
+type OptionalsObject = Record<string, () => boolean>;
 /**
  * Conditionally skips running tests within the callback.
  *
@@ -323,11 +325,11 @@ type TOptionalsObject = Record<string, () => boolean>;
  *  test('username', 'User already taken', async () => await doesUserExist(username)
  * });
  */
-declare function skipWhen(conditional: boolean | ((draft: SuiteResult) => boolean), callback: (...args: any[]) => void): void;
-declare function testBase(fieldName: string, message: string, cb: TTestFn): VestTest;
-declare function testBase(fieldName: string, cb: TTestFn): VestTest;
-declare function testBase(fieldName: string, message: string, cb: TTestFn, key: string): VestTest;
-declare function testBase(fieldName: string, cb: TTestFn, key: string): VestTest;
+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.
  *
@@ -339,14 +341,14 @@ declare function testBase(fieldName: string, cb: TTestFn, key: string): VestTest
  */
 declare const test: typeof testBase & {
     memo: {
-        (fieldName: string, test: TTestFn, deps: unknown[]): VestTest;
-        (fieldName: string, message: string, test: TTestFn, deps: unknown[]): VestTest;
+        (fieldName: string, test: TestFn, deps: unknown[]): VestTest;
+        (fieldName: string, message: string, test: TestFn, deps: unknown[]): VestTest;
     };
 };
 /**
  * Sets a running test to warn only mode.
  */
 declare function warn(): void;
-declare const VERSION = "4.3.0";
+declare const VERSION = "4.3.1";
 export { test, create, each, only, skip, warn, group, optional, skipWhen, omitWhen, enforce, VERSION, context, include, eager };
 export type { SuiteResult, SuiteRunResult, SuiteSummary, VestTest, Suite };