@thisisagile/easy 15.16.3 → 15.17.1

package/dist/resources/Route.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/resources/Route.ts"],"sourcesContent":["import { List, meta, Optional, tryTo, Uri } from '../types';\nimport { Verb } from '../http';\nimport { Req } from './Req';\nimport { Resource } from './Resource';\nimport { Scope, UseCase } from '../process';\nimport { RequestHandler } from 'express';\n\nexport const route =\n  (uri: Uri): ClassDecorator =>\n  (subject: unknown): void => {\n    meta(subject).set('route', uri);\n  };\n\nexport type Endpoint<T = unknown> = (re: Req) => Promise<T | List<T>>;\nexport type RouteRequires = { token: boolean; labCoat: boolean; scope?: Scope; uc?: UseCase };\nexport type Route = { verb: Verb; endpoint: Endpoint; requires: RouteRequires; middleware: RequestHandler[] };\nexport type Routes = { route: Uri; middleware: RequestHandler[]; endpoints: List<Route> };\n\nconst toRoute = (endpoint: Endpoint, requires: RouteRequires, verb?: Verb, middleware?: RequestHandler[]): Optional<Route> =>\n  tryTo(verb)\n    .is.defined()\n    .map(verb => ({ verb, endpoint, requires, middleware: middleware ?? [] } as Route))\n    .orElse();\n\nclass Router implements Routes {\n  constructor(readonly resource: Resource) {}\n\n  get route(): Uri {\n    return meta(this.resource).get('route');\n  }\n\n  get middleware(): RequestHandler[] {\n    return meta(this.resource).get<RequestHandler[]>('middleware') ?? [];\n  }\n\n  get endpoints(): List<Route> {\n    return meta(this.resource)\n      .properties('verb')\n      .mapDefined(v =>\n        toRoute(\n          this.resource[v.property],\n          {\n            labCoat: v.get<boolean>('labCoat') ?? false,\n            token: v.get<boolean>('token') ?? false,\n            scope: v.get<Scope>('scope'),\n            uc: v.get<UseCase>('uc'),\n          },\n          v.get<Verb>('verb'),\n          v.get<RequestHandler[]>('middleware')\n        )\n      );\n  }\n}\n\nexport const routes = (resource: Resource): Routes => new Router(resource);\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAAiD;AAO1C,MAAM,QACX,CAAC,QACD,CAAC,YAA2B;AAC1B,yBAAK,OAAO,EAAE,IAAI,SAAS,GAAG;AAChC;AAOF,MAAM,UAAU,CAAC,UAAoB,UAAyB,MAAa,mBACzE,oBAAM,IAAI,EACP,GAAG,QAAQ,EACX,IAAI,CAAAA,WAAS,EAAE,MAAAA,OAAM,UAAU,UAAU,YAAY,cAAc,CAAC,EAAE,EAAW,EACjF,OAAO;AAEZ,MAAM,OAAyB;AAAA,EAC7B,YAAqB,UAAoB;AAApB;AAAA,EAAqB;AAAA,EAE1C,IAAI,QAAa;AACf,eAAO,mBAAK,KAAK,QAAQ,EAAE,IAAI,OAAO;AAAA,EACxC;AAAA,EAEA,IAAI,aAA+B;AACjC,eAAO,mBAAK,KAAK,QAAQ,EAAE,IAAsB,YAAY,KAAK,CAAC;AAAA,EACrE;AAAA,EAEA,IAAI,YAAyB;AAC3B,eAAO,mBAAK,KAAK,QAAQ,EACtB,WAAW,MAAM,EACjB;AAAA,MAAW,OACV;AAAA,QACE,KAAK,SAAS,EAAE,QAAQ;AAAA,QACxB;AAAA,UACE,SAAS,EAAE,IAAa,SAAS,KAAK;AAAA,UACtC,OAAO,EAAE,IAAa,OAAO,KAAK;AAAA,UAClC,OAAO,EAAE,IAAW,OAAO;AAAA,UAC3B,IAAI,EAAE,IAAa,IAAI;AAAA,QACzB;AAAA,QACA,EAAE,IAAU,MAAM;AAAA,QAClB,EAAE,IAAsB,YAAY;AAAA,MACtC;AAAA,IACF;AAAA,EACJ;AACF;AAEO,MAAM,SAAS,CAAC,aAA+B,IAAI,OAAO,QAAQ;","names":["verb"]}
+{"version":3,"sources":["../../src/resources/Route.ts"],"sourcesContent":["import { List, meta, Optional, tryTo, Uri } from '../types';\nimport { Verb } from '../http';\nimport { Req } from './Req';\nimport { Resource } from './Resource';\nimport { Scope, UseCase } from '../process';\nimport { RequestHandler } from 'express';\n\nexport const route =\n  (uri: Uri): ClassDecorator =>\n  (subject: unknown): void => {\n    meta(subject).set('route', uri);\n  };\n\nexport type Endpoint<T = unknown> = (re: Req) => Promise<T | List<T>>;\nexport type RouteRequires = { token: boolean; labCoat: boolean; scope?: Scope; uc?: UseCase };\nexport type Route = { verb: Verb; endpoint: Endpoint; requires: RouteRequires; middleware: RequestHandler[] };\nexport type Routes = { route: Uri; middleware: RequestHandler[]; endpoints: List<Route> };\n\nconst toRoute = (endpoint: Endpoint, requires: RouteRequires, verb?: Verb, middleware?: RequestHandler[]): Optional<Route> =>\n  tryTo(verb)\n    .is.defined()\n    .map(verb => ({ verb, endpoint, requires, middleware: middleware ?? [] }) as Route)\n    .orElse();\n\nclass Router implements Routes {\n  constructor(readonly resource: Resource) {}\n\n  get route(): Uri {\n    return meta(this.resource).get('route');\n  }\n\n  get middleware(): RequestHandler[] {\n    return meta(this.resource).get<RequestHandler[]>('middleware') ?? [];\n  }\n\n  get endpoints(): List<Route> {\n    return meta(this.resource)\n      .properties('verb')\n      .mapDefined(v =>\n        toRoute(\n          this.resource[v.property],\n          {\n            labCoat: v.get<boolean>('labCoat') ?? false,\n            token: v.get<boolean>('token') ?? false,\n            scope: v.get<Scope>('scope'),\n            uc: v.get<UseCase>('uc'),\n          },\n          v.get<Verb>('verb'),\n          v.get<RequestHandler[]>('middleware')\n        )\n      );\n  }\n}\n\nexport const routes = (resource: Resource): Routes => new Router(resource);\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAAiD;AAO1C,MAAM,QACX,CAAC,QACD,CAAC,YAA2B;AAC1B,yBAAK,OAAO,EAAE,IAAI,SAAS,GAAG;AAChC;AAOF,MAAM,UAAU,CAAC,UAAoB,UAAyB,MAAa,mBACzE,oBAAM,IAAI,EACP,GAAG,QAAQ,EACX,IAAI,CAAAA,WAAS,EAAE,MAAAA,OAAM,UAAU,UAAU,YAAY,cAAc,CAAC,EAAE,EAAW,EACjF,OAAO;AAEZ,MAAM,OAAyB;AAAA,EAC7B,YAAqB,UAAoB;AAApB;AAAA,EAAqB;AAAA,EAE1C,IAAI,QAAa;AACf,eAAO,mBAAK,KAAK,QAAQ,EAAE,IAAI,OAAO;AAAA,EACxC;AAAA,EAEA,IAAI,aAA+B;AACjC,eAAO,mBAAK,KAAK,QAAQ,EAAE,IAAsB,YAAY,KAAK,CAAC;AAAA,EACrE;AAAA,EAEA,IAAI,YAAyB;AAC3B,eAAO,mBAAK,KAAK,QAAQ,EACtB,WAAW,MAAM,EACjB;AAAA,MAAW,OACV;AAAA,QACE,KAAK,SAAS,EAAE,QAAQ;AAAA,QACxB;AAAA,UACE,SAAS,EAAE,IAAa,SAAS,KAAK;AAAA,UACtC,OAAO,EAAE,IAAa,OAAO,KAAK;AAAA,UAClC,OAAO,EAAE,IAAW,OAAO;AAAA,UAC3B,IAAI,EAAE,IAAa,IAAI;AAAA,QACzB;AAAA,QACA,EAAE,IAAU,MAAM;AAAA,QAClB,EAAE,IAAsB,YAAY;AAAA,MACtC;AAAA,IACF;AAAA,EACJ;AACF;AAEO,MAAM,SAAS,CAAC,aAA+B,IAAI,OAAO,QAAQ;","names":["verb"]}

package/dist/resources/Route.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/resources/Route.ts"],"sourcesContent":["import { List, meta, Optional, tryTo, Uri } from '../types';\nimport { Verb } from '../http';\nimport { Req } from './Req';\nimport { Resource } from './Resource';\nimport { Scope, UseCase } from '../process';\nimport { RequestHandler } from 'express';\n\nexport const route =\n  (uri: Uri): ClassDecorator =>\n  (subject: unknown): void => {\n    meta(subject).set('route', uri);\n  };\n\nexport type Endpoint<T = unknown> = (re: Req) => Promise<T | List<T>>;\nexport type RouteRequires = { token: boolean; labCoat: boolean; scope?: Scope; uc?: UseCase };\nexport type Route = { verb: Verb; endpoint: Endpoint; requires: RouteRequires; middleware: RequestHandler[] };\nexport type Routes = { route: Uri; middleware: RequestHandler[]; endpoints: List<Route> };\n\nconst toRoute = (endpoint: Endpoint, requires: RouteRequires, verb?: Verb, middleware?: RequestHandler[]): Optional<Route> =>\n  tryTo(verb)\n    .is.defined()\n    .map(verb => ({ verb, endpoint, requires, middleware: middleware ?? [] } as Route))\n    .orElse();\n\nclass Router implements Routes {\n  constructor(readonly resource: Resource) {}\n\n  get route(): Uri {\n    return meta(this.resource).get('route');\n  }\n\n  get middleware(): RequestHandler[] {\n    return meta(this.resource).get<RequestHandler[]>('middleware') ?? [];\n  }\n\n  get endpoints(): List<Route> {\n    return meta(this.resource)\n      .properties('verb')\n      .mapDefined(v =>\n        toRoute(\n          this.resource[v.property],\n          {\n            labCoat: v.get<boolean>('labCoat') ?? false,\n            token: v.get<boolean>('token') ?? false,\n            scope: v.get<Scope>('scope'),\n            uc: v.get<UseCase>('uc'),\n          },\n          v.get<Verb>('verb'),\n          v.get<RequestHandler[]>('middleware')\n        )\n      );\n  }\n}\n\nexport const routes = (resource: Resource): Routes => new Router(resource);\n"],"mappings":";AAAA,SAAe,MAAgB,aAAkB;AAO1C,MAAM,QACX,CAAC,QACD,CAAC,YAA2B;AAC1B,OAAK,OAAO,EAAE,IAAI,SAAS,GAAG;AAChC;AAOF,MAAM,UAAU,CAAC,UAAoB,UAAyB,MAAa,eACzE,MAAM,IAAI,EACP,GAAG,QAAQ,EACX,IAAI,CAAAA,WAAS,EAAE,MAAAA,OAAM,UAAU,UAAU,YAAY,cAAc,CAAC,EAAE,EAAW,EACjF,OAAO;AAEZ,MAAM,OAAyB;AAAA,EAC7B,YAAqB,UAAoB;AAApB;AAAA,EAAqB;AAAA,EAE1C,IAAI,QAAa;AACf,WAAO,KAAK,KAAK,QAAQ,EAAE,IAAI,OAAO;AAAA,EACxC;AAAA,EAEA,IAAI,aAA+B;AACjC,WAAO,KAAK,KAAK,QAAQ,EAAE,IAAsB,YAAY,KAAK,CAAC;AAAA,EACrE;AAAA,EAEA,IAAI,YAAyB;AAC3B,WAAO,KAAK,KAAK,QAAQ,EACtB,WAAW,MAAM,EACjB;AAAA,MAAW,OACV;AAAA,QACE,KAAK,SAAS,EAAE,QAAQ;AAAA,QACxB;AAAA,UACE,SAAS,EAAE,IAAa,SAAS,KAAK;AAAA,UACtC,OAAO,EAAE,IAAa,OAAO,KAAK;AAAA,UAClC,OAAO,EAAE,IAAW,OAAO;AAAA,UAC3B,IAAI,EAAE,IAAa,IAAI;AAAA,QACzB;AAAA,QACA,EAAE,IAAU,MAAM;AAAA,QAClB,EAAE,IAAsB,YAAY;AAAA,MACtC;AAAA,IACF;AAAA,EACJ;AACF;AAEO,MAAM,SAAS,CAAC,aAA+B,IAAI,OAAO,QAAQ;","names":["verb"]}
+{"version":3,"sources":["../../src/resources/Route.ts"],"sourcesContent":["import { List, meta, Optional, tryTo, Uri } from '../types';\nimport { Verb } from '../http';\nimport { Req } from './Req';\nimport { Resource } from './Resource';\nimport { Scope, UseCase } from '../process';\nimport { RequestHandler } from 'express';\n\nexport const route =\n  (uri: Uri): ClassDecorator =>\n  (subject: unknown): void => {\n    meta(subject).set('route', uri);\n  };\n\nexport type Endpoint<T = unknown> = (re: Req) => Promise<T | List<T>>;\nexport type RouteRequires = { token: boolean; labCoat: boolean; scope?: Scope; uc?: UseCase };\nexport type Route = { verb: Verb; endpoint: Endpoint; requires: RouteRequires; middleware: RequestHandler[] };\nexport type Routes = { route: Uri; middleware: RequestHandler[]; endpoints: List<Route> };\n\nconst toRoute = (endpoint: Endpoint, requires: RouteRequires, verb?: Verb, middleware?: RequestHandler[]): Optional<Route> =>\n  tryTo(verb)\n    .is.defined()\n    .map(verb => ({ verb, endpoint, requires, middleware: middleware ?? [] }) as Route)\n    .orElse();\n\nclass Router implements Routes {\n  constructor(readonly resource: Resource) {}\n\n  get route(): Uri {\n    return meta(this.resource).get('route');\n  }\n\n  get middleware(): RequestHandler[] {\n    return meta(this.resource).get<RequestHandler[]>('middleware') ?? [];\n  }\n\n  get endpoints(): List<Route> {\n    return meta(this.resource)\n      .properties('verb')\n      .mapDefined(v =>\n        toRoute(\n          this.resource[v.property],\n          {\n            labCoat: v.get<boolean>('labCoat') ?? false,\n            token: v.get<boolean>('token') ?? false,\n            scope: v.get<Scope>('scope'),\n            uc: v.get<UseCase>('uc'),\n          },\n          v.get<Verb>('verb'),\n          v.get<RequestHandler[]>('middleware')\n        )\n      );\n  }\n}\n\nexport const routes = (resource: Resource): Routes => new Router(resource);\n"],"mappings":";AAAA,SAAe,MAAgB,aAAkB;AAO1C,MAAM,QACX,CAAC,QACD,CAAC,YAA2B;AAC1B,OAAK,OAAO,EAAE,IAAI,SAAS,GAAG;AAChC;AAOF,MAAM,UAAU,CAAC,UAAoB,UAAyB,MAAa,eACzE,MAAM,IAAI,EACP,GAAG,QAAQ,EACX,IAAI,CAAAA,WAAS,EAAE,MAAAA,OAAM,UAAU,UAAU,YAAY,cAAc,CAAC,EAAE,EAAW,EACjF,OAAO;AAEZ,MAAM,OAAyB;AAAA,EAC7B,YAAqB,UAAoB;AAApB;AAAA,EAAqB;AAAA,EAE1C,IAAI,QAAa;AACf,WAAO,KAAK,KAAK,QAAQ,EAAE,IAAI,OAAO;AAAA,EACxC;AAAA,EAEA,IAAI,aAA+B;AACjC,WAAO,KAAK,KAAK,QAAQ,EAAE,IAAsB,YAAY,KAAK,CAAC;AAAA,EACrE;AAAA,EAEA,IAAI,YAAyB;AAC3B,WAAO,KAAK,KAAK,QAAQ,EACtB,WAAW,MAAM,EACjB;AAAA,MAAW,OACV;AAAA,QACE,KAAK,SAAS,EAAE,QAAQ;AAAA,QACxB;AAAA,UACE,SAAS,EAAE,IAAa,SAAS,KAAK;AAAA,UACtC,OAAO,EAAE,IAAa,OAAO,KAAK;AAAA,UAClC,OAAO,EAAE,IAAW,OAAO;AAAA,UAC3B,IAAI,EAAE,IAAa,IAAI;AAAA,QACzB;AAAA,QACA,EAAE,IAAU,MAAM;AAAA,QAClB,EAAE,IAAsB,YAAY;AAAA,MACtC;AAAA,IACF;AAAA,EACJ;AACF;AAEO,MAAM,SAAS,CAAC,aAA+B,IAAI,OAAO,QAAQ;","names":["verb"]}

package/dist/types/Parser.d.ts

@@ -0,0 +1,34 @@
+import { Get } from './Get';
+import { Constructor } from './Constructor';
+export declare class Parser<T, V> {
+    protected value: T;
+    protected f: Get<V, T>;
+    protected alt: Get<V, T>;
+    readonly valid: boolean;
+    if: {
+        empty: <U>(pred?: Get<U, T> | undefined) => this;
+        defined: <U_1>(pred?: Get<U_1, T> | undefined) => this;
+        valid: <U_2>(pred?: Get<U_2, T> | undefined) => this;
+        in: (...items: T[]) => this;
+        is: {
+            object: <U_3>(pred?: Get<U_3, T> | undefined) => this;
+            string: <U_4>(pred?: Get<U_4, T> | undefined) => this;
+            instance: <U_5>(c: Constructor<U_5>, pred?: Get<U_5, T> | undefined) => this;
+        };
+        not: {
+            empty: <U_6>(pred?: Get<U_6, T> | undefined) => this;
+            defined: <U_7>(pred?: Get<U_7, T> | undefined) => this;
+            valid: <U_8>(pred?: Get<U_8, T> | undefined) => this;
+            isObject: <U_9>(pred?: Get<U_9, T> | undefined) => this;
+            in: (...items: T[]) => this;
+            is: {
+                object: <U_10>(pred?: Get<U_10, T> | undefined) => this;
+                string: <U_11>(pred?: Get<U_11, T> | undefined) => this;
+                instance: <U_12>(c: Constructor<U_12>, pred?: Get<U_12, T> | undefined) => this;
+            };
+        };
+    };
+    constructor(value: T, f: Get<V, T>, alt: Get<V, T>, valid?: boolean);
+    protected evaluate<U>(meta: Get<boolean>, pred?: Get<U, T>): this;
+    protected evaluateNot<U>(meta: Get<boolean>, pred?: Get<U, T>): this;
+}

package/dist/types/Parser.js

@@ -0,0 +1,79 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var Parser_exports = {};
+__export(Parser_exports, {
+  Parser: () => Parser
+});
+module.exports = __toCommonJS(Parser_exports);
+var import_Get = require("./Get");
+var import_Is = require("./Is");
+var import_validation = require("../validation");
+var import_Array = require("./Array");
+class Parser {
+  constructor(value, f, alt, valid = true) {
+    this.value = value;
+    this.f = f;
+    this.alt = alt;
+    this.valid = valid;
+  }
+  if = {
+    empty: (pred) => this.evaluate(import_Is.isEmpty, pred),
+    defined: (pred) => this.evaluate(import_Is.isDefined, pred),
+    valid: (pred) => this.evaluate(import_validation.isValid, pred),
+    in: (...items) => this.evaluate(() => (0, import_Is.isIn)(this.value, (0, import_Array.toArray)(...items))),
+    is: {
+      object: (pred) => this.evaluate(import_Is.isObject, pred),
+      string: (pred) => this.evaluate(import_Is.isString, pred),
+      instance: (c, pred) => this.evaluate(() => this.value instanceof c, pred)
+    },
+    not: {
+      empty: (pred) => this.evaluateNot(import_Is.isEmpty, pred),
+      defined: (pred) => this.evaluateNot(import_Is.isDefined, pred),
+      valid: (pred) => this.evaluateNot(import_validation.isValid, pred),
+      isObject: (pred) => this.evaluateNot(import_Is.isObject, pred),
+      in: (...items) => this.evaluate(() => !(0, import_Is.isIn)(this.value, (0, import_Array.toArray)(...items))),
+      is: {
+        object: (pred) => this.evaluateNot(import_Is.isObject, pred),
+        string: (pred) => this.evaluateNot(import_Is.isString, pred),
+        instance: (c, pred) => this.evaluate(() => !(this.value instanceof c), pred)
+      }
+    }
+  };
+  evaluate(meta, pred) {
+    return new this.constructor(
+      this.value,
+      this.f,
+      this.alt,
+      (0, import_Get.ofGet)(meta, pred ? (0, import_Get.ofGet)(pred, this.value) : this.value)
+    );
+  }
+  evaluateNot(meta, pred) {
+    return new this.constructor(
+      this.value,
+      this.f,
+      this.alt,
+      !(0, import_Get.ofGet)(meta, pred ? (0, import_Get.ofGet)(pred, this.value) : this.value)
+    );
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Parser
+});
+//# sourceMappingURL=Parser.js.map

package/dist/types/Parser.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/types/Parser.ts"],"sourcesContent":["import { Get, ofGet } from './Get';\nimport { isDefined, isEmpty, isIn, isObject, isString } from './Is';\nimport { isValid } from '../validation';\nimport { Constructor } from './Constructor';\nimport { toArray } from './Array';\n\nexport class Parser<T, V> {\n  if = {\n    empty: <U>(pred?: Get<U, T>): this => this.evaluate(isEmpty, pred),\n    defined: <U>(pred?: Get<U, T>): this => this.evaluate(isDefined, pred),\n    valid: <U>(pred?: Get<U, T>): this => this.evaluate(isValid, pred),\n    in: (...items: T[]): this => this.evaluate(() => isIn(this.value, toArray(...items))),\n    is: {\n      object: <U>(pred?: Get<U, T>): this => this.evaluate(isObject, pred),\n      string: <U>(pred?: Get<U, T>): this => this.evaluate(isString, pred),\n      instance: <U>(c: Constructor<U>, pred?: Get<U, T>): this => this.evaluate(() => this.value instanceof c, pred),\n    },\n    not: {\n      empty: <U>(pred?: Get<U, T>): this => this.evaluateNot(isEmpty, pred),\n      defined: <U>(pred?: Get<U, T>): this => this.evaluateNot(isDefined, pred),\n      valid: <U>(pred?: Get<U, T>): this => this.evaluateNot(isValid, pred),\n      isObject: <U>(pred?: Get<U, T>): this => this.evaluateNot(isObject, pred),\n      in: (...items: T[]): this => this.evaluate(() => !isIn(this.value, toArray(...items))),\n      is: {\n        object: <U>(pred?: Get<U, T>): this => this.evaluateNot(isObject, pred),\n        string: <U>(pred?: Get<U, T>): this => this.evaluateNot(isString, pred),\n        instance: <U>(c: Constructor<U>, pred?: Get<U, T>): this => this.evaluate(() => !(this.value instanceof c), pred),\n      },\n    },\n  };\n\n  constructor(protected value: T, protected f: Get<V, T>, protected alt: Get<V, T>, readonly valid = true) {}\n\n  protected evaluate<U>(meta: Get<boolean>, pred?: Get<U, T>): this {\n    return new (this.constructor as new (value: T, f: Get<V, T>, alt: Get<V, T>, allow?: boolean) => this)(\n      this.value,\n      this.f,\n      this.alt,\n      ofGet(meta, pred ? ofGet(pred, this.value) : this.value)\n    );\n  }\n\n  protected evaluateNot<U>(meta: Get<boolean>, pred?: Get<U, T>): this {\n    return new (this.constructor as new (value: T, f: Get<V, T>, alt: Get<V, T>, allow?: boolean) => this)(\n      this.value,\n      this.f,\n      this.alt,\n      !ofGet(meta, pred ? ofGet(pred, this.value) : this.value)\n    );\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,iBAA2B;AAC3B,gBAA6D;AAC7D,wBAAwB;AAExB,mBAAwB;AAEjB,MAAM,OAAa;AAAA,EAyBxB,YAAsB,OAAoB,GAAwB,KAAyB,QAAQ,MAAM;AAAnF;AAAoB;AAAwB;AAAyB;AAAA,EAAe;AAAA,EAxB1G,KAAK;AAAA,IACH,OAAO,CAAI,SAA2B,KAAK,SAAS,mBAAS,IAAI;AAAA,IACjE,SAAS,CAAI,SAA2B,KAAK,SAAS,qBAAW,IAAI;AAAA,IACrE,OAAO,CAAI,SAA2B,KAAK,SAAS,2BAAS,IAAI;AAAA,IACjE,IAAI,IAAI,UAAqB,KAAK,SAAS,UAAM,gBAAK,KAAK,WAAO,sBAAQ,GAAG,KAAK,CAAC,CAAC;AAAA,IACpF,IAAI;AAAA,MACF,QAAQ,CAAI,SAA2B,KAAK,SAAS,oBAAU,IAAI;AAAA,MACnE,QAAQ,CAAI,SAA2B,KAAK,SAAS,oBAAU,IAAI;AAAA,MACnE,UAAU,CAAI,GAAmB,SAA2B,KAAK,SAAS,MAAM,KAAK,iBAAiB,GAAG,IAAI;AAAA,IAC/G;AAAA,IACA,KAAK;AAAA,MACH,OAAO,CAAI,SAA2B,KAAK,YAAY,mBAAS,IAAI;AAAA,MACpE,SAAS,CAAI,SAA2B,KAAK,YAAY,qBAAW,IAAI;AAAA,MACxE,OAAO,CAAI,SAA2B,KAAK,YAAY,2BAAS,IAAI;AAAA,MACpE,UAAU,CAAI,SAA2B,KAAK,YAAY,oBAAU,IAAI;AAAA,MACxE,IAAI,IAAI,UAAqB,KAAK,SAAS,MAAM,KAAC,gBAAK,KAAK,WAAO,sBAAQ,GAAG,KAAK,CAAC,CAAC;AAAA,MACrF,IAAI;AAAA,QACF,QAAQ,CAAI,SAA2B,KAAK,YAAY,oBAAU,IAAI;AAAA,QACtE,QAAQ,CAAI,SAA2B,KAAK,YAAY,oBAAU,IAAI;AAAA,QACtE,UAAU,CAAI,GAAmB,SAA2B,KAAK,SAAS,MAAM,EAAE,KAAK,iBAAiB,IAAI,IAAI;AAAA,MAClH;AAAA,IACF;AAAA,EACF;AAAA,EAIU,SAAY,MAAoB,MAAwB;AAChE,WAAO,IAAK,KAAK;AAAA,MACf,KAAK;AAAA,MACL,KAAK;AAAA,MACL,KAAK;AAAA,UACL,kBAAM,MAAM,WAAO,kBAAM,MAAM,KAAK,KAAK,IAAI,KAAK,KAAK;AAAA,IACzD;AAAA,EACF;AAAA,EAEU,YAAe,MAAoB,MAAwB;AACnE,WAAO,IAAK,KAAK;AAAA,MACf,KAAK;AAAA,MACL,KAAK;AAAA,MACL,KAAK;AAAA,MACL,KAAC,kBAAM,MAAM,WAAO,kBAAM,MAAM,KAAK,KAAK,IAAI,KAAK,KAAK;AAAA,IAC1D;AAAA,EACF;AACF;","names":[]}

package/dist/types/Parser.mjs

@@ -0,0 +1,56 @@
+import "../chunk-4N72FQFX.mjs";
+import { ofGet } from "./Get";
+import { isDefined, isEmpty, isIn, isObject, isString } from "./Is";
+import { isValid } from "../validation";
+import { toArray } from "./Array";
+class Parser {
+  constructor(value, f, alt, valid = true) {
+    this.value = value;
+    this.f = f;
+    this.alt = alt;
+    this.valid = valid;
+  }
+  if = {
+    empty: (pred) => this.evaluate(isEmpty, pred),
+    defined: (pred) => this.evaluate(isDefined, pred),
+    valid: (pred) => this.evaluate(isValid, pred),
+    in: (...items) => this.evaluate(() => isIn(this.value, toArray(...items))),
+    is: {
+      object: (pred) => this.evaluate(isObject, pred),
+      string: (pred) => this.evaluate(isString, pred),
+      instance: (c, pred) => this.evaluate(() => this.value instanceof c, pred)
+    },
+    not: {
+      empty: (pred) => this.evaluateNot(isEmpty, pred),
+      defined: (pred) => this.evaluateNot(isDefined, pred),
+      valid: (pred) => this.evaluateNot(isValid, pred),
+      isObject: (pred) => this.evaluateNot(isObject, pred),
+      in: (...items) => this.evaluate(() => !isIn(this.value, toArray(...items))),
+      is: {
+        object: (pred) => this.evaluateNot(isObject, pred),
+        string: (pred) => this.evaluateNot(isString, pred),
+        instance: (c, pred) => this.evaluate(() => !(this.value instanceof c), pred)
+      }
+    }
+  };
+  evaluate(meta, pred) {
+    return new this.constructor(
+      this.value,
+      this.f,
+      this.alt,
+      ofGet(meta, pred ? ofGet(pred, this.value) : this.value)
+    );
+  }
+  evaluateNot(meta, pred) {
+    return new this.constructor(
+      this.value,
+      this.f,
+      this.alt,
+      !ofGet(meta, pred ? ofGet(pred, this.value) : this.value)
+    );
+  }
+}
+export {
+  Parser
+};
+//# sourceMappingURL=Parser.mjs.map

package/dist/types/Parser.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/types/Parser.ts"],"sourcesContent":["import { Get, ofGet } from './Get';\nimport { isDefined, isEmpty, isIn, isObject, isString } from './Is';\nimport { isValid } from '../validation';\nimport { Constructor } from './Constructor';\nimport { toArray } from './Array';\n\nexport class Parser<T, V> {\n  if = {\n    empty: <U>(pred?: Get<U, T>): this => this.evaluate(isEmpty, pred),\n    defined: <U>(pred?: Get<U, T>): this => this.evaluate(isDefined, pred),\n    valid: <U>(pred?: Get<U, T>): this => this.evaluate(isValid, pred),\n    in: (...items: T[]): this => this.evaluate(() => isIn(this.value, toArray(...items))),\n    is: {\n      object: <U>(pred?: Get<U, T>): this => this.evaluate(isObject, pred),\n      string: <U>(pred?: Get<U, T>): this => this.evaluate(isString, pred),\n      instance: <U>(c: Constructor<U>, pred?: Get<U, T>): this => this.evaluate(() => this.value instanceof c, pred),\n    },\n    not: {\n      empty: <U>(pred?: Get<U, T>): this => this.evaluateNot(isEmpty, pred),\n      defined: <U>(pred?: Get<U, T>): this => this.evaluateNot(isDefined, pred),\n      valid: <U>(pred?: Get<U, T>): this => this.evaluateNot(isValid, pred),\n      isObject: <U>(pred?: Get<U, T>): this => this.evaluateNot(isObject, pred),\n      in: (...items: T[]): this => this.evaluate(() => !isIn(this.value, toArray(...items))),\n      is: {\n        object: <U>(pred?: Get<U, T>): this => this.evaluateNot(isObject, pred),\n        string: <U>(pred?: Get<U, T>): this => this.evaluateNot(isString, pred),\n        instance: <U>(c: Constructor<U>, pred?: Get<U, T>): this => this.evaluate(() => !(this.value instanceof c), pred),\n      },\n    },\n  };\n\n  constructor(protected value: T, protected f: Get<V, T>, protected alt: Get<V, T>, readonly valid = true) {}\n\n  protected evaluate<U>(meta: Get<boolean>, pred?: Get<U, T>): this {\n    return new (this.constructor as new (value: T, f: Get<V, T>, alt: Get<V, T>, allow?: boolean) => this)(\n      this.value,\n      this.f,\n      this.alt,\n      ofGet(meta, pred ? ofGet(pred, this.value) : this.value)\n    );\n  }\n\n  protected evaluateNot<U>(meta: Get<boolean>, pred?: Get<U, T>): this {\n    return new (this.constructor as new (value: T, f: Get<V, T>, alt: Get<V, T>, allow?: boolean) => this)(\n      this.value,\n      this.f,\n      this.alt,\n      !ofGet(meta, pred ? ofGet(pred, this.value) : this.value)\n    );\n  }\n}\n"],"mappings":";AAAA,SAAc,aAAa;AAC3B,SAAS,WAAW,SAAS,MAAM,UAAU,gBAAgB;AAC7D,SAAS,eAAe;AAExB,SAAS,eAAe;AAEjB,MAAM,OAAa;AAAA,EAyBxB,YAAsB,OAAoB,GAAwB,KAAyB,QAAQ,MAAM;AAAnF;AAAoB;AAAwB;AAAyB;AAAA,EAAe;AAAA,EAxB1G,KAAK;AAAA,IACH,OAAO,CAAI,SAA2B,KAAK,SAAS,SAAS,IAAI;AAAA,IACjE,SAAS,CAAI,SAA2B,KAAK,SAAS,WAAW,IAAI;AAAA,IACrE,OAAO,CAAI,SAA2B,KAAK,SAAS,SAAS,IAAI;AAAA,IACjE,IAAI,IAAI,UAAqB,KAAK,SAAS,MAAM,KAAK,KAAK,OAAO,QAAQ,GAAG,KAAK,CAAC,CAAC;AAAA,IACpF,IAAI;AAAA,MACF,QAAQ,CAAI,SAA2B,KAAK,SAAS,UAAU,IAAI;AAAA,MACnE,QAAQ,CAAI,SAA2B,KAAK,SAAS,UAAU,IAAI;AAAA,MACnE,UAAU,CAAI,GAAmB,SAA2B,KAAK,SAAS,MAAM,KAAK,iBAAiB,GAAG,IAAI;AAAA,IAC/G;AAAA,IACA,KAAK;AAAA,MACH,OAAO,CAAI,SAA2B,KAAK,YAAY,SAAS,IAAI;AAAA,MACpE,SAAS,CAAI,SAA2B,KAAK,YAAY,WAAW,IAAI;AAAA,MACxE,OAAO,CAAI,SAA2B,KAAK,YAAY,SAAS,IAAI;AAAA,MACpE,UAAU,CAAI,SAA2B,KAAK,YAAY,UAAU,IAAI;AAAA,MACxE,IAAI,IAAI,UAAqB,KAAK,SAAS,MAAM,CAAC,KAAK,KAAK,OAAO,QAAQ,GAAG,KAAK,CAAC,CAAC;AAAA,MACrF,IAAI;AAAA,QACF,QAAQ,CAAI,SAA2B,KAAK,YAAY,UAAU,IAAI;AAAA,QACtE,QAAQ,CAAI,SAA2B,KAAK,YAAY,UAAU,IAAI;AAAA,QACtE,UAAU,CAAI,GAAmB,SAA2B,KAAK,SAAS,MAAM,EAAE,KAAK,iBAAiB,IAAI,IAAI;AAAA,MAClH;AAAA,IACF;AAAA,EACF;AAAA,EAIU,SAAY,MAAoB,MAAwB;AAChE,WAAO,IAAK,KAAK;AAAA,MACf,KAAK;AAAA,MACL,KAAK;AAAA,MACL,KAAK;AAAA,MACL,MAAM,MAAM,OAAO,MAAM,MAAM,KAAK,KAAK,IAAI,KAAK,KAAK;AAAA,IACzD;AAAA,EACF;AAAA,EAEU,YAAe,MAAoB,MAAwB;AACnE,WAAO,IAAK,KAAK;AAAA,MACf,KAAK;AAAA,MACL,KAAK;AAAA,MACL,KAAK;AAAA,MACL,CAAC,MAAM,MAAM,OAAO,MAAM,MAAM,KAAK,KAAK,IAAI,KAAK,KAAK;AAAA,IAC1D;AAAA,EACF;AACF;","names":[]}

package/dist/types/index.d.ts

@@ -25,6 +25,7 @@ export * from './Meta';
 export * from './Nullish';
 export * from './Number';
 export * from './PageList';
+export * from './Parser';
 export * from './Primitive';
 export * from './Repository';
 export * from './Result';

package/dist/types/index.js

@@ -42,6 +42,7 @@ __reExport(types_exports, require("./Meta"), module.exports);
 __reExport(types_exports, require("./Nullish"), module.exports);
 __reExport(types_exports, require("./Number"), module.exports);
 __reExport(types_exports, require("./PageList"), module.exports);
+__reExport(types_exports, require("./Parser"), module.exports);
 __reExport(types_exports, require("./Primitive"), module.exports);
 __reExport(types_exports, require("./Repository"), module.exports);
 __reExport(types_exports, require("./Result"), module.exports);
@@ -86,6 +87,7 @@ __reExport(types_exports, require("./Value"), module.exports);
   ...require("./Nullish"),
   ...require("./Number"),
   ...require("./PageList"),
+  ...require("./Parser"),
   ...require("./Primitive"),
   ...require("./Repository"),
   ...require("./Result"),

package/dist/types/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/types/index.ts"],"sourcesContent":["export * from './Array';\nexport * from './Builder';\nexport * from './Cache';\nexport * from './CacheAge';\nexport * from './Case';\nexport * from './Constructor';\nexport * from './Context';\nexport * from './Enum';\nexport * from './ErrorOrigin';\nexport * from './Exception';\nexport * from './Falsy';\nexport * from './Func';\nexport * from './Gateway';\nexport * from './Get';\nexport * from './Id';\nexport * from './Identity';\nexport * from './Is';\nexport * from './IsA';\nexport * from './IsDate';\nexport * from './IsEqual';\nexport * from './Json';\nexport * from './List';\nexport * from './Message';\nexport * from './Meta';\nexport * from './Nullish';\nexport * from './Number';\nexport * from './PageList';\nexport * from './Primitive';\nexport * from './Repository';\nexport * from './Result';\nexport * from './Results';\nexport * from './Sort';\nexport * from './Tag';\nexport * from './Template';\nexport * from './Text';\nexport * from './Try';\nexport * from './TypeGuard';\nexport * from './Types';\nexport * from './Uri';\nexport * from './Uuid';\nexport * from './Validatable';\nexport * from './Value';\n"],"mappings":";;;;;;;;;;;;;;;AAAA;AAAA;AAAA,0BAAc,oBAAd;AACA,0BAAc,sBADd;AAEA,0BAAc,oBAFd;AAGA,0BAAc,uBAHd;AAIA,0BAAc,mBAJd;AAKA,0BAAc,0BALd;AAMA,0BAAc,sBANd;AAOA,0BAAc,mBAPd;AAQA,0BAAc,0BARd;AASA,0BAAc,wBATd;AAUA,0BAAc,oBAVd;AAWA,0BAAc,mBAXd;AAYA,0BAAc,sBAZd;AAaA,0BAAc,kBAbd;AAcA,0BAAc,iBAdd;AAeA,0BAAc,uBAfd;AAgBA,0BAAc,iBAhBd;AAiBA,0BAAc,kBAjBd;AAkBA,0BAAc,qBAlBd;AAmBA,0BAAc,sBAnBd;AAoBA,0BAAc,mBApBd;AAqBA,0BAAc,mBArBd;AAsBA,0BAAc,sBAtBd;AAuBA,0BAAc,mBAvBd;AAwBA,0BAAc,sBAxBd;AAyBA,0BAAc,qBAzBd;AA0BA,0BAAc,uBA1Bd;AA2BA,0BAAc,wBA3Bd;AA4BA,0BAAc,yBA5Bd;AA6BA,0BAAc,qBA7Bd;AA8BA,0BAAc,sBA9Bd;AA+BA,0BAAc,mBA/Bd;AAgCA,0BAAc,kBAhCd;AAiCA,0BAAc,uBAjCd;AAkCA,0BAAc,mBAlCd;AAmCA,0BAAc,kBAnCd;AAoCA,0BAAc,wBApCd;AAqCA,0BAAc,oBArCd;AAsCA,0BAAc,kBAtCd;AAuCA,0BAAc,mBAvCd;AAwCA,0BAAc,0BAxCd;AAyCA,0BAAc,oBAzCd;","names":[]}
+{"version":3,"sources":["../../src/types/index.ts"],"sourcesContent":["export * from './Array';\nexport * from './Builder';\nexport * from './Cache';\nexport * from './CacheAge';\nexport * from './Case';\nexport * from './Constructor';\nexport * from './Context';\nexport * from './Enum';\nexport * from './ErrorOrigin';\nexport * from './Exception';\nexport * from './Falsy';\nexport * from './Func';\nexport * from './Gateway';\nexport * from './Get';\nexport * from './Id';\nexport * from './Identity';\nexport * from './Is';\nexport * from './IsA';\nexport * from './IsDate';\nexport * from './IsEqual';\nexport * from './Json';\nexport * from './List';\nexport * from './Message';\nexport * from './Meta';\nexport * from './Nullish';\nexport * from './Number';\nexport * from './PageList';\nexport * from './Parser';\nexport * from './Primitive';\nexport * from './Repository';\nexport * from './Result';\nexport * from './Results';\nexport * from './Sort';\nexport * from './Tag';\nexport * from './Template';\nexport * from './Text';\nexport * from './Try';\nexport * from './TypeGuard';\nexport * from './Types';\nexport * from './Uri';\nexport * from './Uuid';\nexport * from './Validatable';\nexport * from './Value';\n"],"mappings":";;;;;;;;;;;;;;;AAAA;AAAA;AAAA,0BAAc,oBAAd;AACA,0BAAc,sBADd;AAEA,0BAAc,oBAFd;AAGA,0BAAc,uBAHd;AAIA,0BAAc,mBAJd;AAKA,0BAAc,0BALd;AAMA,0BAAc,sBANd;AAOA,0BAAc,mBAPd;AAQA,0BAAc,0BARd;AASA,0BAAc,wBATd;AAUA,0BAAc,oBAVd;AAWA,0BAAc,mBAXd;AAYA,0BAAc,sBAZd;AAaA,0BAAc,kBAbd;AAcA,0BAAc,iBAdd;AAeA,0BAAc,uBAfd;AAgBA,0BAAc,iBAhBd;AAiBA,0BAAc,kBAjBd;AAkBA,0BAAc,qBAlBd;AAmBA,0BAAc,sBAnBd;AAoBA,0BAAc,mBApBd;AAqBA,0BAAc,mBArBd;AAsBA,0BAAc,sBAtBd;AAuBA,0BAAc,mBAvBd;AAwBA,0BAAc,sBAxBd;AAyBA,0BAAc,qBAzBd;AA0BA,0BAAc,uBA1Bd;AA2BA,0BAAc,qBA3Bd;AA4BA,0BAAc,wBA5Bd;AA6BA,0BAAc,yBA7Bd;AA8BA,0BAAc,qBA9Bd;AA+BA,0BAAc,sBA/Bd;AAgCA,0BAAc,mBAhCd;AAiCA,0BAAc,kBAjCd;AAkCA,0BAAc,uBAlCd;AAmCA,0BAAc,mBAnCd;AAoCA,0BAAc,kBApCd;AAqCA,0BAAc,wBArCd;AAsCA,0BAAc,oBAtCd;AAuCA,0BAAc,kBAvCd;AAwCA,0BAAc,mBAxCd;AAyCA,0BAAc,0BAzCd;AA0CA,0BAAc,oBA1Cd;","names":[]}

package/dist/types/index.mjs

@@ -25,6 +25,7 @@ export * from "./Meta";
 export * from "./Nullish";
 export * from "./Number";
 export * from "./PageList";
+export * from "./Parser";
 export * from "./Primitive";
 export * from "./Repository";
 export * from "./Result";

package/dist/types/index.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/types/index.ts"],"sourcesContent":["export * from './Array';\nexport * from './Builder';\nexport * from './Cache';\nexport * from './CacheAge';\nexport * from './Case';\nexport * from './Constructor';\nexport * from './Context';\nexport * from './Enum';\nexport * from './ErrorOrigin';\nexport * from './Exception';\nexport * from './Falsy';\nexport * from './Func';\nexport * from './Gateway';\nexport * from './Get';\nexport * from './Id';\nexport * from './Identity';\nexport * from './Is';\nexport * from './IsA';\nexport * from './IsDate';\nexport * from './IsEqual';\nexport * from './Json';\nexport * from './List';\nexport * from './Message';\nexport * from './Meta';\nexport * from './Nullish';\nexport * from './Number';\nexport * from './PageList';\nexport * from './Primitive';\nexport * from './Repository';\nexport * from './Result';\nexport * from './Results';\nexport * from './Sort';\nexport * from './Tag';\nexport * from './Template';\nexport * from './Text';\nexport * from './Try';\nexport * from './TypeGuard';\nexport * from './Types';\nexport * from './Uri';\nexport * from './Uuid';\nexport * from './Validatable';\nexport * from './Value';\n"],"mappings":"AAAA,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;","names":[]}
+{"version":3,"sources":["../../src/types/index.ts"],"sourcesContent":["export * from './Array';\nexport * from './Builder';\nexport * from './Cache';\nexport * from './CacheAge';\nexport * from './Case';\nexport * from './Constructor';\nexport * from './Context';\nexport * from './Enum';\nexport * from './ErrorOrigin';\nexport * from './Exception';\nexport * from './Falsy';\nexport * from './Func';\nexport * from './Gateway';\nexport * from './Get';\nexport * from './Id';\nexport * from './Identity';\nexport * from './Is';\nexport * from './IsA';\nexport * from './IsDate';\nexport * from './IsEqual';\nexport * from './Json';\nexport * from './List';\nexport * from './Message';\nexport * from './Meta';\nexport * from './Nullish';\nexport * from './Number';\nexport * from './PageList';\nexport * from './Parser';\nexport * from './Primitive';\nexport * from './Repository';\nexport * from './Result';\nexport * from './Results';\nexport * from './Sort';\nexport * from './Tag';\nexport * from './Template';\nexport * from './Text';\nexport * from './Try';\nexport * from './TypeGuard';\nexport * from './Types';\nexport * from './Uri';\nexport * from './Uuid';\nexport * from './Validatable';\nexport * from './Value';\n"],"mappings":"AAAA,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;","names":[]}

package/dist/validation/Validate.d.ts

@@ -9,3 +9,4 @@ export type Validator = {
 export declare const asResults: (subject: unknown, template: Text, options?: TemplateOptions) => Results;
 export declare const validate: (subject?: unknown) => Results;
 export declare const validateReject: <T>(subject: T) => Promise<T>;
+export declare const isValid: <T>(t: T) => boolean;

package/dist/validation/Validate.js

@@ -19,6 +19,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var Validate_exports = {};
 __export(Validate_exports, {
   asResults: () => asResults,
+  isValid: () => isValid,
   validate: () => validate,
   validateReject: () => validateReject
 });
@@ -34,9 +35,11 @@ const validate = (subject) => (0, import_types.choose)(subject).is.not.defined(
   () => (0, import_types.toResults)("Subject is not defined.")
 ).type(import_types.isEnum, (e) => e.isValid ? (0, import_types.toResults)() : asResults(e, "This is not a valid {type}.")).type(import_types.isValue, (v) => v.isValid ? (0, import_types.toResults)() : asResults(v, "This is not a valid {type}.")).type(import_types.isArray, (a) => a.map((i) => validate(i)).reduce((rs, r) => rs.add(...r.results), (0, import_types.toResults)())).type(import_types.isValidatable, (v) => constraints(v)).else((0, import_types.toResults)());
 const validateReject = (subject) => (0, import_When.when)(subject).not.isValid.reject();
+const isValid = (t) => validate(t).isValid;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   asResults,
+  isValid,
   validate,
   validateReject
 });

package/dist/validation/Validate.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/validation/Validate.ts"],"sourcesContent":["import {\n  asString,\n  choose,\n  isArray,\n  isEnum,\n  isFunction,\n  isResults,\n  isValidatable,\n  isValue,\n  List,\n  meta,\n  Results,\n  TemplateOptions,\n  text,\n  Text,\n  toList,\n  toName,\n  toResult,\n  toResults,\n  tryTo,\n} from '../types';\nimport { Constraint } from './Contraints';\nimport { when } from './When';\n\nexport type Validator = { property: string | symbol; constraint: Constraint; text: Text; actual?: Text };\n\nexport const asResults = (subject: unknown, template: Text, options: TemplateOptions = {}): Results =>\n  toResults(toResult(text(template).parse(subject, options), toName(subject)));\n\nconst validators = (subject: unknown): List<Validator> =>\n  meta(subject)\n    .keys<List<Validator>>('constraint')\n    .reduce((list, vs) => list.add(vs), toList<Validator>());\n\nconst runValidator = (v: Validator, subject?: unknown): Results =>\n  tryTo(() => (isFunction((subject as any)[v.property]) ? (subject as any)[v.property]() : (subject as any)[v.property]))\n    .map(actual => [actual, v.constraint(actual)])\n    .map(([actual, res]) => (isResults(res) ? res : !res ? asResults(subject, v.text, { ...v, actual }) : toResults()))\n    .recover(e => asResults(subject, asString(e))).value;\n\nconst constraints = (subject?: unknown): Results =>\n  tryTo(() => validators(subject))\n    .map(vs => vs.mapDefined(v => runValidator(v, subject)))\n    .map(res => res.reduce((rs, r) => rs.add(...r.results), toResults())).value;\n\nexport const validate = (subject?: unknown): Results =>\n  choose(subject)\n    .is.not.defined(\n      s => s,\n      () => toResults('Subject is not defined.')\n    )\n    .type(isEnum, e => (e.isValid ? toResults() : asResults(e, 'This is not a valid {type}.')))\n    .type(isValue, v => (v.isValid ? toResults() : asResults(v, 'This is not a valid {type}.')))\n    .type(isArray, a => a.map(i => validate(i)).reduce((rs, r) => rs.add(...r.results), toResults()))\n    .type(isValidatable, v => constraints(v))\n    .else(toResults());\n\nexport const validateReject = <T>(subject: T): Promise<T> => when(subject).not.isValid.reject();\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAoBO;AAEP,kBAAqB;AAId,MAAM,YAAY,CAAC,SAAkB,UAAgB,UAA2B,CAAC,UACtF,4BAAU,2BAAS,mBAAK,QAAQ,EAAE,MAAM,SAAS,OAAO,OAAG,qBAAO,OAAO,CAAC,CAAC;AAE7E,MAAM,aAAa,CAAC,gBAClB,mBAAK,OAAO,EACT,KAAsB,YAAY,EAClC,OAAO,CAAC,MAAM,OAAO,KAAK,IAAI,EAAE,OAAG,qBAAkB,CAAC;AAE3D,MAAM,eAAe,CAAC,GAAc,gBAClC,oBAAM,UAAO,yBAAY,QAAgB,EAAE,QAAQ,CAAC,IAAK,QAAgB,EAAE,QAAQ,EAAE,IAAK,QAAgB,EAAE,QAAQ,CAAE,EACnH,IAAI,YAAU,CAAC,QAAQ,EAAE,WAAW,MAAM,CAAC,CAAC,EAC5C,IAAI,CAAC,CAAC,QAAQ,GAAG,UAAO,wBAAU,GAAG,IAAI,MAAM,CAAC,MAAM,UAAU,SAAS,EAAE,MAAM,EAAE,GAAG,GAAG,OAAO,CAAC,QAAI,wBAAU,CAAE,EACjH,QAAQ,OAAK,UAAU,aAAS,uBAAS,CAAC,CAAC,CAAC,EAAE;AAEnD,MAAM,cAAc,CAAC,gBACnB,oBAAM,MAAM,WAAW,OAAO,CAAC,EAC5B,IAAI,QAAM,GAAG,WAAW,OAAK,aAAa,GAAG,OAAO,CAAC,CAAC,EACtD,IAAI,SAAO,IAAI,OAAO,CAAC,IAAI,MAAM,GAAG,IAAI,GAAG,EAAE,OAAO,OAAG,wBAAU,CAAC,CAAC,EAAE;AAEnE,MAAM,WAAW,CAAC,gBACvB,qBAAO,OAAO,EACX,GAAG,IAAI;AAAA,EACN,OAAK;AAAA,EACL,UAAM,wBAAU,yBAAyB;AAC3C,EACC,KAAK,qBAAQ,OAAM,EAAE,cAAU,wBAAU,IAAI,UAAU,GAAG,6BAA6B,CAAE,EACzF,KAAK,sBAAS,OAAM,EAAE,cAAU,wBAAU,IAAI,UAAU,GAAG,6BAA6B,CAAE,EAC1F,KAAK,sBAAS,OAAK,EAAE,IAAI,OAAK,SAAS,CAAC,CAAC,EAAE,OAAO,CAAC,IAAI,MAAM,GAAG,IAAI,GAAG,EAAE,OAAO,OAAG,wBAAU,CAAC,CAAC,EAC/F,KAAK,4BAAe,OAAK,YAAY,CAAC,CAAC,EACvC,SAAK,wBAAU,CAAC;AAEd,MAAM,iBAAiB,CAAI,gBAA2B,kBAAK,OAAO,EAAE,IAAI,QAAQ,OAAO;","names":[]}
+{"version":3,"sources":["../../src/validation/Validate.ts"],"sourcesContent":["import {\n  asString,\n  choose,\n  isArray,\n  isEnum,\n  isFunction,\n  isResults,\n  isValidatable,\n  isValue,\n  List,\n  meta,\n  Results,\n  TemplateOptions,\n  text,\n  Text,\n  toList,\n  toName,\n  toResult,\n  toResults,\n  tryTo,\n} from '../types';\nimport { Constraint } from './Contraints';\nimport { when } from './When';\n\nexport type Validator = { property: string | symbol; constraint: Constraint; text: Text; actual?: Text };\n\nexport const asResults = (subject: unknown, template: Text, options: TemplateOptions = {}): Results =>\n  toResults(toResult(text(template).parse(subject, options), toName(subject)));\n\nconst validators = (subject: unknown): List<Validator> =>\n  meta(subject)\n    .keys<List<Validator>>('constraint')\n    .reduce((list, vs) => list.add(vs), toList<Validator>());\n\nconst runValidator = (v: Validator, subject?: unknown): Results =>\n  tryTo(() => (isFunction((subject as any)[v.property]) ? (subject as any)[v.property]() : (subject as any)[v.property]))\n    .map(actual => [actual, v.constraint(actual)])\n    .map(([actual, res]) => (isResults(res) ? res : !res ? asResults(subject, v.text, { ...v, actual }) : toResults()))\n    .recover(e => asResults(subject, asString(e))).value;\n\nconst constraints = (subject?: unknown): Results =>\n  tryTo(() => validators(subject))\n    .map(vs => vs.mapDefined(v => runValidator(v, subject)))\n    .map(res => res.reduce((rs, r) => rs.add(...r.results), toResults())).value;\n\nexport const validate = (subject?: unknown): Results =>\n  choose(subject)\n    .is.not.defined(\n      s => s,\n      () => toResults('Subject is not defined.')\n    )\n    .type(isEnum, e => (e.isValid ? toResults() : asResults(e, 'This is not a valid {type}.')))\n    .type(isValue, v => (v.isValid ? toResults() : asResults(v, 'This is not a valid {type}.')))\n    .type(isArray, a => a.map(i => validate(i)).reduce((rs, r) => rs.add(...r.results), toResults()))\n    .type(isValidatable, v => constraints(v))\n    .else(toResults());\n\nexport const validateReject = <T>(subject: T): Promise<T> => when(subject).not.isValid.reject();\n\nexport const isValid = <T>(t: T): boolean => validate(t).isValid;\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAoBO;AAEP,kBAAqB;AAId,MAAM,YAAY,CAAC,SAAkB,UAAgB,UAA2B,CAAC,UACtF,4BAAU,2BAAS,mBAAK,QAAQ,EAAE,MAAM,SAAS,OAAO,OAAG,qBAAO,OAAO,CAAC,CAAC;AAE7E,MAAM,aAAa,CAAC,gBAClB,mBAAK,OAAO,EACT,KAAsB,YAAY,EAClC,OAAO,CAAC,MAAM,OAAO,KAAK,IAAI,EAAE,OAAG,qBAAkB,CAAC;AAE3D,MAAM,eAAe,CAAC,GAAc,gBAClC,oBAAM,UAAO,yBAAY,QAAgB,EAAE,QAAQ,CAAC,IAAK,QAAgB,EAAE,QAAQ,EAAE,IAAK,QAAgB,EAAE,QAAQ,CAAE,EACnH,IAAI,YAAU,CAAC,QAAQ,EAAE,WAAW,MAAM,CAAC,CAAC,EAC5C,IAAI,CAAC,CAAC,QAAQ,GAAG,UAAO,wBAAU,GAAG,IAAI,MAAM,CAAC,MAAM,UAAU,SAAS,EAAE,MAAM,EAAE,GAAG,GAAG,OAAO,CAAC,QAAI,wBAAU,CAAE,EACjH,QAAQ,OAAK,UAAU,aAAS,uBAAS,CAAC,CAAC,CAAC,EAAE;AAEnD,MAAM,cAAc,CAAC,gBACnB,oBAAM,MAAM,WAAW,OAAO,CAAC,EAC5B,IAAI,QAAM,GAAG,WAAW,OAAK,aAAa,GAAG,OAAO,CAAC,CAAC,EACtD,IAAI,SAAO,IAAI,OAAO,CAAC,IAAI,MAAM,GAAG,IAAI,GAAG,EAAE,OAAO,OAAG,wBAAU,CAAC,CAAC,EAAE;AAEnE,MAAM,WAAW,CAAC,gBACvB,qBAAO,OAAO,EACX,GAAG,IAAI;AAAA,EACN,OAAK;AAAA,EACL,UAAM,wBAAU,yBAAyB;AAC3C,EACC,KAAK,qBAAQ,OAAM,EAAE,cAAU,wBAAU,IAAI,UAAU,GAAG,6BAA6B,CAAE,EACzF,KAAK,sBAAS,OAAM,EAAE,cAAU,wBAAU,IAAI,UAAU,GAAG,6BAA6B,CAAE,EAC1F,KAAK,sBAAS,OAAK,EAAE,IAAI,OAAK,SAAS,CAAC,CAAC,EAAE,OAAO,CAAC,IAAI,MAAM,GAAG,IAAI,GAAG,EAAE,OAAO,OAAG,wBAAU,CAAC,CAAC,EAC/F,KAAK,4BAAe,OAAK,YAAY,CAAC,CAAC,EACvC,SAAK,wBAAU,CAAC;AAEd,MAAM,iBAAiB,CAAI,gBAA2B,kBAAK,OAAO,EAAE,IAAI,QAAQ,OAAO;AAEvF,MAAM,UAAU,CAAI,MAAkB,SAAS,CAAC,EAAE;","names":[]}

package/dist/validation/Validate.mjs

@@ -26,8 +26,10 @@ const validate = (subject) => choose(subject).is.not.defined(
   () => toResults("Subject is not defined.")
 ).type(isEnum, (e) => e.isValid ? toResults() : asResults(e, "This is not a valid {type}.")).type(isValue, (v) => v.isValid ? toResults() : asResults(v, "This is not a valid {type}.")).type(isArray, (a) => a.map((i) => validate(i)).reduce((rs, r) => rs.add(...r.results), toResults())).type(isValidatable, (v) => constraints(v)).else(toResults());
 const validateReject = (subject) => when(subject).not.isValid.reject();
+const isValid = (t) => validate(t).isValid;
 export {
   asResults,
+  isValid,
   validate,
   validateReject
 };

package/dist/validation/Validate.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/validation/Validate.ts"],"sourcesContent":["import {\n  asString,\n  choose,\n  isArray,\n  isEnum,\n  isFunction,\n  isResults,\n  isValidatable,\n  isValue,\n  List,\n  meta,\n  Results,\n  TemplateOptions,\n  text,\n  Text,\n  toList,\n  toName,\n  toResult,\n  toResults,\n  tryTo,\n} from '../types';\nimport { Constraint } from './Contraints';\nimport { when } from './When';\n\nexport type Validator = { property: string | symbol; constraint: Constraint; text: Text; actual?: Text };\n\nexport const asResults = (subject: unknown, template: Text, options: TemplateOptions = {}): Results =>\n  toResults(toResult(text(template).parse(subject, options), toName(subject)));\n\nconst validators = (subject: unknown): List<Validator> =>\n  meta(subject)\n    .keys<List<Validator>>('constraint')\n    .reduce((list, vs) => list.add(vs), toList<Validator>());\n\nconst runValidator = (v: Validator, subject?: unknown): Results =>\n  tryTo(() => (isFunction((subject as any)[v.property]) ? (subject as any)[v.property]() : (subject as any)[v.property]))\n    .map(actual => [actual, v.constraint(actual)])\n    .map(([actual, res]) => (isResults(res) ? res : !res ? asResults(subject, v.text, { ...v, actual }) : toResults()))\n    .recover(e => asResults(subject, asString(e))).value;\n\nconst constraints = (subject?: unknown): Results =>\n  tryTo(() => validators(subject))\n    .map(vs => vs.mapDefined(v => runValidator(v, subject)))\n    .map(res => res.reduce((rs, r) => rs.add(...r.results), toResults())).value;\n\nexport const validate = (subject?: unknown): Results =>\n  choose(subject)\n    .is.not.defined(\n      s => s,\n      () => toResults('Subject is not defined.')\n    )\n    .type(isEnum, e => (e.isValid ? toResults() : asResults(e, 'This is not a valid {type}.')))\n    .type(isValue, v => (v.isValid ? toResults() : asResults(v, 'This is not a valid {type}.')))\n    .type(isArray, a => a.map(i => validate(i)).reduce((rs, r) => rs.add(...r.results), toResults()))\n    .type(isValidatable, v => constraints(v))\n    .else(toResults());\n\nexport const validateReject = <T>(subject: T): Promise<T> => when(subject).not.isValid.reject();\n"],"mappings":";AAAA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EAEA;AAAA,EAGA;AAAA,EAEA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAEP,SAAS,YAAY;AAId,MAAM,YAAY,CAAC,SAAkB,UAAgB,UAA2B,CAAC,MACtF,UAAU,SAAS,KAAK,QAAQ,EAAE,MAAM,SAAS,OAAO,GAAG,OAAO,OAAO,CAAC,CAAC;AAE7E,MAAM,aAAa,CAAC,YAClB,KAAK,OAAO,EACT,KAAsB,YAAY,EAClC,OAAO,CAAC,MAAM,OAAO,KAAK,IAAI,EAAE,GAAG,OAAkB,CAAC;AAE3D,MAAM,eAAe,CAAC,GAAc,YAClC,MAAM,MAAO,WAAY,QAAgB,EAAE,QAAQ,CAAC,IAAK,QAAgB,EAAE,QAAQ,EAAE,IAAK,QAAgB,EAAE,QAAQ,CAAE,EACnH,IAAI,YAAU,CAAC,QAAQ,EAAE,WAAW,MAAM,CAAC,CAAC,EAC5C,IAAI,CAAC,CAAC,QAAQ,GAAG,MAAO,UAAU,GAAG,IAAI,MAAM,CAAC,MAAM,UAAU,SAAS,EAAE,MAAM,EAAE,GAAG,GAAG,OAAO,CAAC,IAAI,UAAU,CAAE,EACjH,QAAQ,OAAK,UAAU,SAAS,SAAS,CAAC,CAAC,CAAC,EAAE;AAEnD,MAAM,cAAc,CAAC,YACnB,MAAM,MAAM,WAAW,OAAO,CAAC,EAC5B,IAAI,QAAM,GAAG,WAAW,OAAK,aAAa,GAAG,OAAO,CAAC,CAAC,EACtD,IAAI,SAAO,IAAI,OAAO,CAAC,IAAI,MAAM,GAAG,IAAI,GAAG,EAAE,OAAO,GAAG,UAAU,CAAC,CAAC,EAAE;AAEnE,MAAM,WAAW,CAAC,YACvB,OAAO,OAAO,EACX,GAAG,IAAI;AAAA,EACN,OAAK;AAAA,EACL,MAAM,UAAU,yBAAyB;AAC3C,EACC,KAAK,QAAQ,OAAM,EAAE,UAAU,UAAU,IAAI,UAAU,GAAG,6BAA6B,CAAE,EACzF,KAAK,SAAS,OAAM,EAAE,UAAU,UAAU,IAAI,UAAU,GAAG,6BAA6B,CAAE,EAC1F,KAAK,SAAS,OAAK,EAAE,IAAI,OAAK,SAAS,CAAC,CAAC,EAAE,OAAO,CAAC,IAAI,MAAM,GAAG,IAAI,GAAG,EAAE,OAAO,GAAG,UAAU,CAAC,CAAC,EAC/F,KAAK,eAAe,OAAK,YAAY,CAAC,CAAC,EACvC,KAAK,UAAU,CAAC;AAEd,MAAM,iBAAiB,CAAI,YAA2B,KAAK,OAAO,EAAE,IAAI,QAAQ,OAAO;","names":[]}
+{"version":3,"sources":["../../src/validation/Validate.ts"],"sourcesContent":["import {\n  asString,\n  choose,\n  isArray,\n  isEnum,\n  isFunction,\n  isResults,\n  isValidatable,\n  isValue,\n  List,\n  meta,\n  Results,\n  TemplateOptions,\n  text,\n  Text,\n  toList,\n  toName,\n  toResult,\n  toResults,\n  tryTo,\n} from '../types';\nimport { Constraint } from './Contraints';\nimport { when } from './When';\n\nexport type Validator = { property: string | symbol; constraint: Constraint; text: Text; actual?: Text };\n\nexport const asResults = (subject: unknown, template: Text, options: TemplateOptions = {}): Results =>\n  toResults(toResult(text(template).parse(subject, options), toName(subject)));\n\nconst validators = (subject: unknown): List<Validator> =>\n  meta(subject)\n    .keys<List<Validator>>('constraint')\n    .reduce((list, vs) => list.add(vs), toList<Validator>());\n\nconst runValidator = (v: Validator, subject?: unknown): Results =>\n  tryTo(() => (isFunction((subject as any)[v.property]) ? (subject as any)[v.property]() : (subject as any)[v.property]))\n    .map(actual => [actual, v.constraint(actual)])\n    .map(([actual, res]) => (isResults(res) ? res : !res ? asResults(subject, v.text, { ...v, actual }) : toResults()))\n    .recover(e => asResults(subject, asString(e))).value;\n\nconst constraints = (subject?: unknown): Results =>\n  tryTo(() => validators(subject))\n    .map(vs => vs.mapDefined(v => runValidator(v, subject)))\n    .map(res => res.reduce((rs, r) => rs.add(...r.results), toResults())).value;\n\nexport const validate = (subject?: unknown): Results =>\n  choose(subject)\n    .is.not.defined(\n      s => s,\n      () => toResults('Subject is not defined.')\n    )\n    .type(isEnum, e => (e.isValid ? toResults() : asResults(e, 'This is not a valid {type}.')))\n    .type(isValue, v => (v.isValid ? toResults() : asResults(v, 'This is not a valid {type}.')))\n    .type(isArray, a => a.map(i => validate(i)).reduce((rs, r) => rs.add(...r.results), toResults()))\n    .type(isValidatable, v => constraints(v))\n    .else(toResults());\n\nexport const validateReject = <T>(subject: T): Promise<T> => when(subject).not.isValid.reject();\n\nexport const isValid = <T>(t: T): boolean => validate(t).isValid;\n"],"mappings":";AAAA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EAEA;AAAA,EAGA;AAAA,EAEA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAEP,SAAS,YAAY;AAId,MAAM,YAAY,CAAC,SAAkB,UAAgB,UAA2B,CAAC,MACtF,UAAU,SAAS,KAAK,QAAQ,EAAE,MAAM,SAAS,OAAO,GAAG,OAAO,OAAO,CAAC,CAAC;AAE7E,MAAM,aAAa,CAAC,YAClB,KAAK,OAAO,EACT,KAAsB,YAAY,EAClC,OAAO,CAAC,MAAM,OAAO,KAAK,IAAI,EAAE,GAAG,OAAkB,CAAC;AAE3D,MAAM,eAAe,CAAC,GAAc,YAClC,MAAM,MAAO,WAAY,QAAgB,EAAE,QAAQ,CAAC,IAAK,QAAgB,EAAE,QAAQ,EAAE,IAAK,QAAgB,EAAE,QAAQ,CAAE,EACnH,IAAI,YAAU,CAAC,QAAQ,EAAE,WAAW,MAAM,CAAC,CAAC,EAC5C,IAAI,CAAC,CAAC,QAAQ,GAAG,MAAO,UAAU,GAAG,IAAI,MAAM,CAAC,MAAM,UAAU,SAAS,EAAE,MAAM,EAAE,GAAG,GAAG,OAAO,CAAC,IAAI,UAAU,CAAE,EACjH,QAAQ,OAAK,UAAU,SAAS,SAAS,CAAC,CAAC,CAAC,EAAE;AAEnD,MAAM,cAAc,CAAC,YACnB,MAAM,MAAM,WAAW,OAAO,CAAC,EAC5B,IAAI,QAAM,GAAG,WAAW,OAAK,aAAa,GAAG,OAAO,CAAC,CAAC,EACtD,IAAI,SAAO,IAAI,OAAO,CAAC,IAAI,MAAM,GAAG,IAAI,GAAG,EAAE,OAAO,GAAG,UAAU,CAAC,CAAC,EAAE;AAEnE,MAAM,WAAW,CAAC,YACvB,OAAO,OAAO,EACX,GAAG,IAAI;AAAA,EACN,OAAK;AAAA,EACL,MAAM,UAAU,yBAAyB;AAC3C,EACC,KAAK,QAAQ,OAAM,EAAE,UAAU,UAAU,IAAI,UAAU,GAAG,6BAA6B,CAAE,EACzF,KAAK,SAAS,OAAM,EAAE,UAAU,UAAU,IAAI,UAAU,GAAG,6BAA6B,CAAE,EAC1F,KAAK,SAAS,OAAK,EAAE,IAAI,OAAK,SAAS,CAAC,CAAC,EAAE,OAAO,CAAC,IAAI,MAAM,GAAG,IAAI,GAAG,EAAE,OAAO,GAAG,UAAU,CAAC,CAAC,EAC/F,KAAK,eAAe,OAAK,YAAY,CAAC,CAAC,EACvC,KAAK,UAAU,CAAC;AAEd,MAAM,iBAAiB,CAAI,YAA2B,KAAK,OAAO,EAAE,IAAI,QAAQ,OAAO;AAEvF,MAAM,UAAU,CAAI,MAAkB,SAAS,CAAC,EAAE;","names":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thisisagile/easy",
-  "version": "15.16.3",
+  "version": "15.17.1",
   "description": "Straightforward library for building domain-driven microservice architectures",
   "author": "Sander Hoogendoorn",
   "license": "MIT",
@@ -33,7 +33,7 @@
     "access": "public"
   },
   "devDependencies": {
-    "@thisisagile/easy-test": "15.16.3",
+    "@thisisagile/easy-test": "15.17.1",
     "@types/form-urlencoded": "^4.4.0",
     "@types/jsonwebtoken": "^9.0.2",
     "@types/luxon": "3.4.2",

package/src/resources/Route.ts

@@ -19,7 +19,7 @@ export type Routes = { route: Uri; middleware: RequestHandler[]; endpoints: List
 const toRoute = (endpoint: Endpoint, requires: RouteRequires, verb?: Verb, middleware?: RequestHandler[]): Optional<Route> =>
   tryTo(verb)
     .is.defined()
-    .map(verb => ({ verb, endpoint, requires, middleware: middleware ?? [] } as Route))
+    .map(verb => ({ verb, endpoint, requires, middleware: middleware ?? [] }) as Route)
     .orElse();
 
 class Router implements Routes {

package/src/types/Parser.ts

@@ -0,0 +1,51 @@
+import { Get, ofGet } from './Get';
+import { isDefined, isEmpty, isIn, isObject, isString } from './Is';
+import { isValid } from '../validation';
+import { Constructor } from './Constructor';
+import { toArray } from './Array';
+
+export class Parser<T, V> {
+  if = {
+    empty: <U>(pred?: Get<U, T>): this => this.evaluate(isEmpty, pred),
+    defined: <U>(pred?: Get<U, T>): this => this.evaluate(isDefined, pred),
+    valid: <U>(pred?: Get<U, T>): this => this.evaluate(isValid, pred),
+    in: (...items: T[]): this => this.evaluate(() => isIn(this.value, toArray(...items))),
+    is: {
+      object: <U>(pred?: Get<U, T>): this => this.evaluate(isObject, pred),
+      string: <U>(pred?: Get<U, T>): this => this.evaluate(isString, pred),
+      instance: <U>(c: Constructor<U>, pred?: Get<U, T>): this => this.evaluate(() => this.value instanceof c, pred),
+    },
+    not: {
+      empty: <U>(pred?: Get<U, T>): this => this.evaluateNot(isEmpty, pred),
+      defined: <U>(pred?: Get<U, T>): this => this.evaluateNot(isDefined, pred),
+      valid: <U>(pred?: Get<U, T>): this => this.evaluateNot(isValid, pred),
+      isObject: <U>(pred?: Get<U, T>): this => this.evaluateNot(isObject, pred),
+      in: (...items: T[]): this => this.evaluate(() => !isIn(this.value, toArray(...items))),
+      is: {
+        object: <U>(pred?: Get<U, T>): this => this.evaluateNot(isObject, pred),
+        string: <U>(pred?: Get<U, T>): this => this.evaluateNot(isString, pred),
+        instance: <U>(c: Constructor<U>, pred?: Get<U, T>): this => this.evaluate(() => !(this.value instanceof c), pred),
+      },
+    },
+  };
+
+  constructor(protected value: T, protected f: Get<V, T>, protected alt: Get<V, T>, readonly valid = true) {}
+
+  protected evaluate<U>(meta: Get<boolean>, pred?: Get<U, T>): this {
+    return new (this.constructor as new (value: T, f: Get<V, T>, alt: Get<V, T>, allow?: boolean) => this)(
+      this.value,
+      this.f,
+      this.alt,
+      ofGet(meta, pred ? ofGet(pred, this.value) : this.value)
+    );
+  }
+
+  protected evaluateNot<U>(meta: Get<boolean>, pred?: Get<U, T>): this {
+    return new (this.constructor as new (value: T, f: Get<V, T>, alt: Get<V, T>, allow?: boolean) => this)(
+      this.value,
+      this.f,
+      this.alt,
+      !ofGet(meta, pred ? ofGet(pred, this.value) : this.value)
+    );
+  }
+}

package/src/types/index.ts

@@ -25,6 +25,7 @@ export * from './Meta';
 export * from './Nullish';
 export * from './Number';
 export * from './PageList';
+export * from './Parser';
 export * from './Primitive';
 export * from './Repository';
 export * from './Result';

package/src/validation/Validate.ts

@@ -56,3 +56,5 @@ export const validate = (subject?: unknown): Results =>
     .else(toResults());
 
 export const validateReject = <T>(subject: T): Promise<T> => when(subject).not.isValid.reject();
+
+export const isValid = <T>(t: T): boolean => validate(t).isValid;