ivl 0.2.6 → 0.3.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Oskar-V
+
+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/README.md

@@ -1,11 +1,10 @@
 # Super lightweight input validation library
 This is a lightweight library for user input validation.
-Main focus is on speed and flexibility of the validation rules
+Main focus is on speed and flexibility of the validation rules.
 
-By default it automatically detects and supports async rules in your rule sets.
+By default `getInputErrors` and `getSchemaErrors` automatically detects and chooses the most performant checking method for your rule set.
 
-If your rule set and/or object are very large or complex, you may want to use 
-`getInputErrorsSync`/`getSchemaErrorsSync` or `getInputErrorsAsync`/`getSchemaErrorsAsync` for improved performance on synchronous and asynchronous rule sets respectively.
+If your rule set and/or schema are very large or complex, you may want to directly use `getInputErrorsSync`/`getSchemaErrorsSync` or `getInputErrorsAsync`/`getSchemaErrorsAsync` for improved performance on synchronous and asynchronous rule sets respectively.
 
 Use synchronous versions of the functions for better performance if you don't need to support asynchronous checks on your inputs. 
 
@@ -20,7 +19,6 @@ const my_rules = {
 console.log(getInputErrors(50, my_rules)); // []
 console.log(getInputErrors(11, my_rules)); // ["Input must be more than 40", "Input must be divisible by 10"]
 console.log(getInputErrors(30, my_rules)) // ["Input must be more than 40"]
-
 ```
 # Installing
 ```typescript
@@ -35,9 +33,9 @@ pnpm install ivl // pnpm
 ---
 # Usage examples
 ## Frontend example
-```javascript
-// src/index.ts
-import { getInputErrorsSync, getInputErrors } from 'ivl';
+### `index.ts`
+```typescript
+import { getInputErrors } from 'ivl';
 import type { RULES } from 'ivl';
 import { matchesRegex, minLength, maxLength, isType } from 'ivl/helpers';
 
@@ -58,23 +56,23 @@ const EMAIL_REQUIREMENTS: RULES = {
 const PASSWORD_REQUIREMENTS: RULES = {
   "Must be string": isType('string'),
   "Must be at least 8 characters": minLength(8),
-  "Must contain at least one upper case character": matchesRegex(/(?=.*[A-Z])/),
-  "Must contain at least one lower case character": matchesRegex(/(?=.*[a-z])/),
+  "Must contain at least one upper case character": matchesRegex(/[A-Z]/),
+  "Must contain at least one lower case character": matchesRegex(/[a-z]/),
 };
 
 // You can of course expand on your existing rules: 
 const STRONG_PASSWORD_REQUIREMENTS: RULES = {
   ...PASSWORD_REQUIREMENTS,
-  "Must contain at least one digit": matchesRegex(/(?=.*\d)/),
-  "Must contain at least one symbol": matchesRegex(/[^\w]/),
+  "Must contain at least one digit": matchesRegex(/\d/),
+  "Must contain at least one symbol": matchesRegex(/[^\w\s]/),
 };
 
 const email_value = "some-value";
 const pw_value = "Passesweakpw";
 
 const email_errors = getInputErrors(email_value, EMAIL_REQUIREMENTS);
-const pw_errors = getInputErrorsSync(pw_value, PASSWORD_REQUIREMENTS);
-const strong_pw_errors = getInputErrorsSync(pw_value, STRONG_PASSWORD_REQUIREMENTS);
+const pw_errors = getInputErrors(pw_value, PASSWORD_REQUIREMENTS);
+const strong_pw_errors = getInputErrors(pw_value, STRONG_PASSWORD_REQUIREMENTS);
 
 console.log({email_errors, pw_errors, strong_pw_errors});
 ```
@@ -82,10 +80,11 @@ console.log({email_errors, pw_errors, strong_pw_errors});
 
 ## Backend example with Hono & Bun.js
 
+### `rules.ts`
 ```typescript
-// rules.ts
-
 import { isType, minLength, maxLength, matchesRegex } from 'ivl/helpers';
+import { EMAIL_PATTERN } from 'ivl/patterns';
+import type { SCHEMA } from 'ivl';
 import { checkValueInDatabase } from 'my-database-controller';
 
 const existsInDatabase = (key: string, table: string, exists: boolean = true): RULE =>
@@ -101,10 +100,10 @@ const EMAIL_REQUIREMENTS = {
 const PASSWORD_REQUIREMENTS = {
   "Must be string": isType('string'),
   "Must be at least 8 characters": minLength(8),
-  "Must contain at least one upper case character": matchesRegex(/(?=.*[A-Z])/),
-  "Must contain at least one lower case character": matchesRegex(/(?=.*[a-z])/),
-  "Must contain at least one digit": matchesRegex(/(?=.*\d)/),
-  "Must contain at least one symbol": matchesRegex(/[^\w]/),
+  "Must contain at least one upper case character": matchesRegex(/[A-Z]/),
+  "Must contain at least one lower case character": matchesRegex(/[a-z]/),
+  "Must contain at least one digit": matchesRegex(/\d/),
+  "Must contain at least one symbol": matchesRegex(/[^\w\s]/),
 };
 
 export const LOGIN_SCHEMA: SCHEMA =  {
@@ -113,7 +112,9 @@ export const LOGIN_SCHEMA: SCHEMA =  {
 };
 
 export const REGISTER_SCHEMA: SCHEMA = {
-  organization_name: {} // Pass in an empty rule set, so the value can be whatever
+  // We can pass in an empty rule set to allow any value
+  // Or we can omit the argument entirely and set the strict flag to false when checking the schema
+  organization_name: {}
   email: {
     ...EMAIL_REQUIREMENTS,
     "Email already registered": existsInDatabase('email','users', false)
@@ -121,61 +122,55 @@ export const REGISTER_SCHEMA: SCHEMA = {
   password: PASSWORD_REQUIREMENTS
 };
 
+// Registering via invitation needs all the same values except organization name
+// inherit parts of rule sets, as opposed to extending the rule set as show in the
+// frontend example
+export const INVITE_REGISTER_SCHEMA = (({ organization_name, ...invite_schema }) => invite_schema)(REGISTRATION_SCHEMA)
+
 export const INVITATION_PARAM: SCHEMA = {
-  code: {
+  invitation_code: {
     "Not a valid invitation": existsInDatabase('code', 'invitation')
   }
 };
 
 ```
 
+### `index.ts`
 ```typescript
-// index.ts
-import { Hono } from 'hono';
-import { jwt } from 'hono/jwt';
+import { Hono, ValidationTargets } from 'hono';
 import { validator } from 'hono/validator';
 import { getSchemaErrors } from 'ivl';
-import type { SCHEMA } from 'ivl';
-import { LOGIN_SCHEMA, REGISTER_SCHEMA, INVITATION_PARAM } from './rules.ts';
+import { LOGIN_SCHEMA, REGISTER_SCHEMA, INVITE_REGISTER_SCHEMA, INVITATION_PARAM } from './rules.ts';
 
 // Wrapper for hono validator middleware
-const validateWrapper = (schema: SCHEMA, error: ClientErrorStatusCode | RedirectStatusCode = 400, strict = true) =>
-  async (value: any, c: Context) => {
-    const jwt = c.get('jwtPayload'); // Pass jwt to the validator so we could use its value when checking input validation rules
-    const errors = await getSchemaErrors(value, schema, {strict:true}, jwt);
+export const validate = (input_type: keyof ValidationTargets, schema: SCHEMA) =>
+  validator(input_type, async (value: CHECKABLE_OBJECT) => {
+    const errors = await getSchemaErrors(value, schema, { strict: true });
     if (Object.values(errors).filter((e) => e.length).length) {
-      throw new HTTPException(error, {
+      throw new HTTPException(400, {
         message: JSON.stringify(errors),
       });
     }
     return value;
-  }
+  })
 
 const app = new Hono();
 
-app.use(jwt({
-  secret: "some-secret-value",
-  cookie: 'token'
-}));
-
 app.post('/login',
-  validator('json', validateWrapper(LOGIN_SCHEMA)),
+  validate('json', LOGIN_SCHEMA),
   (c) => c.text("Success"));
 
 app.all('/logout', (c) => c.text("Success"));
 
 app.put('/register', 
-  validator('json', validateWrapper(REGISTER_SCHEMA)),
+  validate('json', REGISTER_SCHEMA),
   (c) => c.text("Success"));
 
 // This first validates the invitation parameter against our database
 // And then validates the body of the request
 app.put('/register/:invitation_code',
-  validator('param', validateWrapper(INVITATION_PARAM)),
-  validator('json', validateWrapper(
-    // Registering via invitation needs all the same values except organization name - inherit parts of rule sets, as opposed to extending the rule set as shown above
-    (({ organization_name, ...invite_schema }) => invite_schema)(REGISTRATION_SCHEMA)
-  )),
+  validate('param', INVITATION_PARAM),
+  validate('json', INVITE_REGISTER_SCHEMA ),
   (c)=> c.text("Success"));
 
 export default app;

package/lib/helpers/index.d.ts

@@ -13,9 +13,17 @@ export declare const maxLength: (max_length?: number) => RULE_SYNC;
 export declare const minLength: (min_length?: number) => RULE_SYNC;
 export declare const stringBetween: (max?: number, min?: number) => RULE_SYNC;
 export declare const numberBetween: (max?: number, min?: number) => RULE_SYNC;
-export declare const acceptAny: (rules?: RULE[]) => RULE;
+export declare const acceptAnyAsync: (rules?: RULE[]) => RULE;
 export declare const acceptAnySync: (rules?: RULE_SYNC[]) => RULE_SYNC;
-export declare const allowUndefined: (rules: RULES) => {};
-export declare const preprocess: (fn: Function, rules: RULES) => {};
+declare const allowUndefined: (rules: RULES) => {};
+declare const preprocess: (fn: Function, rules: RULES) => {};
+
+declare namespace ruleSet {
+	export { allowUndefined, preprocess };
+}
+
+export {
+	ruleSet,
+};
 
 export {};

package/lib/helpers/index.js

@@ -1 +1 @@
-var s=(n)=>typeof n==="string"||n!==null&&typeof n==="object"&&("length"in n)&&typeof n.length==="number",i=(n)=>(e)=>typeof e===n,p=(n)=>(e)=>typeof e==="string"&&n.test(e),f=(n=1/0)=>(e)=>typeof e==="number"&&e<=n,m=(n=-1/0)=>(e)=>typeof e==="number"&&e>=n,w=(n=1/0)=>(e)=>s(e)&&e.length<=n,y=(n=0)=>(e)=>s(e)&&e.length>=n,a=(n=1/0,e=0)=>(t)=>typeof t==="string"&&t.length>=e&&t.length<=n,L=(n=1/0,e=-1/0)=>(t)=>typeof t==="number"&&t>=e&&t<=n,g=(n=[])=>async(e,...t)=>(await Promise.all(n.map((o)=>o(void 0,e,...t)))).some((o)=>o),h=(n=[])=>(e,...t)=>n.map((o)=>o(void 0,e,...t)).some((o)=>o);var l=(n)=>Object.entries(n).reduce((e,[t,o])=>({...e,[t]:(r,...u)=>typeof r==="undefined"?!0:o(r,...u)}),{}),x=(n,e)=>Object.entries(e).reduce((t,[o,r])=>({...t,[o]:(u,...c)=>r(n(u),...c)}),{});export{a as stringBetween,x as preprocess,L as numberBetween,y as minLength,m as min,w as maxLength,f as max,p as matchesRegex,i as isType,l as allowUndefined,h as acceptAnySync,g as acceptAny};
+var i=Object.defineProperty;var m=(e,n)=>{for(var t in n)i(e,t,{get:n[t],enumerable:!0,configurable:!0,set:(o)=>n[t]=()=>o})};var u=(e)=>typeof e==="string"||e!==null&&typeof e==="object"&&("length"in e)&&typeof e.length==="number",a=(e)=>(n)=>typeof n===e,L=(e)=>(n)=>typeof n==="string"&&e.test(n),g=(e=1/0)=>(n)=>typeof n==="number"&&n<=e,h=(e=-1/0)=>(n)=>typeof n==="number"&&n>=e,l=(e=1/0)=>(n)=>u(n)&&n.length<=e,R=(e=0)=>(n)=>u(n)&&n.length>=e,x=(e=1/0,n=0)=>(t)=>typeof t==="string"&&t.length>=n&&t.length<=e,E=(e=1/0,n=-1/0)=>(t)=>typeof t==="number"&&t>=n&&t<=e,U=(e=[])=>async(n,...t)=>(await Promise.all(e.map((o)=>o(n,...t)))).some((o)=>o),b=(e=[])=>(n,...t)=>e.map((o)=>o(n,...t)).some((o)=>o);var p={};m(p,{preprocess:()=>f,allowUndefined:()=>y});var y=(e)=>Object.entries(e).reduce((n,[t,o])=>({...n,[t]:(r,...s)=>typeof r==="undefined"?!0:o(r,...s)}),{}),f=(e,n)=>Object.entries(n).reduce((t,[o,r])=>({...t,[o]:(s,...c)=>r(e(s),...c)}),{});export{x as stringBetween,p as ruleSet,E as numberBetween,R as minLength,h as min,l as maxLength,g as max,L as matchesRegex,a as isType,b as acceptAnySync,U as acceptAnyAsync};

package/lib/index.d.ts

@@ -9,31 +9,31 @@ export type RULES = {
 	[index: string]: RULE;
 };
 export type SCHEMA_SYNC = {
-	[index: string]: RULES_SYNC;
+	[index: string]: RULES_SYNC | RULES_SYNC[];
 };
 export type SCHEMA = {
-	[index: string]: RULES;
-};
-export type CHECKABLE_OBJECT = {
-	[index: string]: unknown;
+	[index: string]: RULES | RULES[];
 };
 /**
  * @arg {boolean} strict --- Don't allow object to have keys not included in the schema
- */
+*/
 export type SCHEMA_OPTIONS = {
 	strict?: boolean;
 };
-export type CHECKED_SCHEMA_SYNC = {
-	[index: string]: string[];
+export type CHECKABLE_OBJECT = {
+	[index: string]: unknown;
 };
-export type CHECKED_SCHEMA = Promise<CHECKED_SCHEMA_SYNC>;
+export type CHECKED_SCHEMA_SYNC<T extends keyof CHECKABLE_OBJECT> = {
+	[K in T]: string[] | string[][];
+};
+export type CHECKED_SCHEMA<T extends keyof CHECKABLE_OBJECT> = Promise<CHECKED_SCHEMA_SYNC<T>>;
 /**
  * Detect if a RULES object has any async rules in it
  *
- * @param {Record<string, RULE>} rules a rules object
+ * @param {Record<string, RULE>|Record<string, RULE>[]} rules a rules object
  * @returns {boolean} true if any of the rules is an async function otherwise false
  */
-export declare const hasAsyncFunction: (rules: Record<string, RULE>) => boolean;
+export declare const hasAsyncFunction: (rules: Record<string, RULE> | Record<string, RULE>[]) => boolean;
 /**
  * Check the input against all provided validation rules asynchronously
  *
@@ -46,13 +46,15 @@ export declare const getValueErrorsAsync: (value: unknown, rules: RULES, ...over
 /**
  * Check a schema against all provided validation rules asynchronously
  *
- * @param {CHECKABLE_OBJECT} object object to be validated
+ * @param {CHECKABLE_OBJECT} object_to_check object to be validated
  * @param {SCHEMA} schema schema to validate against
  * @param {SCHEMA_OPTIONS} options options affecting how the rules are run
  * @param {unknown[]} overload array of extra values the validator rules might need to properly validate the value
- * @returns {CHECKED_SCHEMA} an object containing keys and their respective lists of failed rule names
+ * @returns {CHECKED_SCHEMA<T>} an object containing keys and their respective lists of failed rule names
  */
-export declare const getSchemaErrorsAsync: (object: CHECKABLE_OBJECT, schema: SCHEMA, options?: SCHEMA_OPTIONS, ...overload: unknown[]) => CHECKED_SCHEMA;
+export declare const getSchemaErrorsAsync: <T extends keyof CHECKABLE_OBJECT>(object_to_check: Pick<CHECKABLE_OBJECT, T>, schema: {
+	[K in T]: RULES | RULES[];
+}, options?: SCHEMA_OPTIONS, ...overload: unknown[]) => Promise<CHECKED_SCHEMA_SYNC<T>>;
 /**
  *
  * @param {unknown} value the value to check
@@ -68,26 +70,25 @@ export declare const getValueErrorsSync: (value: unknown, rules: RULES_SYNC, ...
 * @param {SCHEMA} schema schema to validate against
 * @param {SCHEMA_OPTIONS} options options affecting how the rules are run
 * @param {unknown[]} overload array of extra values the validator rules might need to properly validate the value
-* @returns {CHECKED_SCHEMA} an object containing keys and their respective lists of failed rule names
+* @returns {CHECKED_SCHEMA_SYNC<T>} an object containing keys and their respective lists of failed rule names
 */
-export declare const getSchemaErrorsSync: (object: CHECKABLE_OBJECT, schema: SCHEMA_SYNC, options?: SCHEMA_OPTIONS, ...overload: unknown[]) => CHECKED_SCHEMA_SYNC;
+export declare const getSchemaErrorsSync: <T extends keyof CHECKABLE_OBJECT>(object: CHECKABLE_OBJECT, schema: SCHEMA_SYNC, options?: SCHEMA_OPTIONS, ...overload: unknown[]) => CHECKED_SCHEMA_SYNC<T>;
 /**
- *
  * @param {unknown} value the value to check
  * @param {RULES|RULES_SYNC} rules rules object to use for validating the provided value
  * @param {unknown[]} overload array of extra values the validator rules might need to properly validate the value
- * @returns {string[]} a list of rule names which failed validation
+ * @returns {Promise<string[]>|string[]} a list of rule names which failed validation
  */
-export declare const getValueErrors: (value: unknown, rules: RULES | RULES_SYNC, ...overload: unknown[]) => string[] | Promise<string[]>;
+export declare const getValueErrors: (value: unknown, rules: RULES | RULES_SYNC, ...overload: unknown[]) => Promise<string[]> | string[];
 /**
  * Check a schema against all provided validation rules
  *
  * @param {CHECKABLE_OBJECT} object object to be validated
- * @param {SCHEMA} schema schema to validate against
+ * @param {SCHEMA|SCHEMA_SYNC} schema schema to validate against
  * @param {SCHEMA_OPTIONS} options options affecting how the rules are run
  * @param {unknown[]} overload array of extra values the validator rules might need to properly validate the value
  * @returns {CHECKED_SCHEMA} an object containing keys and their respective lists of failed rule names
  */
-export declare const getSchemaErrors: (object: CHECKABLE_OBJECT, schema: SCHEMA_SYNC | SCHEMA, options?: SCHEMA_OPTIONS, ...overload: unknown[]) => CHECKED_SCHEMA_SYNC | CHECKED_SCHEMA;
+export declare const getSchemaErrors: <T extends keyof CHECKABLE_OBJECT>(object: CHECKABLE_OBJECT, schema: SCHEMA_SYNC | SCHEMA, options?: SCHEMA_OPTIONS, ...overload: unknown[]) => CHECKED_SCHEMA<T> | CHECKED_SCHEMA_SYNC<T>;
 
 export {};

package/lib/index.js

@@ -1 +1 @@
-var Z={strict:!1},$=(z)=>Object.values(z).some((q)=>typeof q==="function"&&q.constructor.name==="AsyncFunction"),J=async(z,q,...W)=>{const G={};return Object.entries(q).forEach(([x,Q])=>{G[x]=Promise.resolve(!1).then(()=>Q(z,...W)).then((R)=>G[x]=R).catch((R)=>{return console.warn(`Rule validation functions for "${x}" didn't exit cleanly`,R),G[x]=!1})}),await Promise.allSettled(Object.values(G)),Object.entries(G).reduce((x,[Q,R])=>R?x:[...x,Q],[])},K=async(z,q,W=Z,...G)=>{const x={};if(Object.entries(q).forEach(([Q,R])=>{x[Q]=J(z[Q],R,...G).then((X)=>{x[Q]=X}).catch((X)=>{x[Q]=X})}),W.strict){const Q=Object.keys(z),R=new Set(Object.keys(q));Q.filter((Y)=>!R.has(Y)).forEach((Y)=>{x[Y]=["Key not allowed"]})}return await Promise.allSettled(Object.values(x)),x},B=(z,q,...W)=>Object.entries(q).reduce((G,[x,Q])=>{try{return Q(z,...W)?G:[...G,x]}catch(R){return console.warn(`Rule validation function for "${x}" didn't exit cleanly`,R),[...G,x]}},[]),f=(z,q,W=Z,...G)=>{const x=Object.entries(q).reduce((Q,[R,X])=>({...Q,[R]:B(z[R],X,...G)}),{});if(W.strict){const Q=Object.keys(z),R=new Set(Object.keys(q));Q.filter((Y)=>!R.has(Y)).forEach((Y)=>{x[Y]=["Key not allowed"]})}return x},U=(z,q,...W)=>{if($(q))return J(z,q,...W);return B(z,q,...W)},I=(z,q,W=Z,...G)=>{if(Object.values(q).some($))return K(z,q,W,...G);return f(z,q,W,...G)};export{$ as hasAsyncFunction,B as getValueErrorsSync,J as getValueErrorsAsync,U as getValueErrors,f as getSchemaErrorsSync,K as getSchemaErrorsAsync,I as getSchemaErrors};
+var K={strict:!1},U=(x)=>{if(Array.isArray(x))return x.some((z)=>Object.values(z).some((W)=>typeof W==="function"&&W.constructor.name==="AsyncFunction"));return Object.values(x).some((z)=>typeof z==="function"&&z.constructor.name==="AsyncFunction")},Y=async(x,z,...W)=>{const Q={};return Object.entries(z).forEach(([G,X])=>{Q[G]=Promise.resolve(!1).then(()=>X(x,...W)).then((q)=>Q[G]=q).catch(()=>{return Q[G]=!1})}),await Promise.allSettled(Object.values(Q)),Object.entries(Q).reduce((G,[X,q])=>q?G:[...G,X],[])},I=async(x,z,W=K,...Q)=>{const G={},X=[];if(Object.entries(z).forEach(([q,$])=>{let Z;if(Array.isArray($))Z=Promise.allSettled($.map((R)=>Y(x[q],R,...Q))).then((R)=>{const f=R.map((J)=>{if(J.status==="fulfilled")return J.value;return["Unknown error occurred"]},[]);if(f.some((J)=>!J.length))G[q]=[];else G[q]=f}).catch((R)=>{if(R instanceof Error)G[q]=[R.message];else G[q]=["Unknown error occurred"]});else Z=Y(x[q],$,...Q).then((R)=>{G[q]=R}).catch((R)=>{G[q]=R});X.push(Z)}),W.strict){const q=Object.keys(x),$=new Set(Object.keys(z));q.filter((R)=>!$.has(R)).forEach((R)=>{G[R]=["Key not allowed"]})}return await Promise.allSettled(X),G},B=(x,z,...W)=>Object.entries(z).reduce((Q,[G,X])=>{try{return X(x,...W)?Q:[...Q,G]}catch(q){return[...Q,G]}},[]),L=(x,z,W=K,...Q)=>{const G=Object.entries(z).reduce((X,[q,$])=>{if(Array.isArray($)){const Z=$.map((R)=>B(x[q],R,...Q));if(Z.some((R)=>!R.length))return{...X,[q]:[]};return{...X,[q]:Z}}return{...X,[q]:B(x[q],$,...Q)}},{});if(W.strict){const X=Object.keys(x),q=new Set(Object.keys(z));X.filter((Z)=>!q.has(Z)).forEach((Z)=>{G[Z]=["Key not allowed"]})}return G},D=(x,z,...W)=>{if(U(z))return Y(x,z,...W);return B(x,z,...W)},w=(x)=>Object.values(x).some(U),F=(x,z,W=K,...Q)=>{if(w(z))return I(x,z,W,...Q);return L(x,z,W,...Q)};export{U as hasAsyncFunction,B as getValueErrorsSync,Y as getValueErrorsAsync,D as getValueErrors,L as getSchemaErrorsSync,I as getSchemaErrorsAsync,F as getSchemaErrors};

package/lib/patterns/index.d.ts

@@ -6,7 +6,6 @@ export declare const URL_PATTERN: RegExp;
 export declare const ISO_8601_DATETIME_PATTERN_STRICT: RegExp;
 export declare const ISO_8601_DATETIME_PATTERN: RegExp;
 export declare const ISO_8601_TIME_PATTERN: RegExp;
-export declare const RFC_2822_TIMESTAMP_PATTERN: RegExp;
 export declare const CONTAINS_LOWERCASE_CHARACTER_PATTERN: RegExp;
 export declare const CONTAINS_UPPERCASE_CHARACTER_PATTERN: RegExp;
 export declare const CONTAINS_DIGIT_CHARACTER_PATTERN: RegExp;

package/lib/patterns/index.js

@@ -1 +1 @@
-var x=/^[\w.%+-]+@[\w.-]+\.[a-zA-Z]{1,}$/,c=/^(\d{4})-(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2})$/,d=/^(https?:\/\/)?([^\s$.?#].[^\s]*)\.[a-z]{2,}(\/[^ \t\r\n\v\f]*)?$/i,f=/^(\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d(?:\.\d+)?(?:[+-][0-2]\d:[0-5]\d|Z)?)$/,j=/^(\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d(?::[0-5]\d(?:\.\d+)?)?)$/,k=/^(2[0-3]|[01][0-9]):([0-5][0-9]):([0-5][0-9])(Z|[+-](?:2[0-3]|[01][0-9]):([0-5][0-9]))?$/,l=/^(?:(Sun|Mon|Tue|Wed|Thu|Fri|Sat),\s)?(0[1-9]|[1-2]?[0-9]|3[01])\s(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s(19[0-9]{2}|[2-9][0-9]{3})\s(2[0-3]|[0-1][0-9]):([0-5][0-9])(?::(60|[0-5][0-9]))?\s([-\+][0-9]{2}[0-5][0-9]|(?:UT|GMT|(?:E|C|M|P)(?:ST|DT)|[A-IK-Z]))(?:\s|\((?:[^()\\]+|\\.)*?\))*$/,m=/[a-z]/,p=/[A-Z]/,q=/\d/,r=/[^\w\s]/;export{d as URL_PATTERN,l as RFC_2822_TIMESTAMP_PATTERN,c as MYSQL_TIMESTAMP_PATTERN,k as ISO_8601_TIME_PATTERN,f as ISO_8601_DATETIME_PATTERN_STRICT,j as ISO_8601_DATETIME_PATTERN,x as EMAIL_PATTERN,p as CONTAINS_UPPERCASE_CHARACTER_PATTERN,r as CONTAINS_SYMBOL_CHARACTER_PATTERN,m as CONTAINS_LOWERCASE_CHARACTER_PATTERN,q as CONTAINS_DIGIT_CHARACTER_PATTERN};
+var x=/^[\w.%+-]+@[\w.-]+\.[a-zA-Z]{1,}$/,c=/^(\d{4})-(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2})$/,d=/^(https?:\/\/)?([^\s$.?#].[^\s]*)\.[a-z]{2,}(\/[^ \t\r\n\v\f]*)?$/i,f=/^(\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d(?:\.\d+)?(?:[+-][0-2]\d:[0-5]\d|Z)?)$/,j=/^(\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d(?::[0-5]\d(?:\.\d+)?)?)$/,k=/^(2[0-3]|[01][0-9]):([0-5][0-9]):([0-5][0-9])(Z|[+-](?:2[0-3]|[01][0-9]):([0-5][0-9]))?$/,l=/[a-z]/,m=/[A-Z]/,p=/\d/,q=/[^\w\s]/;export{d as URL_PATTERN,c as MYSQL_TIMESTAMP_PATTERN,k as ISO_8601_TIME_PATTERN,f as ISO_8601_DATETIME_PATTERN_STRICT,j as ISO_8601_DATETIME_PATTERN,x as EMAIL_PATTERN,m as CONTAINS_UPPERCASE_CHARACTER_PATTERN,q as CONTAINS_SYMBOL_CHARACTER_PATTERN,l as CONTAINS_LOWERCASE_CHARACTER_PATTERN,p as CONTAINS_DIGIT_CHARACTER_PATTERN};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ivl",
-  "version": "0.2.6",
+  "version": "0.3.0",
   "author": {
     "name": "Oskar Voorel",
     "email": "oskar@voorel.com"