n4s 3.0.0 → 4.0.0-dev-1aae50

package/types/compounds.d.ts

@@ -0,0 +1,146 @@
+type DropFirst<T extends unknown[]> = T extends [
+    unknown,
+    ...infer U
+] ? U : never;
+type TStringable = string | ((...args: any[]) => string);
+type TRuleReturn = boolean | {
+    pass: boolean;
+    message?: TStringable;
+};
+type TRuleDetailedResult = {
+    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;
+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 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 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;
+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 greaterThan;
+    greaterThanOrEquals: typeof greaterThanOrEquals;
+    gt: typeof greaterThan;
+    gte: typeof greaterThanOrEquals;
+    inside: typeof inside;
+    isArray: typeof isArray;
+    isBetween: typeof isBetween;
+    isBlank: typeof isBlank;
+    isBoolean: typeof isBoolean;
+    isEmpty: typeof isEmpty;
+    isEven: (value: any) => boolean;
+    isFalsy: (value: unknown) => boolean;
+    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;
+    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;
+    isNull: typeof isNull;
+    isNullish: typeof isNullish;
+    isNumber: typeof isNumber;
+    isNumeric: typeof isNumeric;
+    isOdd: (value: any) => boolean;
+    isPositive: (value: string | number) => boolean;
+    isString: typeof isStringValue;
+    isTruthy: typeof isTruthy;
+    isUndefined: typeof isUndefined;
+    lengthEquals: typeof lengthEquals;
+    lengthNotEquals: (value: string | unknown[], arg1: string | number) => boolean;
+    lessThan: typeof lessThan;
+    lessThanOrEquals: typeof lessThanOrEquals;
+    longerThan: typeof 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 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;
+};
+/* eslint-disable @typescript-eslint/no-namespace, @typescript-eslint/no-empty-interface */
+declare global {
+    namespace n4s {
+        interface IRules<E> extends TRules<E> {
+        }
+    }
+}
+type TLazyRules = n4s.IRules<TLazyRuleMethods>;
+type TLazy = TLazyRules & TLazyRuleMethods & 
+// 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 TLazyRuleRunners = {
+    test: (value: unknown) => boolean;
+    run: (value: unknown) => TRuleDetailedResult;
+};
+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;
+declare global {
+    namespace n4s {
+        interface EnforceCustomMatchers<R> {
+            allOf: (...args: DropFirst<Parameters<typeof allOf>>) => R;
+            anyOf: (...args: DropFirst<Parameters<typeof anyOf>>) => R;
+            noneOf: (...args: DropFirst<Parameters<typeof noneOf>>) => R;
+            oneOf: (...args: DropFirst<Parameters<typeof oneOf>>) => R;
+        }
+    }
+}
+export {};

package/types/n4s.d.ts

@@ -0,0 +1,167 @@
+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;
+};
+type CTXType = {
+    meta: Record<string, any>;
+    value: any;
+    set?: boolean;
+    parent: () => CTXType | null;
+};
+type TEnforceContext = null | {
+    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 | {
+    pass: boolean;
+    message?: TStringable;
+};
+type TRuleDetailedResult = {
+    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;
+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 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 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;
+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 greaterThan;
+    greaterThanOrEquals: typeof greaterThanOrEquals;
+    gt: typeof greaterThan;
+    gte: typeof greaterThanOrEquals;
+    inside: typeof inside;
+    isArray: typeof isArray;
+    isBetween: typeof isBetween;
+    isBlank: typeof isBlank;
+    isBoolean: typeof isBoolean;
+    isEmpty: typeof isEmpty;
+    isEven: (value: any) => boolean;
+    isFalsy: (value: unknown) => boolean;
+    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;
+    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;
+    isNull: typeof isNull;
+    isNullish: typeof isNullish;
+    isNumber: typeof isNumber;
+    isNumeric: typeof isNumeric;
+    isOdd: (value: any) => boolean;
+    isPositive: (value: string | number) => boolean;
+    isString: typeof isStringValue;
+    isTruthy: typeof isTruthy;
+    isUndefined: typeof isUndefined;
+    lengthEquals: typeof lengthEquals;
+    lengthNotEquals: (value: string | unknown[], arg1: string | number) => boolean;
+    lessThan: typeof lessThan;
+    lessThanOrEquals: typeof lessThanOrEquals;
+    longerThan: typeof 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 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;
+};
+/* eslint-disable @typescript-eslint/no-namespace, @typescript-eslint/no-empty-interface */
+declare global {
+    namespace n4s {
+        interface IRules<E> extends TRules<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 & 
+// 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 TLazyRuleRunners = {
+    test: (value: unknown) => boolean;
+    run: (value: unknown) => TRuleDetailedResult;
+};
+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;
+};
+declare global {
+    namespace n4s {
+        interface EnforceCustomMatchers<R> {
+        }
+    }
+}
+export { enforce, ctx };

package/types/schema.d.ts

@@ -0,0 +1,151 @@
+type DropFirst<T extends unknown[]> = T extends [
+    unknown,
+    ...infer U
+] ? U : never;
+type TStringable = string | ((...args: any[]) => string);
+type TRuleReturn = boolean | {
+    pass: boolean;
+    message?: TStringable;
+};
+type TRuleDetailedResult = {
+    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;
+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 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 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;
+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 greaterThan;
+    greaterThanOrEquals: typeof greaterThanOrEquals;
+    gt: typeof greaterThan;
+    gte: typeof greaterThanOrEquals;
+    inside: typeof inside;
+    isArray: typeof isArray;
+    isBetween: typeof isBetween;
+    isBlank: typeof isBlank;
+    isBoolean: typeof isBoolean;
+    isEmpty: typeof isEmpty;
+    isEven: (value: any) => boolean;
+    isFalsy: (value: unknown) => boolean;
+    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;
+    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;
+    isNull: typeof isNull;
+    isNullish: typeof isNullish;
+    isNumber: typeof isNumber;
+    isNumeric: typeof isNumeric;
+    isOdd: (value: any) => boolean;
+    isPositive: (value: string | number) => boolean;
+    isString: typeof isStringValue;
+    isTruthy: typeof isTruthy;
+    isUndefined: typeof isUndefined;
+    lengthEquals: typeof lengthEquals;
+    lengthNotEquals: (value: string | unknown[], arg1: string | number) => boolean;
+    lessThan: typeof lessThan;
+    lessThanOrEquals: typeof lessThanOrEquals;
+    longerThan: typeof 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 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;
+};
+/* eslint-disable @typescript-eslint/no-namespace, @typescript-eslint/no-empty-interface */
+declare global {
+    namespace n4s {
+        interface IRules<E> extends TRules<E> {
+        }
+    }
+}
+type TLazyRules = n4s.IRules<TLazyRuleMethods>;
+type TLazy = TLazyRules & TLazyRuleMethods & 
+// This is a "catch all" hack to make TS happy while not
+// losing type hints
+Record<string, (...args: any[]) => any>;
+interface IShapeObject extends Record<string, any>, Record<string, TLazyRuleRunners> {
+}
+type TLazyRuleMethods = TLazyRuleRunners & {
+    message: (message: TLazyMessage) => TLazy;
+};
+type TLazyRuleRunners = {
+    test: (value: unknown) => boolean;
+    run: (value: unknown) => TRuleDetailedResult;
+};
+type TLazyMessage = string | ((value: unknown, originalMessage?: TStringable) => string);
+declare function isArrayOf(inputArray: any[], currentRule: TLazy): TRuleDetailedResult;
+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;
+// Help needed improving the typings of this file.
+// Ideally, we'd be able to extend IShapeObject, 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;
+        }
+    }
+}
+export { partial };

package/config/jest/jest.setup.js

@@ -1,14 +0,0 @@
-expect.extend({
-  toPass: res => ({
-    pass: res.pass,
-    message: () => 'enforceResult.pass failed validation',
-  }),
-  toPassWith: (enforcement, value) => {
-    return {
-      pass:
-        enforcement.run(value).pass === true &&
-        enforcement.test(value) === true,
-      message: () => 'enforceResult.pass failed validation',
-    };
-  },
-});

package/config/rollup/enforce.js

@@ -1,8 +0,0 @@
-const genConfig = require('../../../../config/rollup/genConfig');
-const { packageDist, packageNames } = require('../../../../util');
-
-export default genConfig({
-  libraryName: packageNames.N4S,
-  distPath: packageDist(packageNames.N4S),
-  input: 'enforce.js',
-});

package/config/rollup/rollup.config.js

@@ -1,3 +0,0 @@
-import enforce from './enforce';
-
-export default [].concat(enforce);

package/docs/compound.md

@@ -1,187 +0,0 @@
-# Shape and schema validation
-
-Alongside the list of rules that only accept data provided by the user, enforce also supports compound rules - these are rules that accept other rules as their arguments. These rules let you validate more complex scenarios with the ergonomics of enforce.
-
-- [enforce.anyOf() - either/or validations](#anyof)
-- [enforce.allOf() - all/and validations](#allof)
-- [enforce.shape() - Object's shape matching](#shape)
-  - [enforce.optional() - nullable keys](#optional)
-- [enforec.loose() - loose shape matching](#loose)
-- [enforce.isArrayOf() - array shape matching](#isarrayof)
-
-## enforce.anyOf() - either/or validations :id=anyof
-
-Sometimes a value has more than one valid possibilities, `any` lets us validate that a value passes _at least_ one of the supplied rules.
-
-```js
-enforce(value).anyOf(enforce.isString(), enforce.isArray()).isNotEmpty();
-// A valid value would either an array or a string.
-```
-
-## enforce.allOf() - all/and validations :id=allof
-
-`allOf` lets us validate that a value passes _all_ of the supplied rules or templates.
-
-enforce(value).allOf(
-enforce.isArray(),
-enforce.longerThan(2)
-);
-
-This can be even more useful when combined with shapes and templates:
-
-```js
-const User = enforce.template(
-  enforce.loose({
-    id: enforce.isNumber()
-    name: enforce.shape({
-      first: enforce.isString(),
-      last: enforce.isString(),
-      middle: enforce.optional(enforce.isString()),
-    }),
-  })
-);
-
-const DisabledAccount = enforce.template(
-  enforce.loose({
-    disabled: enforce.equals(true)
-  })
-)
-
-enforce(value).allOf(
-  User,
-  DisabledAccount
-);
-// A valid is string and longer then 5.
-```
-
-## enforce.shape() - Lean schema validation. :id=shape
-
-`enforce.shape()` validates the structure of an object.
-
-```js
-enforce({
-  firstName: 'Rick',
-  lastName: 'Sanchez',
-  age: 70,
-}).shape({
-  firstName: enforce.isString(),
-  lastName: enforce.isString(),
-  age: enforce.isNumber(),
-});
-```
-
-You may also chain your validation rules:
-
-```js
-enforce({
-  age: 22,
-}).shape({
-  age: enforce.isNumber().isBetween(0, 150),
-});
-```
-
-You may also nest calls to shape in order to validate a deeply nested object.
-
-```js
-enforce({
-  user: {
-    name: {
-      first: 'Joseph',
-      last: 'Weil',
-    },
-  },
-}).shape({
-  user: enforce.shape({
-    name: enforce.shape({
-      first: enforce.isString(),
-      last: enforce.isString(),
-    }),
-  }),
-});
-```
-
-### enforce.optional() - nullable keys :id=optional
-
--- Optional can only be used within enforce.shape().
-
-In regular cases, a missing key in the data object would cause an error to be thrown. To prevent that from happening, mark your optional keys with `enforce.optional`.
-
-enforce.optional will pass validations of a key that's either not defined, undefined or null.
-
-`enforce.optional` takes as its arguments all the rules that the value must pass.
-
-```js
-enforce({
-  user: {
-    name: {
-      first: 'Joseph',
-      last: 'Weil',
-    },
-  },
-}).shape({
-  user: enforce.shape({
-    name: enforce.shape({
-      first: enforce.isString(),
-      last: enforce.isString(),
-      middle: enforce.optional(enforce.isString(), enforce.longerThan(3)),
-    }),
-  }),
-});
-```
-
-## enforec.loose() - loose shape matching :id=loose
-
-By default, shape will treat excess keys in your data object as validation errors. If you wish to allow support for excess keys in your object's shape, you can use `enforce.loose()` which is a shorthand to `enforce.shape(data, shape, { loose: true })`.
-
-```js
-enforce({ name: 'Laura', code: 'x23' }).shape({ name: enforce.isString() });
-// 🚨 This will throw an error because `code` is not defined in the shape
-```
-
-```js
-enforce({ name: 'Laura', code: 'x23' }).loose({ name: enforce.isString() });
-// ✅ This will pass with `code` not being validated
-```
-
-## enforce.isArrayOf() - array shape matching :id=isarrayof
-
-enforce.isArrayOf can be used to determine the allowed types and values within an array. It will run against each element in the array, and will only pass if all items meet at least one of the validation rules.
-
-```js
-enforce([1, 2, 'hello!']).isArrayOf(enforce.isString(), enforce.isNumber());
-```
-
-You can also combine `isArrayOf` with other rules to validate other array properties:
-
-```js
-enforce(someArrayValue)
-  .isArrayOf(enforce.isString(), enforce.isNumber().lessThan(3))
-  .longerThan(2);
-```
-
-And as part of shape:
-
-```js
-enforce({ data: [1, 2, 3] }).shape({
-  data: enforce.isArrayOf(enforce.isNumber()),
-});
-```
-
-## enforce.oneOf()
-
-enforce.oneOf can be used to determine if _exactly_ one of the rules applies. It will run against rule in the array, and will only pass if exactly one rule applies.
-
-```js
-enforce(value).oneOf(
-  enforce.isString(),
-  enforce.isNumber(),
-  enforce.longerThan(1)
-);
-
-/*
-value = 1      -> ✅ (value is a number)
-value = "1"    -> ✅ (value is string)
-value = [1, 2] -> ✅ (value is longer than 1)
-value = "12"   -> 🚨 (value is both a string and longer than 1)
-*/
-```