n4s 2.2.0-rc.1 → 4.0.0-dev-e266d9

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/rollup/enforce.js

@@ -1,13 +0,0 @@
-const addEsmDir = require('../../../../scripts/build/addEsmDir');
-const genConfig = require('../../../../scripts/build/genConfig');
-const writeMainTemplate = require('../../../../scripts/build/writeMainTemplate');
-const { PACKAGE_N4S } = require('../../../../shared/constants');
-const { packageDist } = require('../../../../util');
-
-addEsmDir(packageDist(PACKAGE_N4S));
-writeMainTemplate(packageDist(PACKAGE_N4S), PACKAGE_N4S);
-
-export default genConfig({
-  libraryName: PACKAGE_N4S,
-  distPath: packageDist(PACKAGE_N4S),
-});

package/config/rollup/enforceExtended.js

@@ -1,10 +0,0 @@
-const genConfig = require('../../../../scripts/build/genConfig');
-const { PACKAGE_N4S } = require('../../../../shared/constants');
-const { packageDist } = require('../../../../util');
-
-export default genConfig({
-  distPath: packageDist(PACKAGE_N4S),
-  input: 'extended/enforce/index.js',
-  libraryName: 'enforceExtended',
-  packageName: PACKAGE_N4S,
-});

package/config/rollup/ensure.js

@@ -1,10 +0,0 @@
-const genConfig = require('../../../../scripts/build/genConfig');
-const { PACKAGE_N4S } = require('../../../../shared/constants');
-const { packageDist } = require('../../../../util');
-
-export default genConfig({
-  distPath: packageDist(PACKAGE_N4S),
-  input: 'ensure/index.js',
-  libraryName: 'ensure',
-  packageName: PACKAGE_N4S,
-});

package/config/rollup/rollup.config.js

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

package/docs/business_rules.md

@@ -1,80 +0,0 @@
-# Business related rules
-
-Along with the existing rules, you might need different business related rules, for email, phone number, credit card validations, and more.
-
-n4s uses [validator.js](https://github.com/validatorjs/validator.js) to provide some of these validations.
-
-## Validator.js validations currently provided:
-
-- isAlphanumeric
-- isCreditCard
-- isCurrency
-- isEmail
-- isIP
-- isIdentityCard
-- isJSON
-- isLocale
-- isMimeType
-- isMobilePhone
-- isPassportNumber
-- isPostalCode
-- isURL
-
-Because these rules are business specific, and can have an impact on your bundle size, they are split into a their own bundle.
-
-```js
-import enforce from 'n4s/enforceExtended';
-
-enforce('example@gmail.com').isEmail();
-```
-
-```js
-import ensure from 'n4s/ensureExtended';
-
-ensure().isEmail().test('example@gmail.com');
-```
-
-Some of these rules also require locale arrays and objects. These are also exported by the extended entry point:
-
-```js
-import enforce, {
-  isAlphanumericLocales,
-  isMobilePhoneLocales,
-  isPostalCodeLocales,
-} from 'n4s/enforceExtended';
-```
-
-```js
-import ensure, {
-  isAlphanumericLocales,
-  isMobilePhoneLocales,
-  isPostalCodeLocales,
-} from 'n4s/ensureExtended';
-```
-
-To read the full documentation on these rules and the options they take, please visit [validator.js](https://github.com/validatorjs/validator.js).
-
-### validator.js license:
-
-```
-Copyright (c) 2018 Chris O'Hara <cohara87@gmail.com>
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-```

package/docs/custom.md

@@ -1,54 +0,0 @@
-# Custom enforce rules
-
-To make it easier to reuse logic across your application, sometimes you would want to encapsulate bits of logic in rules that you can use later on, for example, "what's considered a valid email".
-
-Rules are called with the argument passed to enforce(x) followed by the arguments passed to `.yourRule(y, z)`.
-
-```js
-enforce.extend({
-  yourRule(x, y, z) {
-    return {
-      pass: true,
-      message: () => '',
-    };
-  },
-});
-```
-
-```js
-import { enforce } from 'n4s';
-
-enforce.extend({
-  isValidEmail: value => value.indexOf('@') > -1,
-  hasKey: (value, key) => value.hasOwnProperty(key),
-  passwordsMatch: (passConfirm, options) =>
-    passConfirm === options.passConfirm && options.passIsValid,
-});
-
-enforce(user.email).isValidEmail();
-```
-
-## Custom rules return value
-
-Rules can either return boolean indicating success or failure, or an object with two keys. `pass` indicates whether the validation is successful or not, and message provides a function with no arguments that return an error message in case of failure. Thus, when pass is false, message should return the error message for when enforce(x).yourRule() fails.
-
-```js
-enforce.extend({
-  isWithinRange(received, floor, ceiling) {
-    const pass = received >= floor && received <= ceiling;
-    if (pass) {
-      return {
-        message: () =>
-          `expected ${received} not to be within range ${floor} - ${ceiling}`,
-        pass: true,
-      };
-    } else {
-      return {
-        message: () =>
-          `expected ${received} to be within range ${floor} - ${ceiling}`,
-        pass: false,
-      };
-    }
-  },
-});
-```

package/docs/ensure.md

@@ -1,40 +0,0 @@
-# Not-throwing validations (ensure)
-
-If you do not use a validations testing library but still want to use enforce [rules](./rules), you can use the ensure interface.
-
-Ensure is similar to enforce, only that it returns a boolean value instead of throwing an error.
-
-Since ensure has no way of knowing when you are done adding rules, you have to do that by putting the `.test()` function last with your value as its argument.
-
-## Usage example
-
-For example, if I want to test that the number 4 is both numeric, and is less than 5, I would:
-
-```js
-import { ensure } from 'n4s';
-
-ensure().isNumeric().lessThan(5).test(4); // The value I am testing.
-// `.test()` is always the last function passed
-
-// returns true
-```
-
-## Custom rules
-
-You can [extend](./custom) ensure in the same way you extend enforce.
-
-```js
-import ensure from 'n4s';
-
-ensure.extend({
-  isValidEmail: value => value.includes('@'),
-});
-
-ensure().isValidEmail().test('some invali dstring');
-
-// returns false
-
-ensure().isValidEmail().test('valid@email.com');
-
-// returns true
-```