@optique/valibot 1.0.0-dev.1344 → 1.0.0-dev.1359

package/dist/index.cjs

@@ -27,6 +27,148 @@ const valibot = __toESM(require("valibot"));
 
 //#region src/index.ts
 /**
+* Valibot transformation action types that are known to be non-rejecting and
+* type-preserving (they transform a string into a string without ever adding
+* issues).  All other transformation types (transform, raw_transform,
+* parse_json, to_number, to_boolean, etc.) may reject input or change the
+* value type.
+*/
+const SAFE_TRANSFORMATION_TYPES = new Set([
+	"trim",
+	"to_lower_case",
+	"to_upper_case",
+	"normalize",
+	"to_min_value",
+	"to_max_value",
+	"trim_start",
+	"trim_end",
+	"readonly",
+	"brand",
+	"flavor"
+]);
+/**
+* Checks whether a schema synchronously accepts every possible input value.
+* This includes:
+* - `v.unknown()`, `v.any()` (accept everything regardless of input type)
+* - Bare `v.string()` without a pipe (accepts every string)
+* - Any wrapper with a `wrapped` field pointing to a catch-all schema
+*   (e.g., `v.optional()`, `v.nullable()`, `v.nonOptional()`, etc.)
+*
+* Piped schemas are considered catch-all only when the base type is
+* `string`/`unknown`/`any` and every pipe action is a non-rejecting
+* transformation (not a validation or nested schema).
+*
+* @param afterTransform When true, only type-agnostic catch-alls
+*   (`v.unknown()`, `v.any()`) are recognized.  String-based catch-alls
+*   are not trusted since the input type may no longer be a string.
+*/
+function isCatchAllSchema(schema, afterTransform = false) {
+	const s = schema;
+	if (s.async) return false;
+	if ("fallback" in s) return true;
+	if (s.type === "unknown" || s.type === "any") {
+		if (!s.pipe) return true;
+		return s.pipe.slice(1).every((action) => {
+			const a = action;
+			if (a.kind === "validation") return false;
+			if (a.kind === "schema") return isCatchAllSchema(action, afterTransform);
+			return SAFE_TRANSFORMATION_TYPES.has(a.type ?? "");
+		});
+	}
+	if (!afterTransform && s.type === "string") {
+		if (!s.pipe) return true;
+		return s.pipe.slice(1).every((action) => {
+			const a = action;
+			if (a.kind === "validation") return false;
+			if (a.kind === "schema") return isCatchAllSchema(action, afterTransform);
+			return SAFE_TRANSFORMATION_TYPES.has(a.type ?? "");
+		});
+	}
+	if (s.wrapped && !s.pipe) return isCatchAllSchema(s.wrapped, afterTransform);
+	return false;
+}
+/**
+* Recursively checks whether a Valibot schema contains any async parts
+* (e.g., `pipeAsync`, `checkAsync`).  Wrapper schemas such as `optional()`,
+* `nullable()`, `nullish()`, and `union()` keep `async === false` on the
+* outer layer even when they wrap async inner schemas, so a shallow check
+* on the top-level `async` property is not sufficient.
+*
+* Known limitations:
+* - `v.variant()` arms are treated like union arms, but the catch-all
+*   detection does not recognize object-shaped variant arms.  Variant
+*   schemas with async arms after a broad discriminator will be
+*   conservatively rejected.
+* - `v.lazy()` schemas are not inspected because the getter depends on
+*   actual parse input, making static analysis unreliable.
+*
+* @param afterTransform When true, a preceding `v.transform()` may have
+*   changed the value type.  Container members become reachable and
+*   string-based union catch-all arms are no longer trusted.
+*/
+function containsAsyncSchema(schema, visited = /* @__PURE__ */ new WeakMap(), afterTransform = false) {
+	const prev = visited.get(schema);
+	if (prev !== void 0 && (prev || !afterTransform)) return false;
+	visited.set(schema, (prev ?? false) || afterTransform);
+	const s = schema;
+	if (s.async) return true;
+	if (s.wrapped && !s.pipe) return containsAsyncSchema(s.wrapped, visited, afterTransform);
+	if (s.options && Array.isArray(s.options)) {
+		if (s.type === "union") for (const option of s.options) {
+			if (typeof option !== "object" || option == null) continue;
+			if (isCatchAllSchema(option, afterTransform)) break;
+			if (containsAsyncSchema(option, visited, afterTransform)) return true;
+		}
+		else if (s.type === "variant") {
+			if (afterTransform) {
+				for (const option of s.options) if (typeof option === "object" && option != null) {
+					if (containsAsyncSchema(option, visited, true)) return true;
+				}
+			}
+		} else for (const option of s.options) if (typeof option === "object" && option != null) {
+			if (containsAsyncSchema(option, visited, afterTransform)) return true;
+		}
+	}
+	if (s.pipe && Array.isArray(s.pipe)) {
+		let seenTransform = afterTransform;
+		for (const action of s.pipe) {
+			if (action.async) return true;
+			const a = action;
+			if (a.kind === "transformation" && !SAFE_TRANSFORMATION_TYPES.has(a.type ?? "")) seenTransform = true;
+			if (a.kind === "schema") {
+				if (containsAsyncSchema(action, visited, seenTransform)) return true;
+				if (!seenTransform) {
+					const innerPipe = action.pipe;
+					if (innerPipe && Array.isArray(innerPipe)) for (const innerAction of innerPipe) {
+						const ia = innerAction;
+						if (ia.kind === "transformation" && !SAFE_TRANSFORMATION_TYPES.has(ia.type ?? "")) {
+							seenTransform = true;
+							break;
+						}
+					}
+				}
+			}
+		}
+	}
+	if (afterTransform) {
+		if (s.entries) {
+			for (const entry of Object.values(s.entries)) if (containsAsyncSchema(entry, visited, true)) return true;
+		}
+		if (s.item && containsAsyncSchema(s.item, visited, true)) return true;
+		if (s.items && Array.isArray(s.items)) {
+			for (const item of s.items) if (containsAsyncSchema(item, visited, true)) return true;
+		}
+		if (s.key && typeof s.key === "object" && containsAsyncSchema(s.key, visited, true)) return true;
+		if (s.value && containsAsyncSchema(s.value, visited, true)) return true;
+		if (s.rest && containsAsyncSchema(s.rest, visited, true)) return true;
+		if (s.type === "promise") {
+			const promiseInner = schema.message;
+			if (typeof promiseInner === "object" && promiseInner != null && "kind" in promiseInner && containsAsyncSchema(promiseInner, visited, true)) return true;
+		}
+	}
+	return false;
+}
+/**
 * Infers an appropriate metavar string from a Valibot schema.
 *
 * This function analyzes the Valibot schema's internal structure to determine
@@ -221,9 +363,12 @@ function inferChoices(schema) {
 * ```
 *
 * @throws {TypeError} If the resolved `metavar` is an empty string.
+* @throws {TypeError} If the schema contains async validations that cannot be
+*   executed synchronously.
 * @since 0.7.0
 */
 function valibot$1(schema, options = {}) {
+	if (containsAsyncSchema(schema)) throw new TypeError("Async Valibot schemas (e.g., async validations) are not supported by valibot(). Use synchronous schemas instead.");
 	const choices = inferChoices(schema);
 	const metavar = options.metavar ?? inferMetavar(schema);
 	(0, __optique_core_nonempty.ensureNonEmptyString)(metavar);

package/dist/index.d.cts

@@ -107,6 +107,8 @@ interface ValibotParserOptions {
  * ```
  *
  * @throws {TypeError} If the resolved `metavar` is an empty string.
+ * @throws {TypeError} If the schema contains async validations that cannot be
+ *   executed synchronously.
  * @since 0.7.0
  */
 declare function valibot<T>(schema: v.BaseSchema<unknown, T, v.BaseIssue<unknown>>, options?: ValibotParserOptions): ValueParser<"sync", T>;

package/dist/index.d.ts

@@ -107,6 +107,8 @@ interface ValibotParserOptions {
  * ```
  *
  * @throws {TypeError} If the resolved `metavar` is an empty string.
+ * @throws {TypeError} If the schema contains async validations that cannot be
+ *   executed synchronously.
  * @since 0.7.0
  */
 declare function valibot<T>(schema: v.BaseSchema<unknown, T, v.BaseIssue<unknown>>, options?: ValibotParserOptions): ValueParser<"sync", T>;

package/dist/index.js

@@ -4,6 +4,148 @@ import { safeParse } from "valibot";
 
 //#region src/index.ts
 /**
+* Valibot transformation action types that are known to be non-rejecting and
+* type-preserving (they transform a string into a string without ever adding
+* issues).  All other transformation types (transform, raw_transform,
+* parse_json, to_number, to_boolean, etc.) may reject input or change the
+* value type.
+*/
+const SAFE_TRANSFORMATION_TYPES = new Set([
+	"trim",
+	"to_lower_case",
+	"to_upper_case",
+	"normalize",
+	"to_min_value",
+	"to_max_value",
+	"trim_start",
+	"trim_end",
+	"readonly",
+	"brand",
+	"flavor"
+]);
+/**
+* Checks whether a schema synchronously accepts every possible input value.
+* This includes:
+* - `v.unknown()`, `v.any()` (accept everything regardless of input type)
+* - Bare `v.string()` without a pipe (accepts every string)
+* - Any wrapper with a `wrapped` field pointing to a catch-all schema
+*   (e.g., `v.optional()`, `v.nullable()`, `v.nonOptional()`, etc.)
+*
+* Piped schemas are considered catch-all only when the base type is
+* `string`/`unknown`/`any` and every pipe action is a non-rejecting
+* transformation (not a validation or nested schema).
+*
+* @param afterTransform When true, only type-agnostic catch-alls
+*   (`v.unknown()`, `v.any()`) are recognized.  String-based catch-alls
+*   are not trusted since the input type may no longer be a string.
+*/
+function isCatchAllSchema(schema, afterTransform = false) {
+	const s = schema;
+	if (s.async) return false;
+	if ("fallback" in s) return true;
+	if (s.type === "unknown" || s.type === "any") {
+		if (!s.pipe) return true;
+		return s.pipe.slice(1).every((action) => {
+			const a = action;
+			if (a.kind === "validation") return false;
+			if (a.kind === "schema") return isCatchAllSchema(action, afterTransform);
+			return SAFE_TRANSFORMATION_TYPES.has(a.type ?? "");
+		});
+	}
+	if (!afterTransform && s.type === "string") {
+		if (!s.pipe) return true;
+		return s.pipe.slice(1).every((action) => {
+			const a = action;
+			if (a.kind === "validation") return false;
+			if (a.kind === "schema") return isCatchAllSchema(action, afterTransform);
+			return SAFE_TRANSFORMATION_TYPES.has(a.type ?? "");
+		});
+	}
+	if (s.wrapped && !s.pipe) return isCatchAllSchema(s.wrapped, afterTransform);
+	return false;
+}
+/**
+* Recursively checks whether a Valibot schema contains any async parts
+* (e.g., `pipeAsync`, `checkAsync`).  Wrapper schemas such as `optional()`,
+* `nullable()`, `nullish()`, and `union()` keep `async === false` on the
+* outer layer even when they wrap async inner schemas, so a shallow check
+* on the top-level `async` property is not sufficient.
+*
+* Known limitations:
+* - `v.variant()` arms are treated like union arms, but the catch-all
+*   detection does not recognize object-shaped variant arms.  Variant
+*   schemas with async arms after a broad discriminator will be
+*   conservatively rejected.
+* - `v.lazy()` schemas are not inspected because the getter depends on
+*   actual parse input, making static analysis unreliable.
+*
+* @param afterTransform When true, a preceding `v.transform()` may have
+*   changed the value type.  Container members become reachable and
+*   string-based union catch-all arms are no longer trusted.
+*/
+function containsAsyncSchema(schema, visited = /* @__PURE__ */ new WeakMap(), afterTransform = false) {
+	const prev = visited.get(schema);
+	if (prev !== void 0 && (prev || !afterTransform)) return false;
+	visited.set(schema, (prev ?? false) || afterTransform);
+	const s = schema;
+	if (s.async) return true;
+	if (s.wrapped && !s.pipe) return containsAsyncSchema(s.wrapped, visited, afterTransform);
+	if (s.options && Array.isArray(s.options)) {
+		if (s.type === "union") for (const option of s.options) {
+			if (typeof option !== "object" || option == null) continue;
+			if (isCatchAllSchema(option, afterTransform)) break;
+			if (containsAsyncSchema(option, visited, afterTransform)) return true;
+		}
+		else if (s.type === "variant") {
+			if (afterTransform) {
+				for (const option of s.options) if (typeof option === "object" && option != null) {
+					if (containsAsyncSchema(option, visited, true)) return true;
+				}
+			}
+		} else for (const option of s.options) if (typeof option === "object" && option != null) {
+			if (containsAsyncSchema(option, visited, afterTransform)) return true;
+		}
+	}
+	if (s.pipe && Array.isArray(s.pipe)) {
+		let seenTransform = afterTransform;
+		for (const action of s.pipe) {
+			if (action.async) return true;
+			const a = action;
+			if (a.kind === "transformation" && !SAFE_TRANSFORMATION_TYPES.has(a.type ?? "")) seenTransform = true;
+			if (a.kind === "schema") {
+				if (containsAsyncSchema(action, visited, seenTransform)) return true;
+				if (!seenTransform) {
+					const innerPipe = action.pipe;
+					if (innerPipe && Array.isArray(innerPipe)) for (const innerAction of innerPipe) {
+						const ia = innerAction;
+						if (ia.kind === "transformation" && !SAFE_TRANSFORMATION_TYPES.has(ia.type ?? "")) {
+							seenTransform = true;
+							break;
+						}
+					}
+				}
+			}
+		}
+	}
+	if (afterTransform) {
+		if (s.entries) {
+			for (const entry of Object.values(s.entries)) if (containsAsyncSchema(entry, visited, true)) return true;
+		}
+		if (s.item && containsAsyncSchema(s.item, visited, true)) return true;
+		if (s.items && Array.isArray(s.items)) {
+			for (const item of s.items) if (containsAsyncSchema(item, visited, true)) return true;
+		}
+		if (s.key && typeof s.key === "object" && containsAsyncSchema(s.key, visited, true)) return true;
+		if (s.value && containsAsyncSchema(s.value, visited, true)) return true;
+		if (s.rest && containsAsyncSchema(s.rest, visited, true)) return true;
+		if (s.type === "promise") {
+			const promiseInner = schema.message;
+			if (typeof promiseInner === "object" && promiseInner != null && "kind" in promiseInner && containsAsyncSchema(promiseInner, visited, true)) return true;
+		}
+	}
+	return false;
+}
+/**
 * Infers an appropriate metavar string from a Valibot schema.
 *
 * This function analyzes the Valibot schema's internal structure to determine
@@ -198,9 +340,12 @@ function inferChoices(schema) {
 * ```
 *
 * @throws {TypeError} If the resolved `metavar` is an empty string.
+* @throws {TypeError} If the schema contains async validations that cannot be
+*   executed synchronously.
 * @since 0.7.0
 */
 function valibot(schema, options = {}) {
+	if (containsAsyncSchema(schema)) throw new TypeError("Async Valibot schemas (e.g., async validations) are not supported by valibot(). Use synchronous schemas instead.");
 	const choices = inferChoices(schema);
 	const metavar = options.metavar ?? inferMetavar(schema);
 	ensureNonEmptyString(metavar);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@optique/valibot",
-  "version": "1.0.0-dev.1344+e7f36975",
+  "version": "1.0.0-dev.1359+1fa707c2",
   "description": "Valibot value parsers for Optique",
   "keywords": [
     "CLI",
@@ -57,7 +57,7 @@
     "valibot": "^1.2.0"
   },
   "dependencies": {
-    "@optique/core": "1.0.0-dev.1344+e7f36975"
+    "@optique/core": "1.0.0-dev.1359+1fa707c2"
   },
   "devDependencies": {
     "@types/node": "^20.19.9",