umt 3.1.0 → 3.2.0

package/module/es5/Validate/standardSchema.js

@@ -0,0 +1,91 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.attachStandard = exports.STANDARD_SCHEMA_VENDOR = void 0;
+/**
+ * Standard Schema V1 integration
+ *
+ * Defines the public Standard Schema V1 surface (https://standardschema.dev)
+ * and exposes the `attachStandard()` helper used by every UMT validator
+ * factory to advertise itself as a Standard Schema V1 implementation. The
+ * `~standard` property added by `attachStandard()` lets external tools
+ * (Zod-, Valibot-, ArkType-style ecosystems) consume UMT validators without
+ * adapters.
+ *
+ * Biome's `noNamespace` lint rule forbids TypeScript namespaces, so the spec
+ * is mirrored with flat interface/type names that remain structurally
+ * compatible with the official `StandardSchemaV1` interface published by
+ * `@standard-schema/spec`.
+ */
+
+/** The Standard Schema V1 interface. */
+
+/** The Standard Schema V1 properties interface. */
+
+/** The result type produced by `Props.validate`. */
+
+/** The result interface when validation succeeds. */
+
+/** The result interface when validation fails. */
+
+/** The issue interface returned on failure. */
+
+/** The path segment interface for nested issues. */
+
+/** The Standard Schema V1 types interface. */
+
+/** Infers the input type of a Standard Schema V1 implementation. */
+
+/** Infers the output type of a Standard Schema V1 implementation. */
+
+/**
+ * Vendor identifier used by all UMT validators when advertising Standard
+ * Schema V1 compatibility. External tools may key off this value to attach
+ * UMT-specific behavior.
+ */
+var STANDARD_SCHEMA_VENDOR = exports.STANDARD_SCHEMA_VENDOR = "umt";
+
+/** Minimal shape of UMT validator results consumed by `attachStandard`. */
+
+/**
+ * Attaches a Standard Schema V1 `~standard` property to a UMT validator
+ * function in place. The validator's existing call signature, attached
+ * helpers (such as `shape` on `object()` or `implement` on `function_()`),
+ * and return type are preserved untouched; only the `~standard` property is
+ * added.
+ *
+ * Validation is delegated to the wrapped validator. On success the input
+ * value is returned through the Standard Schema `value` field; on failure a
+ * single issue carrying the validator's message is emitted. UMT validators
+ * never transform their input, so `Input` and `Output` default to the same
+ * type.
+ *
+ * @template Input - The input type advertised through `~standard.types`
+ * @template Output - The output type advertised through `~standard.types`
+ * @template F - The validator function being augmented
+ * @param {F} validator - The validator function to augment
+ * @returns {F & StandardSchemaV1<Input, Output>} The same function with `~standard` attached
+ */
+var attachStandard = exports.attachStandard = function attachStandard(validator) {
+  var properties = {
+    version: 1,
+    vendor: STANDARD_SCHEMA_VENDOR,
+    validate: function validate(value) {
+      var result = validator(value);
+      if (result.validate) {
+        return {
+          value: value
+        };
+      }
+      return {
+        issues: [{
+          message: result.message || "Validation failed"
+        }]
+      };
+    }
+  };
+  validator["~standard"] = properties;
+  return validator;
+};

package/module/es5/Validate/string/core.d.ts

@@ -2,7 +2,8 @@
  * String validation core module
  * Provides the base validation functionality for string values
  */
-import type { ValidateReturnType } from "../../Validate/type";
+import { type StandardSchemaV1 } from "../../Validate/standardSchema";
+import type { ValidateCoreReturnType, ValidateReturnType } from "../../Validate/type";
 /**
  * Creates a string validator with optional validation rules
  * @template T - Array of validation rules for strings
@@ -10,4 +11,4 @@ import type { ValidateReturnType } from "../../Validate/type";
  * @param {string} [message] - Custom error message for type validation
  * @returns {Function} - Validator function that checks if the value is a string and applies validation rules
  */
-export declare const string: <T extends ValidateReturnType<string>[]>(option?: T, message?: string) => (value: string) => import("../../Validate/type").ValidateCoreReturnType<string>;
+export declare const string: <T extends ValidateReturnType<string>[]>(option?: T, message?: string) => ((value: string) => ValidateCoreReturnType<string>) & StandardSchemaV1<string, string>;

package/module/es5/Validate/string/core.js

@@ -5,6 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.string = void 0;
 var _core = require("../../Validate/core");
+var _standardSchema = require("../../Validate/standardSchema");
 /**
  * String validation core module
  * Provides the base validation functionality for string values
@@ -18,7 +19,8 @@ var _core = require("../../Validate/core");
  * @returns {Function} - Validator function that checks if the value is a string and applies validation rules
  */
 var string = exports.string = function string(option, message) {
-  return function (value) {
+  var validator = function validator(value) {
     return (0, _core.core)("string")(value, option, message);
   };
+  return (0, _standardSchema.attachStandard)(validator);
 };

package/module/es5/Validate/templateLiteral/core.d.ts

@@ -6,6 +6,7 @@
  * an auto-generated regular expression assembled from the parts, while the
  * inferred type is the corresponding TypeScript template literal type.
  */
+import { type StandardSchemaV1 } from "../../Validate/standardSchema";
 import type { ValidateType } from "../../Validate/type";
 export type TemplateLiteralAnyValidator = (value?: any) => {
     type: unknown;
@@ -51,4 +52,4 @@ export interface TemplateLiteralReturnType<T extends string> {
  * @param {string} [message] - Custom error message for validation failure
  * @returns {Function} - Validator function for template literal strings
  */
-export declare const templateLiteral: <const Parts extends readonly TemplateLiteralPart[]>(parts: Parts, message?: string) => (value: BuildTemplateLiteral<Parts>) => TemplateLiteralReturnType<BuildTemplateLiteral<Parts>>;
+export declare const templateLiteral: <const Parts extends readonly TemplateLiteralPart[]>(parts: Parts, message?: string) => ((value: BuildTemplateLiteral<Parts>) => TemplateLiteralReturnType<BuildTemplateLiteral<Parts>>) & StandardSchemaV1<BuildTemplateLiteral<Parts>, BuildTemplateLiteral<Parts>>;

package/module/es5/Validate/templateLiteral/core.js

@@ -4,11 +4,8 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.templateLiteral = void 0;
+var _standardSchema = require("../../Validate/standardSchema");
 var _templateObject, _templateObject2, _templateObject3;
-function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
-function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
-function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
-function _taggedTemplateLiteral(e, t) { return t || (t = e.slice(0)), Object.freeze(Object.defineProperties(e, { raw: { value: Object.freeze(t) } })); }
 /**
  * Template literal validation core module
  * Provides a validator that checks whether a string matches a template
@@ -17,7 +14,10 @@ function _taggedTemplateLiteral(e, t) { return t || (t = e.slice(0)), Object.fre
  * an auto-generated regular expression assembled from the parts, while the
  * inferred type is the corresponding TypeScript template literal type.
  */
-
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+function _taggedTemplateLiteral(e, t) { return t || (t = e.slice(0)), Object.freeze(Object.defineProperties(e, { raw: { value: Object.freeze(t) } })); }
 // biome-ignore lint/suspicious/noExplicitAny: validator signatures vary
 
 /**
@@ -97,7 +97,7 @@ var templateLiteral = exports.templateLiteral = function templateLiteral(parts,
   }
   pattern += "$";
   var regex = new RegExp(pattern);
-  return function (value) {
+  var templateValidator = function templateValidator(value) {
     if (typeof value !== "string" || !regex.test(value)) {
       return {
         validate: false,
@@ -111,4 +111,5 @@ var templateLiteral = exports.templateLiteral = function templateLiteral(parts,
       type: value
     };
   };
+  return (0, _standardSchema.attachStandard)(templateValidator);
 };

package/module/es5/Validate/unknown/core.d.ts

@@ -3,6 +3,7 @@
  * Provides a validator that accepts any value but exposes it as `unknown`
  * to keep callers honest about narrowing before use.
  */
+import { type StandardSchemaV1 } from "../../Validate/standardSchema";
 /**
  * Return type produced by an `unknown` validator. Exposes the literal
  * `"unknown"` tag through the `type` field so `ValidateType<"unknown">` can
@@ -18,4 +19,4 @@ export interface UnknownReturnType {
  * Creates a validator that accepts any value but typed as unknown
  * @returns {Function} - Validator that always succeeds
  */
-export declare const unknown: () => ((value: unknown) => UnknownReturnType);
+export declare const unknown: () => ((value: unknown) => UnknownReturnType) & StandardSchemaV1<unknown, unknown>;

package/module/es5/Validate/unknown/core.js

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.unknown = void 0;
+var _standardSchema = require("../../Validate/standardSchema");
 /**
  * Unknown validation core module
  * Provides a validator that accepts any value but exposes it as `unknown`
@@ -24,11 +25,12 @@ var unknownValidator = function unknownValidator(_value) {
     type: "unknown"
   };
 };
+var standardUnknownValidator = (0, _standardSchema.attachStandard)(unknownValidator);
 
 /**
  * Creates a validator that accepts any value but typed as unknown
  * @returns {Function} - Validator that always succeeds
  */
 var unknown = exports.unknown = function unknown() {
-  return unknownValidator;
+  return standardUnknownValidator;
 };

package/package.json

@@ -9,18 +9,18 @@
     "@babel/core": "7.29.0",
     "@babel/preset-env": "7.29.5",
     "@babel/preset-typescript": "7.28.5",
-    "@biomejs/biome": "2.4.14",
+    "@biomejs/biome": "2.4.15",
     "@codecov/bundle-analyzer": "2.0.1",
     "@eslint/js": "10.0.1",
     "@swc/core": "1.15.33",
     "@swc/jest": "0.2.39",
-    "@types/bun": "1.3.13",
+    "@types/bun": "1.3.14",
     "@types/jest": "30.0.0",
     "@types/lodash": "4.17.24",
-    "@types/node": "25.6.0",
-    "@typescript-eslint/eslint-plugin": "8.59.2",
-    "@typescript-eslint/parser": "8.59.2",
-    "bun-types": "1.3.13",
+    "@types/node": "25.7.0",
+    "@typescript-eslint/eslint-plugin": "8.59.3",
+    "@typescript-eslint/parser": "8.59.3",
+    "bun-types": "1.3.14",
     "dependency-cruiser": "17.4.0",
     "es-toolkit": "1.46.1",
     "eslint": "10.3.0",
@@ -29,7 +29,7 @@
     "eslint-plugin-unicorn": "64.0.0",
     "fast-sort": "3.4.1",
     "gh-pages": "6.3.0",
-    "jest": "30.3.0",
+    "jest": "30.4.2",
     "jest-junit": "17.0.0",
     "lodash": "4.18.1",
     "mitata": "1.0.34",
@@ -40,7 +40,7 @@
     "typedoc-github-wiki-theme": "2.1.0",
     "typedoc-plugin-markdown": "4.11.0",
     "typescript": "6.0.3",
-    "typescript-eslint": "8.59.2"
+    "typescript-eslint": "8.59.3"
   },
   "exports": {
     ".": {
@@ -226,5 +226,5 @@
   },
   "type": "module",
   "types": "module/index.d.ts",
-  "version": "3.1.0"
+  "version": "3.2.0"
 }