@devp0nt/route0 1.0.0-next.65 → 1.0.0-next.67

package/dist/esm/index.js

@@ -434,76 +434,171 @@ class Route0 {
       unmatched
     };
   }
-  /**
-   * Safe parser for flat input objects.
-   *
-   * Returns structured success/error result instead of throwing.
-   */
-  safeParseFlatInput(input, loose) {
-    loose ??= this.hasLooseSearch;
+  _validateParamsInput(input) {
     const paramsKeys = this.getParamsKeys();
     if (input === void 0) {
       if (paramsKeys.length) {
         return {
-          success: false,
-          data: void 0,
-          error: new Error(`Missing params: ${paramsKeys.map((k) => `"${k}"`).join(", ")}`)
+          issues: [
+            {
+              message: `Missing params: ${paramsKeys.map((k) => `"${k}"`).join(", ")}`
+            }
+          ]
         };
       }
       input = {};
     }
     if (typeof input !== "object" || input === null) {
       return {
-        success: false,
-        data: void 0,
-        error: new Error("Invalid input: expected object")
+        issues: [{ message: "Invalid input: expected object" }]
       };
     }
-    const inputKeys = Object.keys(input);
+    const inputObj = input;
+    const inputKeys = Object.keys(inputObj);
     const notDefinedKeys = paramsKeys.filter((k) => !inputKeys.includes(k));
     if (notDefinedKeys.length) {
       return {
-        success: false,
-        data: void 0,
-        error: new Error(`Missing params: ${notDefinedKeys.map((k) => `"${k}"`).join(", ")}`)
+        issues: [
+          {
+            message: `Missing params: ${notDefinedKeys.map((k) => `"${k}"`).join(", ")}`
+          }
+        ]
       };
     }
     const data = {};
-    const filterKeys = !loose ? [...paramsKeys, ...this.getSearchKeys()] : false;
-    for (const [k, v] of Object.entries(input)) {
-      if (filterKeys && !filterKeys.includes(k)) {
-        continue;
+    for (const k of paramsKeys) {
+      const v = inputObj[k];
+      if (typeof v === "string") {
+        data[k] = v;
+      } else if (typeof v === "number") {
+        data[k] = String(v);
+      } else {
+        return {
+          issues: [{ message: `Invalid input: expected string, number, got ${typeof v} for "${k}"` }]
+        };
       }
+    }
+    return {
+      value: data
+    };
+  }
+  _validateSearchInput(input, loose) {
+    if (input === void 0) {
+      input = {};
+    }
+    if (typeof input !== "object" || input === null) {
+      return {
+        issues: [{ message: "Invalid input: expected object" }]
+      };
+    }
+    const inputObj = input;
+    const paramsKeys = this.getParamsKeys();
+    const searchKeys = this.getSearchKeys();
+    const data = {};
+    for (const [k, v] of Object.entries(inputObj)) {
+      if (k === "hash") continue;
+      if (paramsKeys.includes(k)) continue;
+      if (!loose && !searchKeys.includes(k)) continue;
+      if (v === void 0) continue;
       if (typeof v === "string") {
         data[k] = v;
       } else if (typeof v === "number") {
         data[k] = String(v);
       } else {
-        const isParamKey = paramsKeys.includes(k);
         return {
-          success: false,
-          data: void 0,
-          error: new Error(
-            `Invalid input: expected string, number,${!isParamKey ? " or undefined," : ""} got ${typeof v} for "${k}"`
-          )
+          issues: [{ message: `Invalid input: expected string, number, or undefined, got ${typeof v} for "${k}"` }]
         };
       }
     }
     return {
-      success: true,
-      data,
-      error: void 0
+      value: data
+    };
+  }
+  _validateFlatInput(input, loose) {
+    const paramsResult = this._validateParamsInput(input);
+    if ("issues" in paramsResult) {
+      return {
+        issues: paramsResult.issues ?? []
+      };
+    }
+    const searchResult = this._validateSearchInput(input, loose);
+    if ("issues" in searchResult) {
+      return {
+        issues: searchResult.issues ?? []
+      };
+    }
+    return {
+      value: {
+        ...searchResult.value,
+        ...paramsResult.value
+      }
     };
   }
-  /** Throwing variant of `safeParseFlatInput()`. */
-  parseFlatInput(input, loose) {
-    loose ??= this.hasLooseSearch;
-    const result = this.safeParseFlatInput(input, loose);
-    if (result.error) {
-      throw result.error;
+  _safeParseSchemaResult(result) {
+    if ("issues" in result) {
+      return {
+        success: false,
+        data: void 0,
+        error: new Error(result.issues?.[0]?.message ?? "Invalid input")
+      };
     }
-    return result.data;
+    return {
+      success: true,
+      data: result.value,
+      error: void 0
+    };
   }
+  _parseSchemaResult(result) {
+    const safeResult = this._safeParseSchemaResult(result);
+    if (safeResult.error) {
+      throw safeResult.error;
+    }
+    return safeResult.data;
+  }
+  /** Standard Schema for route params input. */
+  paramsInputSchema = {
+    "~standard": {
+      version: 1,
+      vendor: "route0",
+      validate: (value) => this._validateParamsInput(value),
+      types: void 0
+    },
+    parse: (value) => this._parseSchemaResult(this._validateParamsInput(value)),
+    safeParse: (value) => this._safeParseSchemaResult(this._validateParamsInput(value))
+  };
+  /** Standard Schema for strict search input. */
+  strictSearchInputSchema = {
+    "~standard": {
+      version: 1,
+      vendor: "route0",
+      validate: (value) => this._validateSearchInput(value, false),
+      types: void 0
+    },
+    parse: (value) => this._parseSchemaResult(this._validateSearchInput(value, false)),
+    safeParse: (value) => this._safeParseSchemaResult(this._validateSearchInput(value, false))
+  };
+  /** Standard Schema for loose search input. */
+  looseSearchInputSchema = {
+    "~standard": {
+      version: 1,
+      vendor: "route0",
+      validate: (value) => this._validateSearchInput(value, true),
+      types: void 0
+    },
+    parse: (value) => this._parseSchemaResult(this._validateSearchInput(value, true)),
+    safeParse: (value) => this._safeParseSchemaResult(this._validateSearchInput(value, true))
+  };
+  /** Standard Schema for route flat input (uses route default strict/loose mode). */
+  flatInputSchema = {
+    "~standard": {
+      version: 1,
+      vendor: "route0",
+      validate: (value) => this._validateFlatInput(value, this.hasLooseSearch),
+      types: void 0
+    },
+    parse: (value) => this._parseSchemaResult(this._validateFlatInput(value, this.hasLooseSearch)),
+    safeParse: (value) => this._safeParseSchemaResult(this._validateFlatInput(value, this.hasLooseSearch))
+  };
   /** True when path structure is equal (param names are ignored). */
   isSame(other) {
     return this.pathDefinition.replace(/:([A-Za-z0-9_]+)/g, "__PARAM__") === other.pathDefinition.replace(/:([A-Za-z0-9_]+)/g, "__PARAM__");