@reliverse/rempts 1.7.8 → 1.7.10

package/README.md

@@ -910,7 +910,7 @@ $ bun example/launcher/modern.ts build --entry "[foo.ts," "bar.ts]"
 ⚠   If you intended to pass a bracketed list, quote the whole value like: --entry "[a, b, c]"
 ```
 
-#### 6. All together
+#### 7. All together
 
 ```bash
 mycli input.txt --verbose --name Alice --count 3 --tags foo --tags bar
@@ -923,6 +923,66 @@ mycli input.txt --verbose --name Alice --count 3 --tags foo --tags bar
 #   }
 ```
 
+#### 8. Value Validation with `allowed`
+
+All argument types support an optional `allowed` property that restricts which values can be passed:
+
+```ts
+const main = defineCommand({
+  args: {
+    // Only allow specific string values
+    mode: {
+      type: "string",
+      allowed: ["development", "production", "test"],
+      description: "The mode to run in"
+    },
+    
+    // Only allow specific boolean values (e.g. if you only want true)
+    force: {
+      type: "boolean",
+      allowed: [true],
+      description: "Force the operation"
+    },
+    
+    // Only allow specific numbers
+    level: {
+      type: "number",
+      allowed: [1, 2, 3],
+      description: "The level to use"
+    },
+    
+    // Only allow specific values in an array
+    tags: {
+      type: "array",
+      allowed: ["web", "api", "mobile"],
+      description: "Tags to apply"
+    },
+    
+    // Only allow specific positional values
+    action: {
+      type: "positional",
+      allowed: ["build", "serve", "test"],
+      description: "The action to perform"
+    }
+  }
+});
+```
+
+If someone tries to pass a value that's not in the `allowed` list, they'll get a helpful error message:
+
+```bash
+mycli --mode staging
+# Error: Invalid value for --mode: staging. Allowed values are: development, production, test
+
+mycli --level 4
+# Error: Invalid value for --level: 4. Allowed values are: 1, 2, 3
+
+mycli --tags desktop
+# Error: Invalid value in array --tags: desktop. Allowed values are: web, api, mobile
+```
+
+The validation happens after type casting, so for example with numbers, the input will first be converted to a number and then checked against the allowed list.
+
 ## Contributing
 
 Bug report? Prompt idea? Want to build the best DX possible?
@@ -960,7 +1020,7 @@ All APIs are fully typed. See [`src/types.ts`](./src/types.ts) for advanced cust
 ## Related
 
 - [`@reliverse/cli`](https://npmjs.com/package/@reliverse/cli) – CLI-first toolkit for fullstack workflows
-- [`@reliverse/reliarg`](https://npmjs.com/package/@reliverse/reliarg) – Tiny, strict, zero-dep argument parser
+- [`@reliverse/reliarg`](https://npmjs.com/package/@reliverse/reliarg) – Tiny, strict, zero-dep argument parser with value validation support (`allowed` property for restricting argument values)
 - [`@reliverse/reglob`](https://npmjs.com/package/@reliverse/reglob) – Fast, minimal file matcher
 - [`@reliverse/relinka`](https://npmjs.com/package/@reliverse/relinka) – Styled CLI logs, steps, and symbols
 

package/bin/components/launcher/launcher-mod.d.ts

@@ -3,6 +3,7 @@ type EmptyArgs = Record<string, never>;
 type BaseArgProps = {
     description?: string;
     required?: boolean;
+    allowed?: string[];
 };
 type PositionalArgDefinition = {
     type: "positional";
@@ -11,6 +12,7 @@ type PositionalArgDefinition = {
 type BooleanArgDefinition = {
     type: "boolean";
     default?: boolean;
+    allowed?: boolean[];
 } & BaseArgProps;
 type StringArgDefinition = {
     type: "string";
@@ -19,6 +21,7 @@ type StringArgDefinition = {
 type NumberArgDefinition = {
     type: "number";
     default?: number;
+    allowed?: number[];
 } & BaseArgProps;
 type ArrayArgDefinition = {
     type: "array";

package/bin/components/launcher/launcher-mod.js

@@ -654,25 +654,51 @@ function castArgValue(def, rawVal, argName) {
     }
     return def.default ?? void 0;
   }
+  let castedValue;
   switch (def.type) {
     case "boolean":
       if (typeof rawVal === "string") {
         const lower = rawVal.toLowerCase();
-        if (lower === "true") return true;
-        if (lower === "false") return false;
+        if (lower === "true") castedValue = true;
+        else if (lower === "false") castedValue = false;
+        else castedValue = Boolean(rawVal);
+      } else {
+        castedValue = Boolean(rawVal);
+      }
+      if (def.allowed && !def.allowed.includes(castedValue)) {
+        throw new Error(
+          `Invalid value for --${argName}: ${rawVal}. Allowed values are: ${def.allowed.join(", ")}`
+        );
       }
-      return Boolean(rawVal);
+      return castedValue;
     case "string":
-      return typeof rawVal === "string" ? rawVal : String(rawVal);
+      castedValue = typeof rawVal === "string" ? rawVal : String(rawVal);
+      if (def.allowed && !def.allowed.includes(castedValue)) {
+        throw new Error(
+          `Invalid value for --${argName}: ${rawVal}. Allowed values are: ${def.allowed.join(", ")}`
+        );
+      }
+      return castedValue;
     case "number": {
       const n = Number(rawVal);
       if (Number.isNaN(n)) {
         throw new Error(`Invalid number provided for --${argName}: ${rawVal}`);
       }
+      if (def.allowed && !def.allowed.includes(n)) {
+        throw new Error(
+          `Invalid value for --${argName}: ${rawVal}. Allowed values are: ${def.allowed.join(", ")}`
+        );
+      }
       return n;
     }
     case "positional":
-      return String(rawVal);
+      castedValue = String(rawVal);
+      if (def.allowed && !def.allowed.includes(castedValue)) {
+        throw new Error(
+          `Invalid value for <${argName}>: ${rawVal}. Allowed values are: ${def.allowed.join(", ")}`
+        );
+      }
+      return castedValue;
     case "array": {
       const arrVal = Array.isArray(rawVal) ? rawVal : [String(rawVal)];
       const result = [];
@@ -705,6 +731,11 @@ function castArgValue(def, rawVal, argName) {
               `Array argument --${argName}: Quoted values are not supported due to shell parsing limitations. Please avoid using single or double quotes around array elements.`
             );
           }
+          if (def.allowed && !def.allowed.includes(p)) {
+            throw new Error(
+              `Invalid value in array --${argName}: ${p}. Allowed values are: ${def.allowed.join(", ")}`
+            );
+          }
         });
         result.push(...parts);
       }

package/package.json

@@ -28,7 +28,7 @@
   "license": "MIT",
   "name": "@reliverse/rempts",
   "type": "module",
-  "version": "1.7.8",
+  "version": "1.7.10",
   "author": "reliverse",
   "bugs": {
     "email": "blefnk@gmail.com",
@@ -44,7 +44,7 @@
   "devDependencies": {
     "@biomejs/biome": "1.9.4",
     "@eslint/js": "^9.26.0",
-    "@reliverse/dler": "^1.2.3",
+    "@reliverse/dler": "^1.2.4",
     "@reliverse/relidler-cfg": "^1.1.3",
     "@stylistic/eslint-plugin": "^4.2.0",
     "@total-typescript/ts-reset": "^0.6.1",