n4s 5.0.0 → 5.0.2

package/types/email.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="validator" />
+import isEmail from 'validator/es/lib/isEmail';
+import { CB, DropFirst } from "vest-utils";
+type EnforceCustomMatcher<F extends CB, R> = (...args: DropFirst<Parameters<F>>) => R;
+declare global {
+    namespace n4s {
+        interface EnforceCustomMatchers<R> {
+            isEmail: EnforceCustomMatcher<typeof isEmail, R>;
+        }
+    }
+}
+//# sourceMappingURL=email.d.ts.map

package/types/email.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"email.d.ts","sourceRoot":"","sources":["../src/exports/email.ts","../src/lib/enforceUtilityTypes.ts"],"names":[],"mappings":";AACA,OAAO,OAAO,MAAM,0BAA0B,CAAC;;;AAO/C,QAAQ,MAAM,CAAC;IACb,UAAU,GAAG,CAAC;QACZ,UAAU,qBAAqB,CAAC,CAAC;YAC/B,OAAO,EAAE,oBAAoB,CAAC,OAAO,OAAO,EAAE,CAAC,CAAC,CAAC;SAClD;KACF;CACF"}

package/types/isURL.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="validator" />
+import isURL from 'validator/es/lib/isURL';
+import { CB, DropFirst } from "vest-utils";
+type EnforceCustomMatcher<F extends CB, R> = (...args: DropFirst<Parameters<F>>) => R;
+declare global {
+    namespace n4s {
+        interface EnforceCustomMatchers<R> {
+            isURL: EnforceCustomMatcher<typeof isURL, R>;
+        }
+    }
+}
+//# sourceMappingURL=isURL.d.ts.map

package/types/isURL.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isURL.d.ts","sourceRoot":"","sources":["../src/exports/isURL.ts","../src/lib/enforceUtilityTypes.ts"],"names":[],"mappings":";AACA,OAAO,KAAK,MAAM,wBAAwB,CAAC;;;AAO3C,QAAQ,MAAM,CAAC;IACb,UAAU,GAAG,CAAC;QACZ,UAAU,qBAAqB,CAAC,CAAC;YAC/B,KAAK,EAAE,oBAAoB,CAAC,OAAO,KAAK,EAAE,CAAC,CAAC,CAAC;SAC9C;KACF;CACF"}

package/types/n4s.d.ts

@@ -1,21 +1,16 @@
+import { Nullable, DropFirst, Stringable, BlankValue, CB, DynamicValue } from "vest-utils";
 declare const ctx: import("context").CtxCascadeApi<CTXType>;
 type CTXType = {
     meta: Record<string, any>;
     value: any;
     set?: boolean;
-    parent: () => CTXType | null;
+    parent: () => Nullable<CTXType>;
 };
-type EnforceContext = null | {
+type EnforceContext = Nullable<{
     meta: Record<string, any>;
     value: any;
     parent: () => EnforceContext;
-};
-type DropFirst<T extends unknown[]> = T extends [
-    unknown,
-    ...infer U
-] ? U : never;
-type Stringable = string | ((...args: any[]) => string);
-type CB = (...args: any[]) => any;
+}>;
 type RuleReturn = boolean | {
     pass: boolean;
     message?: Stringable;
@@ -36,7 +31,7 @@ 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 isBlank(value: unknown): value is BlankValue;
 declare function isKeyOf(key: string | symbol | number, obj: any): boolean;
 declare function isNaN(value: unknown): boolean;
 declare function isNegative(value: number | string): boolean;
@@ -56,16 +51,16 @@ declare const baseRules: {
     doesNotStartWith: (value: string, arg1: string) => boolean;
     endsWith: typeof endsWith;
     equals: typeof equals;
-    greaterThan: typeof import("packages/vest-utils/types/vest-utils").greaterThan;
+    greaterThan: typeof import("vest-utils").greaterThan;
     greaterThanOrEquals: typeof greaterThanOrEquals;
-    gt: typeof import("packages/vest-utils/types/vest-utils").greaterThan;
+    gt: typeof import("vest-utils").greaterThan;
     gte: typeof greaterThanOrEquals;
     inside: typeof inside;
-    isArray: typeof import("packages/vest-utils/types/vest-utils").isArray;
+    isArray: typeof import("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;
+    isBoolean: typeof import("vest-utils").isBoolean;
+    isEmpty: typeof import("vest-utils").isEmpty;
     isEven: (value: any) => boolean;
     isFalsy: (value: unknown) => boolean;
     isKeyOf: typeof isKeyOf;
@@ -85,21 +80,21 @@ declare const baseRules: {
     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;
+    isNull: typeof import("vest-utils").isNull;
+    isNullish: typeof import("vest-utils").isNullish;
     isNumber: typeof isNumber;
-    isNumeric: typeof import("packages/vest-utils/types/vest-utils").isNumeric;
+    isNumeric: typeof import("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;
+    isPositive: typeof import("vest-utils").isPositive;
+    isString: typeof import("vest-utils").isStringValue;
     isTruthy: typeof isTruthy;
-    isUndefined: typeof import("packages/vest-utils/types/vest-utils").isUndefined;
+    isUndefined: typeof import("vest-utils").isUndefined;
     isValueOf: typeof isValueOf;
-    lengthEquals: typeof import("packages/vest-utils/types/vest-utils").lengthEquals;
+    lengthEquals: typeof import("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;
+    longerThan: typeof import("vest-utils").longerThan;
     longerThanOrEquals: typeof longerThanOrEquals;
     lt: typeof lessThan;
     lte: typeof lessThanOrEquals;
@@ -107,13 +102,13 @@ declare const baseRules: {
     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;
+    numberEquals: typeof import("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> & {
+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 */
@@ -124,7 +119,11 @@ declare global {
     }
 }
 type IRules = n4s.IRules<Record<string, any>>;
-type EnforceEager = (value: RuleValue) => IRules;
+type TModifiers = {
+    message: (input: string) => EnforceEagerReturn;
+};
+type EnforceEagerReturn = IRules & TModifiers;
+type EnforceEager = (value: RuleValue) => EnforceEagerReturn;
 type LazyRules = n4s.IRules<LazyRuleMethods>;
 type Lazy = LazyRules & LazyRuleMethods & 
 // This is a "catch all" hack to make TS happy while not
@@ -137,7 +136,10 @@ type LazyRuleRunners = {
     test: (value: unknown) => boolean;
     run: (value: unknown) => RuleDetailedResult;
 };
-type LazyMessage = string | ((value: unknown, originalMessage?: Stringable) => string);
+type LazyMessage = DynamicValue<string, [
+    value: unknown,
+    originalMessage?: Stringable
+]>;
 declare const enforce: Enforce;
 type Enforce = EnforceMethods & LazyRules & EnforceEager;
 type EnforceMethods = {
@@ -151,3 +153,4 @@ declare global {
     }
 }
 export { enforce, ctx };
+//# sourceMappingURL=n4s.d.ts.map

package/types/n4s.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"n4s.d.ts","sourceRoot":"","sources":["../src/n4s.ts","../src/runtime/enforceContext.ts","../src/lib/ruleReturn.ts","../src/rules/endsWith.ts","../src/rules/equals.ts","../src/rules/greaterThanOrEquals.ts","../src/rules/inside.ts","../src/rules/lessThan.ts","../src/rules/lessThanOrEquals.ts","../src/rules/isBetween.ts","../src/rules/isBlank.ts","../src/rules/isBoolean.ts","../src/rules/isEven.ts","../src/rules/isKeyOf.ts","../src/rules/isNaN.ts","../src/rules/isNegative.ts","../src/rules/isNumber.ts","../src/rules/isOdd.ts","../src/rules/isString.ts","../src/rules/isTruthy.ts","../src/rules/isValueOf.ts","../src/rules/longerThanOrEquals.ts","../src/rules/matches.ts","../src/rules/ruleCondition.ts","../src/rules/shorterThan.ts","../src/rules/shorterThanOrEquals.ts","../src/rules/startsWith.ts","../src/runtime/rules.ts","../src/runtime/runtimeRules.ts","../src/lib/transformResult.ts","../src/runtime/enforceEager.ts","../src/runtime/genEnforceLazy.ts","../src/runtime/enforce.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIA,QAAQ,MAAM,CAAC;IACb,UAAU,GAAG,CAAC;QACZ,UAAU,qBAAqB,CAAC,CAAC;SAAI;KACtC;CACF;AARD,OAAO,gBAAW,CAAgB"}

package/types/schema.d.ts

@@ -1,9 +1,4 @@
-type DropFirst<T extends unknown[]> = T extends [
-    unknown,
-    ...infer U
-] ? U : never;
-type Stringable = string | ((...args: any[]) => string);
-type CB = (...args: any[]) => any;
+import { CB, DropFirst, Stringable, DynamicValue, BlankValue } from "vest-utils";
 type EnforceCustomMatcher<F extends CB, R> = (...args: DropFirst<Parameters<F>>) => R;
 type RuleReturn = boolean | {
     pass: boolean;
@@ -22,7 +17,7 @@ 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 isBlank(value: unknown): value is BlankValue;
 declare function isKeyOf(key: string | symbol | number, obj: any): boolean;
 declare function isNaN(value: unknown): boolean;
 declare function isNegative(value: number | string): boolean;
@@ -42,16 +37,16 @@ declare const baseRules: {
     doesNotStartWith: (value: string, arg1: string) => boolean;
     endsWith: typeof endsWith;
     equals: typeof equals;
-    greaterThan: typeof import("packages/vest-utils/types/vest-utils").greaterThan;
+    greaterThan: typeof import("vest-utils").greaterThan;
     greaterThanOrEquals: typeof greaterThanOrEquals;
-    gt: typeof import("packages/vest-utils/types/vest-utils").greaterThan;
+    gt: typeof import("vest-utils").greaterThan;
     gte: typeof greaterThanOrEquals;
     inside: typeof inside;
-    isArray: typeof import("packages/vest-utils/types/vest-utils").isArray;
+    isArray: typeof import("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;
+    isBoolean: typeof import("vest-utils").isBoolean;
+    isEmpty: typeof import("vest-utils").isEmpty;
     isEven: (value: any) => boolean;
     isFalsy: (value: unknown) => boolean;
     isKeyOf: typeof isKeyOf;
@@ -71,21 +66,21 @@ declare const baseRules: {
     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;
+    isNull: typeof import("vest-utils").isNull;
+    isNullish: typeof import("vest-utils").isNullish;
     isNumber: typeof isNumber;
-    isNumeric: typeof import("packages/vest-utils/types/vest-utils").isNumeric;
+    isNumeric: typeof import("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;
+    isPositive: typeof import("vest-utils").isPositive;
+    isString: typeof import("vest-utils").isStringValue;
     isTruthy: typeof isTruthy;
-    isUndefined: typeof import("packages/vest-utils/types/vest-utils").isUndefined;
+    isUndefined: typeof import("vest-utils").isUndefined;
     isValueOf: typeof isValueOf;
-    lengthEquals: typeof import("packages/vest-utils/types/vest-utils").lengthEquals;
+    lengthEquals: typeof import("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;
+    longerThan: typeof import("vest-utils").longerThan;
     longerThanOrEquals: typeof longerThanOrEquals;
     lt: typeof lessThan;
     lte: typeof lessThanOrEquals;
@@ -93,13 +88,13 @@ declare const baseRules: {
     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;
+    numberEquals: typeof import("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> & {
+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 */
@@ -121,7 +116,10 @@ type LazyRuleRunners = {
     test: (value: unknown) => boolean;
     run: (value: unknown) => RuleDetailedResult;
 };
-type LazyMessage = string | ((value: unknown, originalMessage?: Stringable) => string);
+type LazyMessage = DynamicValue<string, [
+    value: unknown,
+    originalMessage?: Stringable
+]>;
 declare function isArrayOf(inputArray: any[], currentRule: LazyRuleRunners): RuleDetailedResult;
 interface ShapeObject extends Record<string, any>, Record<string, LazyRuleRunners> {
 }
@@ -142,3 +140,4 @@ declare global {
     }
 }
 export { partial };
+//# sourceMappingURL=schema.d.ts.map

package/types/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/exports/schema.ts","../src/lib/enforceUtilityTypes.ts","../src/runtime/enforceContext.ts","../src/lib/ruleReturn.ts","../src/rules/endsWith.ts","../src/rules/equals.ts","../src/rules/greaterThanOrEquals.ts","../src/rules/inside.ts","../src/rules/lessThan.ts","../src/rules/lessThanOrEquals.ts","../src/rules/isBetween.ts","../src/rules/isBlank.ts","../src/rules/isBoolean.ts","../src/rules/isEven.ts","../src/rules/isKeyOf.ts","../src/rules/isNaN.ts","../src/rules/isNegative.ts","../src/rules/isNumber.ts","../src/rules/isOdd.ts","../src/rules/isString.ts","../src/rules/isTruthy.ts","../src/rules/isValueOf.ts","../src/rules/longerThanOrEquals.ts","../src/rules/matches.ts","../src/rules/ruleCondition.ts","../src/rules/shorterThan.ts","../src/rules/shorterThanOrEquals.ts","../src/rules/startsWith.ts","../src/runtime/rules.ts","../src/runtime/runtimeRules.ts","../src/lib/transformResult.ts","../src/runtime/genEnforceLazy.ts","../src/lib/runLazyRule.ts","../src/plugins/schema/isArrayOf.ts","../src/plugins/schema/schemaTypes.ts","../src/plugins/schema/loose.ts","../src/plugins/schema/optional.ts","../src/plugins/schema/shape.ts","../src/plugins/schema/partial.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAcA,QAAQ,MAAM,CAAC;IACb,UAAU,GAAG,CAAC;QACZ,UAAU,qBAAqB,CAAC,CAAC;YAC/B,SAAS,EAAE,oBAAoB,CAAC,OAAO,SAAS,EAAE,CAAC,CAAC,CAAC;YACrD,KAAK,EAAE,oBAAoB,CAAC,OAAO,KAAK,EAAE,CAAC,CAAC,CAAC;YAC7C,KAAK,EAAE,oBAAoB,CAAC,OAAO,KAAK,EAAE,CAAC,CAAC,CAAC;YAC7C,QAAQ,EAAE,oBAAoB,CAAC,OAAO,QAAQ,EAAE,CAAC,CAAC,CAAC;SACpD;KACF;CACF;AAdD,OAAO,WAAW,CAAgB"}

package/tsconfig.json

@@ -1,8 +0,0 @@
-{
-  "extends": "../../tsconfig.json",
-  "compilerOptions": {
-    "declarationMap": true,
-    "declarationDir": "./types",
-    "outDir": "./dist"
-  }
-}