n4s 4.1.1 → 4.1.4

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "4.1.1",
+  "version": "4.1.4",
   "license": "MIT",
   "main": "./dist/cjs/n4s.js",
   "types": "./types/n4s.d.ts",
@@ -10,7 +10,7 @@
     "release": "vx release"
   },
   "dependencies": {
-    "context": "^2.0.1"
+    "context": "^2.0.3"
   },
   "module": "./dist/es/n4s.production.js",
   "exports": {
@@ -134,5 +134,7 @@
   },
   "bugs": {
     "url": "https://github.com/ealush/vest.git/issues"
-  }
+  },
+  "unpkg": "./dist/umd/n4s.production.js",
+  "jsdelivr": "./dist/umd/n4s.production.js"
 }

package/schema/package.json

@@ -1,6 +1,8 @@
 {
   "main": "../dist/cjs/schema.js",
   "module": "../dist/es/schema.production.js",
+  "unpkg": "../dist/umd/schema.production.js",
+  "jsdelivr": "../dist/umd/schema.production.js",
   "name": "schema",
   "types": "../types/schema.d.ts",
   "private": true

package/types/compose.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;
@@ -35,6 +35,7 @@ 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 isPositive(value: number | string): boolean;
 declare function isStringValue(v: unknown): v is string;
 declare function isTruthy(value: unknown): boolean;
 declare function isUndefined(value?: unknown): boolean;
@@ -89,7 +90,7 @@ declare const baseRules: {
     isNumber: typeof isNumber;
     isNumeric: typeof isNumeric;
     isOdd: (value: any) => boolean;
-    isPositive: (value: string | number) => boolean;
+    isPositive: typeof isPositive;
     isString: typeof isStringValue;
     isTruthy: typeof isTruthy;
     isUndefined: typeof isUndefined;
@@ -112,29 +113,29 @@ 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 TComposeResult = TLazyRuleRunners & ((value: any) => void);
-type TLazyMessage = string | ((value: unknown, originalMessage?: TStringable) => string);
-declare function compose(...composites: TLazyRuleRunners[]): TComposeResult;
+type ComposeResult = LazyRuleRunners & ((value: any) => void);
+type LazyMessage = string | ((value: unknown, originalMessage?: Stringable) => string);
+declare function compose(...composites: LazyRuleRunners[]): ComposeResult;
 export { compose as default };

package/types/compounds.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;
@@ -35,6 +35,7 @@ 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 isPositive(value: number | string): boolean;
 declare function isStringValue(v: unknown): v is string;
 declare function isTruthy(value: unknown): boolean;
 declare function isUndefined(value?: unknown): boolean;
@@ -89,7 +90,7 @@ declare const baseRules: {
     isNumber: typeof isNumber;
     isNumeric: typeof isNumeric;
     isOdd: (value: any) => boolean;
-    isPositive: (value: string | number) => boolean;
+    isPositive: typeof isPositive;
     isString: typeof isStringValue;
     isTruthy: typeof isTruthy;
     isUndefined: typeof isUndefined;
@@ -112,33 +113,33 @@ 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 allOf(value: unknown, ...rules: TLazy[]): TRuleDetailedResult;
-declare function anyOf(value: unknown, ...rules: TLazy[]): TRuleDetailedResult;
-declare function noneOf(value: unknown, ...rules: TLazy[]): TRuleDetailedResult;
-declare function oneOf(value: unknown, ...rules: TLazy[]): TRuleDetailedResult;
+type LazyMessage = string | ((value: unknown, originalMessage?: Stringable) => string);
+declare function allOf(value: unknown, ...rules: Lazy[]): RuleDetailedResult;
+declare function anyOf(value: unknown, ...rules: Lazy[]): RuleDetailedResult;
+declare function noneOf(value: unknown, ...rules: Lazy[]): RuleDetailedResult;
+declare function oneOf(value: unknown, ...rules: Lazy[]): RuleDetailedResult;
 declare global {
     namespace n4s {
         interface EnforceCustomMatchers<R> {

package/types/n4s.d.ts

@@ -10,31 +10,31 @@ type CTXType = {
     set?: boolean;
     parent: () => CTXType | null;
 };
-type TEnforceContext = null | {
+type EnforceContext = null | {
     meta: Record<string, any>;
     value: any;
-    parent: () => TEnforceContext;
+    parent: () => EnforceContext;
 };
 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 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;
@@ -55,6 +55,7 @@ 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 isPositive(value: number | string): boolean;
 declare function isStringValue(v: unknown): v is string;
 declare function isTruthy(value: unknown): boolean;
 declare function isUndefined(value?: unknown): boolean;
@@ -109,7 +110,7 @@ declare const baseRules: {
     isNumber: typeof isNumber;
     isNumeric: typeof isNumeric;
     isOdd: (value: any) => boolean;
-    isPositive: (value: string | number) => boolean;
+    isPositive: typeof isPositive;
     isString: typeof isStringValue;
     isTruthy: typeof isTruthy;
     isUndefined: typeof isUndefined;
@@ -132,37 +133,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 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 & 
+declare function enforceEager(value: RuleValue): IRules;
+type EnforceEager = typeof enforceEager;
+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 const enforce: TEnforce;
-type TEnforce = TEnforceMethods & TLazyRules & TEnforceEager;
-type TEnforceMethods = {
-    context: () => TEnforceContext;
-    extend: (customRules: TRule) => void;
+type LazyMessage = string | ((value: unknown, originalMessage?: Stringable) => string);
+declare const enforce: Enforce;
+type Enforce = EnforceMethods & LazyRules & EnforceEager;
+type EnforceMethods = {
+    context: () => EnforceContext;
+    extend: (customRules: Rule) => void;
 };
 declare global {
     namespace n4s {

package/types/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;
@@ -35,6 +35,7 @@ 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 isPositive(value: number | string): boolean;
 declare function isStringValue(v: unknown): v is string;
 declare function isTruthy(value: unknown): boolean;
 declare function isUndefined(value?: unknown): boolean;
@@ -89,7 +90,7 @@ declare const baseRules: {
     isNumber: typeof isNumber;
     isNumeric: typeof isNumeric;
     isOdd: (value: any) => boolean;
-    isPositive: (value: string | number) => boolean;
+    isPositive: typeof isPositive;
     isString: typeof isStringValue;
     isTruthy: typeof isTruthy;
     isUndefined: typeof isUndefined;
@@ -112,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 {