n4s 5.0.1 → 5.0.2

package/types/n4s.d.ts

@@ -1,69 +1,47 @@
-declare const ctx: {
-    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;
-};
+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 TEnforceContext = null | {
+type EnforceContext = Nullable<{
     meta: Record<string, any>;
     value: any;
-    parent: () => TEnforceContext;
-};
-type DropFirst<T extends unknown[]> = T extends [
-    unknown,
-    ...infer U
-] ? U : never;
-type TStringable = string | ((...args: any[]) => string);
-type TRuleReturn = boolean | {
+    parent: () => EnforceContext;
+}>;
+type RuleReturn = boolean | {
     pass: boolean;
-    message?: TStringable;
+    message?: Stringable;
 };
-type TRuleDetailedResult = {
+type RuleDetailedResult = {
     pass: boolean;
     message?: string;
 };
-type TArgs = any[];
-type TRuleValue = any;
-type TRuleBase = (value: TRuleValue, ...args: TArgs) => TRuleReturn;
-type TRule = Record<string, TRuleBase>;
-type TBaseRules = typeof baseRules;
-type KBaseRules = keyof TBaseRules;
-declare function condition(value: any, callback: (value: any) => TRuleReturn): TRuleReturn;
+type Args = any[];
+type RuleValue = any;
+type RuleBase = (value: RuleValue, ...args: Args) => RuleReturn;
+type Rule = Record<string, RuleBase>;
+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;
 declare function greaterThanOrEquals(value: string | number, gte: string | number): boolean;
 declare function inside(value: unknown, arg1: string | unknown[]): boolean;
-// The module is named "isArrayValue" since it
-// is conflicting with a nested npm dependency.
-// We may need to revisit this in the future.
-declare function isArray(value: unknown): value is Array<unknown>;
 declare function isBetween(value: number | string, min: number | string, max: number | string): boolean;
-declare function isBlank(value: unknown): boolean;
-declare function isBoolean(value: unknown): value is boolean;
-declare function isEmpty(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;
-declare function isNull(value: unknown): value is null;
-declare function isNullish(value: any): value is null | undefined;
 declare function isNumber(value: unknown): value is number;
-declare function isNumeric(value: string | number): boolean;
-declare function isStringValue(v: unknown): v is string;
 declare function isTruthy(value: unknown): boolean;
-declare function isUndefined(value?: unknown): boolean;
-declare function lengthEquals(value: string | unknown[], arg1: string | number): 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 longerThan(value: string | unknown[], arg1: string | number): boolean;
 declare function longerThanOrEquals(value: string | unknown[], arg1: string | number): boolean;
 declare function matches(value: string, regex: RegExp | string): boolean;
-declare function numberEquals(value: string | number, eq: string | number): 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;
@@ -73,18 +51,19 @@ declare const baseRules: {
     doesNotStartWith: (value: string, arg1: string) => boolean;
     endsWith: typeof endsWith;
     equals: typeof equals;
-    greaterThan: typeof greaterThan;
+    greaterThan: typeof import("vest-utils").greaterThan;
     greaterThanOrEquals: typeof greaterThanOrEquals;
-    gt: typeof greaterThan;
+    gt: typeof import("vest-utils").greaterThan;
     gte: typeof greaterThanOrEquals;
     inside: typeof inside;
-    isArray: typeof isArray;
+    isArray: typeof import("vest-utils").isArray;
     isBetween: typeof isBetween;
     isBlank: typeof isBlank;
-    isBoolean: typeof isBoolean;
-    isEmpty: typeof isEmpty;
+    isBoolean: typeof import("vest-utils").isBoolean;
+    isEmpty: typeof import("vest-utils").isEmpty;
     isEven: (value: any) => boolean;
     isFalsy: (value: unknown) => boolean;
+    isKeyOf: typeof isKeyOf;
     isNaN: typeof isNaN;
     isNegative: typeof isNegative;
     isNotArray: (value: unknown) => boolean;
@@ -92,6 +71,7 @@ declare const baseRules: {
     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;
@@ -99,20 +79,22 @@ declare const baseRules: {
     isNotNumeric: (value: string | number) => boolean;
     isNotString: (v: unknown) => boolean;
     isNotUndefined: (value?: unknown) => boolean;
-    isNull: typeof isNull;
-    isNullish: typeof isNullish;
+    isNotValueOf: (value: any, objectToCheck: any) => boolean;
+    isNull: typeof import("vest-utils").isNull;
+    isNullish: typeof import("vest-utils").isNullish;
     isNumber: typeof isNumber;
-    isNumeric: typeof isNumeric;
+    isNumeric: typeof import("vest-utils").isNumeric;
     isOdd: (value: any) => boolean;
-    isPositive: (value: string | number) => boolean;
-    isString: typeof isStringValue;
+    isPositive: typeof import("vest-utils").isPositive;
+    isString: typeof import("vest-utils").isStringValue;
     isTruthy: typeof isTruthy;
-    isUndefined: typeof isUndefined;
-    lengthEquals: typeof lengthEquals;
+    isUndefined: typeof import("vest-utils").isUndefined;
+    isValueOf: typeof isValueOf;
+    lengthEquals: typeof import("vest-utils").lengthEquals;
     lengthNotEquals: (value: string | unknown[], arg1: string | number) => boolean;
     lessThan: typeof lessThan;
     lessThanOrEquals: typeof lessThanOrEquals;
-    longerThan: typeof longerThan;
+    longerThan: typeof import("vest-utils").longerThan;
     longerThanOrEquals: typeof longerThanOrEquals;
     lt: typeof lessThan;
     lte: typeof lessThanOrEquals;
@@ -120,43 +102,49 @@ 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 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 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 IRules = n4s.IRules<Record<string, any>>;
-declare function enforceEager(value: TRuleValue): IRules;
-type TEnforceEager = typeof enforceEager;
-type TLazyRules = n4s.IRules<TLazyRuleMethods>;
-type TLazy = TLazyRules & TLazyRuleMethods & 
+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
 // losing type hints
-Record<string, (...args: any[]) => any>;
-type TLazyRuleMethods = TLazyRuleRunners & {
-    message: (message: TLazyMessage) => TLazy;
+Record<string, CB>;
+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 const enforce: TEnforce;
-type TEnforce = TEnforceMethods & TLazyRules & TEnforceEager;
-type TEnforceMethods = {
-    context: () => TEnforceContext;
-    extend: (customRules: TRule) => void;
+type LazyMessage = DynamicValue<string, [
+    value: unknown,
+    originalMessage?: Stringable
+]>;
+declare const enforce: Enforce;
+type Enforce = EnforceMethods & LazyRules & EnforceEager;
+type EnforceMethods = {
+    context: () => EnforceContext;
+    extend: (customRules: Rule) => void;
 };
 declare global {
     namespace n4s {
@@ -165,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,49 +1,33 @@
-type DropFirst<T extends unknown[]> = T extends [
-    unknown,
-    ...infer U
-] ? U : never;
-type TStringable = string | ((...args: any[]) => string);
-type TRuleReturn = boolean | {
+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;
-    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;
 declare function greaterThanOrEquals(value: string | number, gte: string | number): boolean;
 declare function inside(value: unknown, arg1: string | unknown[]): boolean;
-// The module is named "isArrayValue" since it
-// is conflicting with a nested npm dependency.
-// We may need to revisit this in the future.
-declare function isArray(value: unknown): value is Array<unknown>;
 declare function isBetween(value: number | string, min: number | string, max: number | string): boolean;
-declare function isBlank(value: unknown): boolean;
-declare function isBoolean(value: unknown): value is boolean;
-declare function isEmpty(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;
-declare function isNull(value: unknown): value is null;
-declare function isNullish(value: any): value is null | undefined;
 declare function isNumber(value: unknown): value is number;
-declare function isNumeric(value: string | number): boolean;
-declare function isStringValue(v: unknown): v is string;
 declare function isTruthy(value: unknown): boolean;
-declare function isUndefined(value?: unknown): boolean;
-declare function lengthEquals(value: string | unknown[], arg1: string | number): 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 longerThan(value: string | unknown[], arg1: string | number): boolean;
 declare function longerThanOrEquals(value: string | unknown[], arg1: string | number): boolean;
 declare function matches(value: string, regex: RegExp | string): boolean;
-declare function numberEquals(value: string | number, eq: string | number): 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;
@@ -53,18 +37,19 @@ declare const baseRules: {
     doesNotStartWith: (value: string, arg1: string) => boolean;
     endsWith: typeof endsWith;
     equals: typeof equals;
-    greaterThan: typeof greaterThan;
+    greaterThan: typeof import("vest-utils").greaterThan;
     greaterThanOrEquals: typeof greaterThanOrEquals;
-    gt: typeof greaterThan;
+    gt: typeof import("vest-utils").greaterThan;
     gte: typeof greaterThanOrEquals;
     inside: typeof inside;
-    isArray: typeof isArray;
+    isArray: typeof import("vest-utils").isArray;
     isBetween: typeof isBetween;
     isBlank: typeof isBlank;
-    isBoolean: typeof isBoolean;
-    isEmpty: typeof isEmpty;
+    isBoolean: typeof import("vest-utils").isBoolean;
+    isEmpty: typeof import("vest-utils").isEmpty;
     isEven: (value: any) => boolean;
     isFalsy: (value: unknown) => boolean;
+    isKeyOf: typeof isKeyOf;
     isNaN: typeof isNaN;
     isNegative: typeof isNegative;
     isNotArray: (value: unknown) => boolean;
@@ -72,6 +57,7 @@ declare const baseRules: {
     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;
@@ -79,20 +65,22 @@ declare const baseRules: {
     isNotNumeric: (value: string | number) => boolean;
     isNotString: (v: unknown) => boolean;
     isNotUndefined: (value?: unknown) => boolean;
-    isNull: typeof isNull;
-    isNullish: typeof isNullish;
+    isNotValueOf: (value: any, objectToCheck: any) => boolean;
+    isNull: typeof import("vest-utils").isNull;
+    isNullish: typeof import("vest-utils").isNullish;
     isNumber: typeof isNumber;
-    isNumeric: typeof isNumeric;
+    isNumeric: typeof import("vest-utils").isNumeric;
     isOdd: (value: any) => boolean;
-    isPositive: (value: string | number) => boolean;
-    isString: typeof isStringValue;
+    isPositive: typeof import("vest-utils").isPositive;
+    isString: typeof import("vest-utils").isStringValue;
     isTruthy: typeof isTruthy;
-    isUndefined: typeof isUndefined;
-    lengthEquals: typeof lengthEquals;
+    isUndefined: typeof import("vest-utils").isUndefined;
+    isValueOf: typeof isValueOf;
+    lengthEquals: typeof import("vest-utils").lengthEquals;
     lengthNotEquals: (value: string | unknown[], arg1: string | number) => boolean;
     lessThan: typeof lessThan;
     lessThanOrEquals: typeof lessThanOrEquals;
-    longerThan: typeof longerThan;
+    longerThan: typeof import("vest-utils").longerThan;
     longerThanOrEquals: typeof longerThanOrEquals;
     lt: typeof lessThan;
     lte: typeof lessThanOrEquals;
@@ -100,52 +88,56 @@ 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 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 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;
+Record<string, CB>;
+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: TLazy): TRuleDetailedResult;
-interface IShapeObject extends Record<string, any>, Record<string, TLazyRuleRunners> {
+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> {
 }
-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 {
         interface EnforceCustomMatchers<R> {
-            isArrayOf: (...args: DropFirst<Parameters<typeof isArrayOf>>) => R;
-            loose: (...args: DropFirst<Parameters<typeof loose>>) => R;
-            shape: (...args: DropFirst<Parameters<typeof shape>>) => R;
-            optional: (...args: DropFirst<Parameters<typeof optional>>) => R;
+            isArrayOf: EnforceCustomMatcher<typeof isArrayOf, R>;
+            loose: EnforceCustomMatcher<typeof loose, R>;
+            shape: EnforceCustomMatcher<typeof shape, R>;
+            optional: EnforceCustomMatcher<typeof optional, R>;
         }
     }
 }
 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/docs/README.md

@@ -1,44 +0,0 @@
-# Enforce - n4s
-
-Enforce is a validations assertions library. It provides rules that you can test your data against.
-
-By default, enforce throws an error when your validations fail. These errors should be caught by a validation testing framework such as [Vest](https://github.com/ealush/vest).
-
-You can extend Enforce per need, and you can add your custom validation rules in your app.
-
-```js
-import { enforce } from 'n4s';
-
-enforce(4).isNumber();
-// passes
-
-enforce(4).isNumber().greaterThan(2);
-// passes
-
-enforce(4)
-  .lessThan(2) // throws an error, will not carry on to the next rule
-  .greaterThan(3);
-```
-
-## Installation
-
-```
-npm i n4s
-```
-
-## Non throwing validations
-
-> This functionality replaces the no-longer supported ensure export, as it performs the same functionality with better performance.
-
-If you wish to use enforce's functionality safely with a boolean return interface instead, you can use its lazy validation interface:
-
-```js
-enforce.isArray().longerThan(3).test([1, 2, 3]);
-```
-
-## Content
-
-- [List of Enforce rules](./rules)
-- [Business reated rules](./business_rules)
-- [Schema validation](./shape)
-- [Custom Enforce Rules](./custom)

package/docs/_sidebar.md

@@ -1,5 +0,0 @@
-- [Main](./)
-- [List of Enforce Rules](./rules)
-- [Schema validations](./compound)
-- [Custom Enforce Rules](./custom)
-- [Consuming external rules](./external)

package/docs/external.md

@@ -1,27 +0,0 @@
-# Consuming external rules
-
-Enforce comes with the bare minimum of rules needed for input validation, not assuming your business logic constraints.
-
-In some cases you might require more validations such as `isEmail` or `isPhoneNumber`. Enforce intentionally does not include those, since those validations may not necessarily reflect the way those validations should work in your app.
-
-Luckily, there are numerous packages that can be used along with enforce to add those validations. One of the most popular, and most compatible is `validator.js`.
-
-```
-npm i validator
-```
-
-Validator.js is a pretty big package. To prevent it from unnecessarily increasing your bundle size for rules you don't use, import the ones you use individually.
-
-Then add those rules with `enforce.extend`:
-
-```js
-import isEmail from 'validator/es/lib/isEmail';
-import isMobilePhone from 'validator/es/lib/isMobilePhone';
-
-enforce.extend({ isEmail, isMobilePhone });
-
-enforce('example@example.com').isEmail(); // ✅
-enforce('example[at]example[dot]com').isEmail(); // 🚨
-```
-
-A full list of the supported validator.js rules can be found on [npmjs.com/package/validator](https://www.npmjs.com/package/validator).

package/docs/index.html

@@ -1,32 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-  <head>
-    <meta charset="UTF-8" />
-    <title>n4s - Enforce - Validation assertions library</title>
-    <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1" />
-    <meta
-      name="description"
-      content="Enforce - Validation assertions library"
-    />
-    <meta
-      name="viewport"
-      content="width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0"
-    />
-    <link rel="stylesheet" href="//unpkg.com/docsify/lib/themes/vue.css" />
-  </head>
-  <body>
-    <div id="app"></div>
-    <script>
-      window.$docsify = {
-        name: 'n4s - enforce',
-        repo: 'https://github.com/ealush/n4s',
-        search: 'auto',
-        loadSidebar: true,
-        subMaxLevel: 2,
-        themeColor: '#539BDB',
-      };
-    </script>
-    <script src="//unpkg.com/docsify/lib/docsify.min.js"></script>
-    <script src="//unpkg.com/docsify/lib/plugins/search.min.js"></script>
-  </body>
-</html>