wysiwyv 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jeremy "Ibi-Wan" Kent "...obi"
+
+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

@@ -0,0 +1,150 @@
+| _README_ | [USAGE](README-USAGE.md) | [INCLUDED PLUGINS](README-INCLUDED-PLUGINS.md) | [PLUGIN AUTHORING](README-PLUGIN-AUTHORING.md) | [INTEGRATION](README-INTEGRATION.md) |
+| :------- | :----------------------- | :--------------------------------------------- | :--------------------------------------------- | :----------------------------------- |
+
+# WYSIWYV
+
+- [Why You Wyv](#why-you-wyv)
+- [Included Plugins](#included-plugins)
+- [Make Your Own Plugins](#make-your-own-plugins)
+
+## What You See is What You Validate
+
+### candidate data:
+
+```json
+{
+  "name": "John Smythe-Do",
+  "id": "c522fc68-ca27-4391-ac43-494c023e24a7",
+  "age": 27
+}
+```
+
+### validation template:
+
+```json
+{
+  "name": "$string",
+  "id": "$uuid",
+  "age": "$number"
+}
+```
+
+### plugins nest and compose:
+
+```js
+{
+  dept: ["sales", "acquisitions"],
+  team: [
+    { name: "Joan Duet", team: "sales" },
+    { name: "Jonn Tray", team: "sales" },
+    { name: "Jane Quay", team: "sales" }
+  ]
+}
+```
+
+```js
+{
+  dept: { $array: { $minlength: 1 } },
+  team: {
+    $array: { $each: {
+        $object: { $partial: {
+            team: "sales",
+        }},
+      }},
+  },
+}
+```
+
+### success is simple:
+
+```js
+{ success: true, errors: [] }
+```
+
+### rejection is clear:
+
+```js
+{
+  success: false,
+  errors:[
+    {
+      message: "Type: Expected 'number', got value 'old enough'",
+      path: ".age"
+    }
+  ]
+}
+```
+
+## Why You Wyv?
+
+- Templates: JSON
+  - Or directly in JS
+  - $-prefix for plugins
+  - Templates are Language-Agnostic
+    - Other language libraries to follow
+- Tiny: Core is ~ 1.5kB
+- Batteries: Included
+- Strict: By Default
+- Flexible: Rich Plugin API
+- Fast Enough: Faster than yup and joi.  
+  _(Still pursuing zod and valibot)_
+- Simple: Reuse in:
+  - jest assertions
+  - express middleware
+  - cli tools
+  - custom exceptions
+
+### The real reason:
+
+- You like that the plugins are called wyverns.
+
+[↑ top](#wysiwyv)
+
+## Included Plugins
+
+Read the [Included Plugins Documentation](README-INCLUDED-PLUGINS.md)
+
+- $and / $or
+- $any
+- $array / $object / $plainobject
+- $bool
+- $isodate / $basicisodate / $strictisodate
+- $email
+- $int / $number
+- $string
+- $uuid
+- $val
+  - Match values known at call time
+  - Ensure values match within data (back-references)
+
+[↑ top](#wysiwyv)
+
+## Make Your Own Plugins
+
+Read the [Plugin Authoring Documentation](README-PLUGIN-AUTHORING.md)
+
+- Full Type System enables clean interfacing
+  - See `src/type/plugin.ts` for contract
+  - See `src/hooks/string.ts` for a simple example
+- Rich data: inject at setup time or call time, or add during validation
+  - All scoped to your plugin for safety
+  - Alternately, use a shared context to communicate across plugins
+  - See `src/hooks/val.ts` for context use example
+- `evaluate` function provided for custom recursive descent
+  - See `src/hooks/object.ts` for descent example
+
+[↑ top](#wysiwyv)
+
+# TODO
+
+- [x] Base Plugin Set
+- [x] Test Coverage
+- [x] Documentation
+  - [x] Basic Usage
+  - [x] Plugin Authoring
+  - [x] Included Plugins
+  - [x] Integration Examples
+- [x] Benchmarks
+- [ ] Distro Builds
+- [ ] To Npm!
+- [ ] Reuse Instances

package/dist/core.d.ts

@@ -0,0 +1,7 @@
+import { type WysiwyvEvaluatorFunction } from "./type/engine";
+import { type PluginList } from "./type/plugin";
+import type { MultiContext } from "./type/engine";
+export declare const makeCore: (hooks: PluginList, pluginSetups: MultiContext) => {
+    evaluate: WysiwyvEvaluatorFunction;
+};
+//# sourceMappingURL=core.d.ts.map

package/dist/core.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"core.d.ts","sourceRoot":"","sources":["../src/core.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,wBAAwB,EAAE,MAAM,eAAe,CAAC;AAK9D,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,eAAe,CAAC;AAyBhD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAElD,eAAO,MAAM,QAAQ,GAAI,OAAO,UAAU,EAAE,cAAc,YAAY;;CA4MrE,CAAC"}

package/dist/core.js

@@ -0,0 +1,147 @@
+import {} from "./type/engine";
+import {} from "./type/plugin";
+import {} from "./type/template";
+import {} from "./type/template";
+import {} from "./type/plugin";
+import {} from "./type/plugin";
+import { HookAssessor } from "./util/HookAssessment";
+import { errAttr, errConfig, errMissing, errType, errUnexpected, errValue, } from "./util/HookError";
+import { getHookKey, getHookParams } from "./util/parseHook";
+import { repr } from "./util/stringify";
+import { isArray, isBoolean, isNull, isNumber, isPlainObject, isString, isUndefined, } from "./util/types";
+export const makeCore = (hooks, pluginSetups) => {
+    const perHookSetups = Object.freeze({ ...pluginSetups });
+    const perHookContexts = {};
+    const sharedContext = {};
+    const handlerKeyCache = new Map();
+    const evaluate = (expected, candidate, path) => {
+        const key = getHookKey(expected);
+        if (!key)
+            return expectNormal(expected, candidate, path);
+        const hookSetup = perHookSetups[key] ?? {};
+        if (perHookContexts[key] === undefined) {
+            perHookContexts[key] = {};
+        }
+        const hookContext = perHookContexts[key];
+        let handler;
+        if (handlerKeyCache.has(key)) {
+            handler = handlerKeyCache.get(key);
+        }
+        else {
+            const hookPlugin = hooks.find((h) => h.handles(key));
+            handler = hookPlugin?.handlers[key];
+            if (handler) {
+                handlerKeyCache.set(key, handler);
+            }
+        }
+        if (!handler)
+            return expectNormal(expected, candidate, path);
+        const params = getHookParams(expected, key);
+        const result = handler(candidate, expected, {
+            path,
+            params,
+            setup: hookSetup,
+            context: hookContext,
+            shared: sharedContext,
+            evaluate: evaluate,
+        });
+        return result;
+    };
+    const expectNormal = (expected, candidate, path) => {
+        switch (true) {
+            case isString(expected):
+                return expectString(expected, candidate, path);
+            case isNumber(expected):
+                return expectNumber(expected, candidate, path);
+            case isBoolean(expected):
+                return expectBoolean(expected, candidate, path);
+            case isNull(expected):
+                return expectNull(candidate, path);
+            case isArray(expected):
+                return expectArray(expected, candidate, path);
+            case isPlainObject(expected):
+                return expectObject(expected, candidate, path);
+            default:
+                return HookAssessor.fault(errConfig(`Unsupported value type in expected object: '${repr(expected)}'`, path));
+        }
+    };
+    const expectString = (expected, candidate, path) => {
+        if (typeof candidate !== "string") {
+            return HookAssessor.fault(errType("string", candidate, path));
+        }
+        if (candidate !== expected) {
+            return HookAssessor.fault(errValue(expected, candidate, path));
+        }
+        return HookAssessor.SUCCESS;
+    };
+    const expectNumber = (expected, candidate, path) => {
+        if (typeof candidate !== "number") {
+            return HookAssessor.fault(errType("number", candidate, path));
+        }
+        if (candidate !== expected) {
+            return HookAssessor.fault(errValue(expected, candidate, path));
+        }
+        return HookAssessor.SUCCESS;
+    };
+    const expectBoolean = (expected, candidate, path) => {
+        if (typeof candidate !== "boolean") {
+            return HookAssessor.fault(errType("boolean", candidate, path));
+        }
+        if (candidate !== expected) {
+            return HookAssessor.fault(errValue(expected, candidate, path));
+        }
+        return HookAssessor.SUCCESS;
+    };
+    const expectNull = (candidate, path) => {
+        if (candidate !== null) {
+            return HookAssessor.fault(errType("null", candidate, path));
+        }
+        return HookAssessor.SUCCESS;
+    };
+    const expectArray = (expected, candidate, path) => {
+        if (!isArray(candidate)) {
+            return HookAssessor.fault(errType("array", candidate, path));
+        }
+        const errors = HookAssessor.start();
+        if (candidate.length !== expected.length) {
+            errors.fault(errAttr("Array length", expected.length, candidate.length, path));
+        }
+        for (let i = 0; i < expected.length; i++) {
+            if (isUndefined(candidate[i])) {
+                errors.fault(errMissing(`index ${i}`, expected[i], `${path}[${i}]`));
+                continue;
+            }
+            const itemErrors = evaluate(expected[i], // not undefined per earlier check
+            candidate[i], `${path}[${i}]`);
+            errors.include(itemErrors);
+        }
+        return errors;
+    };
+    const expectObject = (expected, candidate, path) => {
+        if (!isPlainObject(candidate)) {
+            return HookAssessor.fault(errType("object", candidate, path));
+        }
+        const errors = HookAssessor.start();
+        const expectedKeys = Object.keys(expected);
+        const candidateKeys = Object.keys(candidate);
+        const missingKeys = expectedKeys.filter((k) => !candidateKeys.includes(k));
+        const extraKeys = candidateKeys.filter((k) => !expectedKeys.includes(k));
+        missingKeys.forEach((k) => {
+            errors.fault(errMissing(`${k}`, expected[k], `${path}.${k}`));
+        });
+        extraKeys.forEach((k) => {
+            errors.fault(errUnexpected(k, candidate[k], `${path}.${k}`));
+        });
+        for (const key in expected) {
+            if (missingKeys.includes(key))
+                continue; // already reported
+            const keyErrors = evaluate(expected[key], // not undefined per earlier check
+            candidate[key], `${path}.${key}`);
+            errors.include(keyErrors);
+        }
+        return errors;
+    };
+    return {
+        evaluate,
+    };
+};

package/dist/hooks/and.d.ts

@@ -0,0 +1,10 @@
+import type { HookValue } from "../type/template";
+import type { ContextObject } from "../type/plugin";
+import type { WyvPlugin } from "../type/plugin";
+export declare const WYV_KEY_AND = "$and";
+type WyvParams = HookValue[];
+type WyvSetup = unknown;
+type WyvContext = ContextObject;
+declare const andWyvern: WyvPlugin<WyvParams, WyvSetup, WyvContext>;
+export default andWyvern;
+//# sourceMappingURL=and.d.ts.map

package/dist/hooks/and.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"and.d.ts","sourceRoot":"","sources":["../../src/hooks/and.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AACpD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAIhD,eAAO,MAAM,WAAW,SAAS,CAAC;AAElC,KAAK,SAAS,GAAG,SAAS,EAAE,CAAC;AAC7B,KAAK,QAAQ,GAAG,OAAO,CAAC;AACxB,KAAK,UAAU,GAAG,aAAa,CAAC;AAEhC,QAAA,MAAM,SAAS,EAAE,SAAS,CAAC,SAAS,EAAE,QAAQ,EAAE,UAAU,CAqCzD,CAAC;AAEF,eAAe,SAAS,CAAC"}

package/dist/hooks/and.js

@@ -0,0 +1,29 @@
+import { HookAssessor } from "../util/HookAssessment";
+import { errColl, errConfig } from "../util/HookError";
+export const WYV_KEY_AND = "$and";
+const andWyvern = {
+    handles: (value) => [WYV_KEY_AND].includes(value),
+    handlers: {
+        [WYV_KEY_AND]: (value, _expected, { path, params, evaluate }) => {
+            if (!Array.isArray(params)) {
+                return HookAssessor.fault(errConfig("$and value should be an array of templates", path));
+            }
+            if (params.length === 0) {
+                // AND(<no arguments>) is defined as TRUE for boolean algebra
+                return HookAssessor.SUCCESS;
+            }
+            const errors = HookAssessor.start();
+            for (const template of params) {
+                const templateErrors = evaluate(template, value, path);
+                errors.include(templateErrors);
+            }
+            if (errors.success) {
+                return HookAssessor.SUCCESS;
+            }
+            const a = HookAssessor.fault(errColl("$and", path));
+            const final = a.include(errors);
+            return final;
+        },
+    },
+};
+export default andWyvern;

package/dist/hooks/any.d.ts

@@ -0,0 +1,8 @@
+import type { ContextObject, WyvPlugin } from "../type/plugin";
+export declare const WYV_KEY_ANY = "$any";
+type WyvParams = unknown;
+type WyvSetup = unknown;
+type WyvContext = ContextObject;
+declare const anyWyvern: WyvPlugin<WyvParams, WyvSetup, WyvContext>;
+export default anyWyvern;
+//# sourceMappingURL=any.d.ts.map

package/dist/hooks/any.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"any.d.ts","sourceRoot":"","sources":["../../src/hooks/any.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAG/D,eAAO,MAAM,WAAW,SAAS,CAAC;AAElC,KAAK,SAAS,GAAG,OAAO,CAAC;AACzB,KAAK,QAAQ,GAAG,OAAO,CAAC;AACxB,KAAK,UAAU,GAAG,aAAa,CAAC;AAEhC,QAAA,MAAM,SAAS,EAAE,SAAS,CAAC,SAAS,EAAE,QAAQ,EAAE,UAAU,CAOzD,CAAC;AAEF,eAAe,SAAS,CAAC"}

package/dist/hooks/any.js

@@ -0,0 +1,11 @@
+import { HookAssessor } from "../util/HookAssessment";
+export const WYV_KEY_ANY = "$any";
+const anyWyvern = {
+    handles: (value) => [WYV_KEY_ANY].includes(value),
+    handlers: {
+        [WYV_KEY_ANY]: () => {
+            return HookAssessor.SUCCESS;
+        },
+    },
+};
+export default anyWyvern;

package/dist/hooks/array.d.ts

@@ -0,0 +1,18 @@
+import type { ContextObject } from "../type/plugin";
+import type { WyvPlugin } from "../type/plugin";
+export declare const WYV_KEY_ARRAY = "$array";
+export declare const WYV_ARRAY_PARAM_LENGTH = "$length";
+export declare const WYV_ARRAY_PARAM_MINLENGTH = "$minlength";
+export declare const WYV_ARRAY_PARAM_MAXLENGTH = "$maxlength";
+export declare const WYV_ARRAY_PARAM_EACH = "$each";
+type WyvParams = {
+    [WYV_ARRAY_PARAM_LENGTH]?: number;
+    [WYV_ARRAY_PARAM_MINLENGTH]?: number;
+    [WYV_ARRAY_PARAM_MAXLENGTH]?: number;
+    [WYV_ARRAY_PARAM_EACH]?: unknown;
+};
+type WyvSetup = unknown;
+type WyvContext = ContextObject;
+declare const arrayWyvern: WyvPlugin<WyvParams, WyvSetup, WyvContext>;
+export default arrayWyvern;
+//# sourceMappingURL=array.d.ts.map

package/dist/hooks/array.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"array.d.ts","sourceRoot":"","sources":["../../src/hooks/array.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AACpD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAKhD,eAAO,MAAM,aAAa,WAAW,CAAC;AACtC,eAAO,MAAM,sBAAsB,YAAY,CAAC;AAChD,eAAO,MAAM,yBAAyB,eAAe,CAAC;AACtD,eAAO,MAAM,yBAAyB,eAAe,CAAC;AACtD,eAAO,MAAM,oBAAoB,UAAU,CAAC;AAE5C,KAAK,SAAS,GAAG;IACf,CAAC,sBAAsB,CAAC,CAAC,EAAE,MAAM,CAAC;IAClC,CAAC,yBAAyB,CAAC,CAAC,EAAE,MAAM,CAAC;IACrC,CAAC,yBAAyB,CAAC,CAAC,EAAE,MAAM,CAAC;IACrC,CAAC,oBAAoB,CAAC,CAAC,EAAE,OAAO,CAAC;CAClC,CAAC;AACF,KAAK,QAAQ,GAAG,OAAO,CAAC;AACxB,KAAK,UAAU,GAAG,aAAa,CAAC;AAEhC,QAAA,MAAM,WAAW,EAAE,SAAS,CAAC,SAAS,EAAE,QAAQ,EAAE,UAAU,CA8F3D,CAAC;AAEF,eAAe,WAAW,CAAC"}

package/dist/hooks/array.js

@@ -0,0 +1,56 @@
+import { HookAssessor } from "../util/HookAssessment";
+import { errAttr, errConfig, errType } from "../util/HookError";
+import { isArray, isDefined, isNumber, isObject, notNull } from "../util/types";
+export const WYV_KEY_ARRAY = "$array";
+export const WYV_ARRAY_PARAM_LENGTH = "$length";
+export const WYV_ARRAY_PARAM_MINLENGTH = "$minlength";
+export const WYV_ARRAY_PARAM_MAXLENGTH = "$maxlength";
+export const WYV_ARRAY_PARAM_EACH = "$each";
+const arrayWyvern = {
+    handles: (value) => [WYV_KEY_ARRAY].includes(value),
+    handlers: {
+        [WYV_KEY_ARRAY]: (value, _expected, { path, params, evaluate }) => {
+            if (!isArray(value)) {
+                return HookAssessor.fault(errType("array", value, path));
+            }
+            const errors = HookAssessor.start();
+            const normalizedParams = isObject(params)
+                ? params
+                : { [WYV_ARRAY_PARAM_EACH]: params };
+            const { [WYV_ARRAY_PARAM_LENGTH]: length, [WYV_ARRAY_PARAM_MINLENGTH]: minLength, [WYV_ARRAY_PARAM_MAXLENGTH]: maxLength, [WYV_ARRAY_PARAM_EACH]: each, ...rest } = normalizedParams;
+            const isParametric = isDefined(length) ||
+                isDefined(minLength) ||
+                isDefined(maxLength) ||
+                isDefined(each);
+            if (isParametric && Object.keys(rest).length > 0) {
+                errors.fault(errConfig(`Ignored unknown $array parameters: '${Object.keys(rest)}'`, path));
+            }
+            const useEach = isParametric
+                ? each
+                : Object.keys(rest).length > 0
+                    ? rest
+                    : null;
+            if (isDefined(length) && value.length !== length) {
+                errors.fault(errAttr(WYV_KEY_ARRAY + "." + WYV_ARRAY_PARAM_LENGTH, length, value.length, path));
+            }
+            if (isDefined(minLength) &&
+                isNumber(minLength) &&
+                value.length < minLength) {
+                errors.fault(errAttr(WYV_KEY_ARRAY + "." + WYV_ARRAY_PARAM_MINLENGTH, minLength, value.length, path));
+            }
+            if (isDefined(maxLength) &&
+                isNumber(maxLength) &&
+                value.length > maxLength) {
+                errors.fault(errAttr(WYV_KEY_ARRAY + "." + WYV_ARRAY_PARAM_MAXLENGTH, maxLength, value.length, path));
+            }
+            if (notNull(useEach)) {
+                for (const [index, element] of value.entries()) {
+                    const elementErrors = evaluate(useEach, element, `${path}[${index}]`);
+                    errors.include(elementErrors);
+                }
+            }
+            return errors;
+        },
+    },
+};
+export default arrayWyvern;

package/dist/hooks/bool.d.ts

@@ -0,0 +1,8 @@
+import type { ContextObject, WyvPlugin } from "../type/plugin";
+export declare const WYV_KEY_BOOL = "$bool";
+type WyvParams = unknown;
+type WyvSetup = unknown;
+type WyvContext = ContextObject;
+declare const boolWyvern: WyvPlugin<WyvParams, WyvSetup, WyvContext>;
+export default boolWyvern;
+//# sourceMappingURL=bool.d.ts.map

package/dist/hooks/bool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bool.d.ts","sourceRoot":"","sources":["../../src/hooks/bool.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAM/D,eAAO,MAAM,YAAY,UAAU,CAAC;AAEpC,KAAK,SAAS,GAAG,OAAO,CAAC;AACzB,KAAK,QAAQ,GAAG,OAAO,CAAC;AACxB,KAAK,UAAU,GAAG,aAAa,CAAC;AAEhC,QAAA,MAAM,UAAU,EAAE,SAAS,CAAC,SAAS,EAAE,QAAQ,EAAE,UAAU,CAU1D,CAAC;AAEF,eAAe,UAAU,CAAC"}

package/dist/hooks/bool.js

@@ -0,0 +1,16 @@
+import { HookAssessor } from "../util/HookAssessment";
+import { isBoolean } from "../util/types";
+import { errType } from "../util/HookError";
+export const WYV_KEY_BOOL = "$bool";
+const boolWyvern = {
+    handles: (value) => [WYV_KEY_BOOL].includes(value),
+    handlers: {
+        [WYV_KEY_BOOL]: (value, _expected, { path }) => {
+            if (!isBoolean(value)) {
+                return HookAssessor.fault(errType("boolean", value, path));
+            }
+            return HookAssessor.SUCCESS;
+        },
+    },
+};
+export default boolWyvern;

package/dist/hooks/datetime.d.ts

@@ -0,0 +1,11 @@
+import type { ContextObject, HookKey } from "../type/plugin";
+import type { WyvPlugin } from "../type/plugin";
+export declare const WYV_KEY_ISODATE: HookKey;
+export declare const WYV_KEY_BASICISODATE: HookKey;
+export declare const WYV_KEY_STRICTISODATE: HookKey;
+type WyvParams = unknown;
+type WyvSetup = unknown;
+type WyvContext = ContextObject;
+declare const datetimeWyvern: WyvPlugin<WyvParams, WyvSetup, WyvContext>;
+export default datetimeWyvern;
+//# sourceMappingURL=datetime.d.ts.map

package/dist/hooks/datetime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"datetime.d.ts","sourceRoot":"","sources":["../../src/hooks/datetime.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAC7D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AA+ChD,eAAO,MAAM,eAAe,EAAE,OAAoB,CAAC;AACnD,eAAO,MAAM,oBAAoB,EAAE,OAAyB,CAAC;AAC7D,eAAO,MAAM,qBAAqB,EAAE,OAA0B,CAAC;AAgC/D,KAAK,SAAS,GAAG,OAAO,CAAC;AACzB,KAAK,QAAQ,GAAG,OAAO,CAAC;AACxB,KAAK,UAAU,GAAG,aAAa,CAAC;AAEhC,QAAA,MAAM,cAAc,EAAE,SAAS,CAAC,SAAS,EAAE,QAAQ,EAAE,UAAU,CAsB9D,CAAC;AAEF,eAAe,cAAc,CAAC"}

package/dist/hooks/datetime.js

@@ -0,0 +1,88 @@
+import { HookAssessor } from "../util/HookAssessment";
+import { errType } from "../util/HookError";
+import { isString } from "../util/types";
+const YEAR = "(?:\\d{4})"; // 0000-9999
+const MONTH = "(?:0[1-9]|1[0-2])"; // 01-12;
+const DAY = `(?:0[1-9]|[12]\\d|3[01])`; // 01-31
+const HOUR = `(?:[01]\\d|2[0-3])`; // 00-23
+const MINUTE = "(?:[0-5]\\d)"; // 00-59
+const SECOND = "(?:[0-5]\\d)"; // 00-59
+const MILLI_EXT = "(?:[,.]\\d+)"; // .123...
+const MILLI_RFC = "(?:\\.\\d+)"; // .123...
+// Validates numeric ranges: YYYY-MM-DD
+const DATE_EXT = `(?:${YEAR}-${MONTH}-${DAY})`;
+const DATE_BAS = `(?:${YEAR}${MONTH}${DAY})`;
+// Validates numeric ranges: HH:mm:ss.SSS (seconds/ms optional)
+const TIME_EXT = `(?:${HOUR}:${MINUTE}(?::${SECOND}(?:${MILLI_EXT})?)?)`;
+const TIME_BAS = `(?:${HOUR}${MINUTE}(?:${SECOND}(?:${MILLI_EXT})?)?)`;
+const TIME_RFC = `(?:${HOUR}:${MINUTE}(?::${SECOND}(?:${MILLI_RFC})?)?)`;
+// Validates Z or ±HH:mm or ±HHmm
+const ZONE_EXT = `(?:Z|[+-]${HOUR}:?${MINUTE})`;
+const ZONE_BAS = `(?:Z|[+-]${HOUR}${MINUTE})`;
+const ZONE_RFC = `(?:Z|[+-]${HOUR}:${MINUTE}|-00:00)`;
+const make8601 = () => {
+    return new RegExp(`^${DATE_EXT}T${TIME_EXT}${ZONE_EXT}$`, "i");
+};
+const RE_ISO_8601 = make8601();
+const make8601basic = () => {
+    return new RegExp(`^${DATE_BAS}T${TIME_BAS}${ZONE_BAS}$`, "i");
+};
+const RE_ISO_8601_BASIC = make8601basic();
+const make3339 = () => {
+    // Full Pattern: YYYY-MM-DDTHH:mm:ss.sssZ
+    return new RegExp(`^${DATE_EXT}[T ]${TIME_RFC}${ZONE_RFC}$`, "i");
+};
+const RE_ISO_3339 = make3339();
+export const WYV_KEY_ISODATE = "$isodate";
+export const WYV_KEY_BASICISODATE = "$basicisodate";
+export const WYV_KEY_STRICTISODATE = "$strictisodate";
+const checkParsedDate = (value) => {
+    const date = new Date(value);
+    return !Number.isNaN(date.getTime());
+};
+const checkIsoDate = (value) => {
+    if (!isString(value)) {
+        return false;
+    }
+    if (!RE_ISO_8601.test(value))
+        return false;
+    return checkParsedDate(value);
+};
+const checkBasicIsoDate = (value) => {
+    if (!isString(value)) {
+        return false;
+    }
+    if (!RE_ISO_8601_BASIC.test(value))
+        return false;
+    // return checkParsedDate(value); // built-in can't parse basic.
+    return true;
+};
+const checkStrictIsoDate = (value) => {
+    if (!isString(value)) {
+        return false;
+    }
+    if (!RE_ISO_3339.test(value))
+        return false;
+    return checkParsedDate(value);
+};
+const datetimeWyvern = {
+    handles: (value) => [WYV_KEY_ISODATE, WYV_KEY_BASICISODATE, WYV_KEY_STRICTISODATE].includes(value),
+    handlers: {
+        [WYV_KEY_ISODATE]: (value, _expected, { path }) => {
+            if (!checkIsoDate(value))
+                return HookAssessor.fault(errType("ISO 8601 date", value, path));
+            return HookAssessor.SUCCESS;
+        },
+        [WYV_KEY_BASICISODATE]: (value, _expected, { path }) => {
+            if (!checkBasicIsoDate(value))
+                return HookAssessor.fault(errType("Basic ISO 8601 date", value, path));
+            return HookAssessor.SUCCESS;
+        },
+        [WYV_KEY_STRICTISODATE]: (value, _expected, { path }) => {
+            if (!checkStrictIsoDate(value))
+                return HookAssessor.fault(errType("RFC 3339 date", value, path));
+            return HookAssessor.SUCCESS;
+        },
+    },
+};
+export default datetimeWyvern;

package/dist/hooks/email.d.ts

@@ -0,0 +1,8 @@
+import type { ContextObject, WyvPlugin } from "../type/plugin";
+export declare const WYV_KEY_EMAIL = "$email";
+type WyvParams = unknown;
+type WyvSetup = unknown;
+type WyvContext = ContextObject;
+declare const emailWyvern: WyvPlugin<WyvParams, WyvSetup, WyvContext>;
+export default emailWyvern;
+//# sourceMappingURL=email.d.ts.map

package/dist/hooks/email.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"email.d.ts","sourceRoot":"","sources":["../../src/hooks/email.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAa/D,eAAO,MAAM,aAAa,WAAW,CAAC;AAEtC,KAAK,SAAS,GAAG,OAAO,CAAC;AACzB,KAAK,QAAQ,GAAG,OAAO,CAAC;AACxB,KAAK,UAAU,GAAG,aAAa,CAAC;AAEhC,QAAA,MAAM,WAAW,EAAE,SAAS,CAAC,SAAS,EAAE,QAAQ,EAAE,UAAU,CAc3D,CAAC;AAEF,eAAe,WAAW,CAAC"}

package/dist/hooks/email.js

@@ -0,0 +1,26 @@
+import { HookAssessor } from "../util/HookAssessment";
+import { isString } from "../util/types";
+import { errType } from "../util/HookError";
+const ncg = (s) => `(?:${s})`;
+const CHARS = `[a-zA-Z0-9_%+\\-]+`;
+const DOT_CHARS = ncg(`\\.${CHARS}`);
+const DOTTED_CHARS_ANY = ncg(`${CHARS}${DOT_CHARS}*`);
+const DOTTED_CHARS_SOME = ncg(`${CHARS}${DOT_CHARS}+`);
+const EMAIL = `${DOTTED_CHARS_ANY}@${DOTTED_CHARS_SOME}`;
+const RE_EMAIL_LOOSE = new RegExp(`^${EMAIL}$`);
+export const WYV_KEY_EMAIL = "$email";
+const emailWyvern = {
+    handles: (value) => [WYV_KEY_EMAIL].includes(value),
+    handlers: {
+        [WYV_KEY_EMAIL]: (value, _expected, { path }) => {
+            if (!isString(value)) {
+                return HookAssessor.fault(errType("string", value, path));
+            }
+            if (!RE_EMAIL_LOOSE.test(value)) {
+                return HookAssessor.fault(errType("valid email address", value, path));
+            }
+            return HookAssessor.SUCCESS;
+        },
+    },
+};
+export default emailWyvern;

package/dist/hooks/index.d.ts

@@ -0,0 +1,3 @@
+import type { PluginList } from "../type/plugin";
+export declare const defaultHooks: PluginList;
+//# sourceMappingURL=index.d.ts.map

package/dist/hooks/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/hooks/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAgBjD,eAAO,MAAM,YAAY,EAAE,UAc1B,CAAC"}