@briklab/malle 1.0.0 → 1.0.1

package/core/class.js

@@ -23,18 +23,32 @@ const expector = {
     for (const schema of schemasArr) {
       if (
         !checkFormat(
-          { name: "string", type: "string", optional: "boolean" },
+          { name: "string", type: "string", optional: "boolean", aliasNames: "array", spread: "boolean" },
           schema,
         )
       ) {
         new cM.error(
-          "Invalid format in schema object. (expected {name, type, optional?})",
+          "Invalid format in schema object. (expected {name, type, optional?, aliasNames?, spread?})",
           debug,
         );
         return false;
       }
 
       schema.optional = !!schema.optional;
+      schema.spread = !!schema.spread;
+
+      if (!isUndefined(schema.aliasNames)) {
+        if (!Array.isArray(schema.aliasNames) || !areAllTypes(schema.aliasNames, "string")) {
+          new cM.error("schema.aliasNames must be an array of strings", debug);
+          return false;
+        }
+      } else {
+        schema.aliasNames = [];
+      }
+
+      if (!schema.spread && typeof schema.type === "string" && /\[\]$/.test(schema.type)) {
+        schema.spread = true;
+      }
     }
 
     return schemasArr;
@@ -62,7 +76,6 @@ const guessor = {
   looseModeGuessor(args, schemas, debug) {
     const result = {};
     const errors = [];
-
     const consumed = new Set();
 
     for (let s = 0; s < schemas.length; s++) {
@@ -71,11 +84,43 @@ const guessor = {
 
       for (let a = 0; a < args.length; a++) {
         if (consumed.has(a)) continue;
-        if (isType(args[a], "object") && !isUndefined(args[a][schema.name])) {
-          result[schema.name] = args[a][schema.name];
-          consumed.add(a);
+        if (isType(args[a], "object")) {
+          const keys = [schema.name].concat(schema.aliasNames || []);
+          for (const k of keys) {
+            if (!isUndefined(args[a][k])) {
+              result[schema.name] = args[a][k];
+              consumed.add(a);
+              found = true;
+              break;
+            }
+          }
+          if (found) break;
+        }
+      }
+
+      if (!found && schema.spread) {
+        let elemType = null;
+        if (typeof schema.type === "string") {
+          if (/\[\]$/.test(schema.type)) elemType = schema.type.replace(/\[\]$/, "");
+          else elemType = schema.type;
+        }
+
+        const collected = [];
+        for (let a = 0; a < args.length; a++) {
+          if (consumed.has(a)) continue;
+          if (isType(args[a], elemType)) {
+            collected.push(args[a]);
+            consumed.add(a);
+          }
+          else if (isType(args[a], elemType + "[]")) {
+            collected.push(...args[a]);
+            consumed.add(a);
+          }
+        }
+
+        if (collected.length > 0) {
+          result[schema.name] = collected;
           found = true;
-          break;
         }
       }
 
@@ -117,37 +162,72 @@ const guessor = {
       const schema = schemas[s];
       let found = false;
 
+      // 1) try named object property or any alias
       for (let a = 0; a < args.length; a++) {
         if (isType(args[a], "object")) {
-          if (!isUndefined(args[a][schema.name])) {
-            result[schema.name] = args[a][schema.name];
-            found = true;
-            break;
+          const keys = [schema.name].concat(schema.aliasNames || []);
+          for (const k of keys) {
+            if (!isUndefined(args[a][k])) {
+              result[schema.name] = args[a][k];
+              found = true;
+              break;
+            }
           }
+          if (found) break;
         }
       }
 
       if (!found) {
-        let consumedIndex = -1;
-        for (let i = onArgCounter; i < args.length; i++) {
-          if (isType(args[i], schema.type)) {
-            consumedIndex = i;
-            break;
+        if (schema.spread) {
+          let elemType = null;
+          if (typeof schema.type === "string") {
+            if (/\[\]$/.test(schema.type)) elemType = schema.type.replace(/\[\]$/, "");
+            else elemType = schema.type;
           }
-        }
 
-        if (consumedIndex !== -1) {
-          result[schema.name] = args[consumedIndex];
-          onArgCounter = consumedIndex + 1;
-          found = true;
-        } else if (schema.optional) {
-          result[schema.name] = undefined;
+          const collected = [];
+          let i = onArgCounter;
+          for (; i < args.length; i++) {
+            if (isType(args[i], elemType)) {
+              collected.push(args[i]);
+            } else break;
+          }
+
+          if (collected.length > 0) {
+            result[schema.name] = collected;
+            onArgCounter = i;
+            found = true;
+          } else if (isType(args[onArgCounter], elemType + "[]")) {
+            result[schema.name] = args[onArgCounter];
+            onArgCounter = onArgCounter + 1;
+            found = true;
+          }
         } else {
-          errors.push({
-            name: schema.name,
-            expected: schema.type,
-            message: `missing required argument '${schema.name}' of type '${schema.type}'`,
-          });
+          let consumedIndex = -1;
+          for (let i = onArgCounter; i < args.length; i++) {
+            if (isType(args[i], schema.type)) {
+              consumedIndex = i;
+              break;
+            }
+          }
+
+          if (consumedIndex !== -1) {
+            result[schema.name] = args[consumedIndex];
+            onArgCounter = consumedIndex + 1;
+            found = true;
+          }
+        }
+
+        if (!found) {
+          if (schema.optional) {
+            result[schema.name] = undefined;
+          } else {
+            errors.push({
+              name: schema.name,
+              expected: schema.type,
+              message: `missing required argument '${schema.name}' of type '${schema.type}'`,
+            });
+          }
         }
       }
     }

package/core/main.js

@@ -20,6 +20,11 @@ import MalleClass from "./class";
  *  - `__DidSucceed` (boolean) — true when all *required* schemas were satisfied
  *  - `__errors` (Array) — list of reported issues when parsing failed
  *
+ * Schema notes:
+ *  - `type` supports unions (`string|number`), generic arrays (`T[]`, e.g. `number[]`) and `any`.
+ *  - `aliasNames` accepts an array of alternate object-property names.
+ *  - `spread: true` collects multiple matching positional values into an array.
+ *
  * @example
  * import malle from "@briklab/malle";
  * 

package/helpers/arrHelpers.js

@@ -1,14 +1,14 @@
 import isType from "./typeHelpers";
 
-export default function getArrFromSpread(arr){
-    if(Array.isArray(arr))return arr;
-    if(Array.isArray(arr[0]))return arr;
-    return false
+export default function getArrFromSpread(args) {
+  if (!Array.isArray(args)) return false;
+  if (args.length === 1 && Array.isArray(args[0])) return args[0];
+  return args;
 }
 
-export function areAllTypes(arr,type){
-    for(let i=0;i<arr.length;i++){
-        if(!isType(arr[i],type))return false
-    }
-    return true
+export function areAllTypes(arr, type) {
+  for (let i = 0; i < arr.length; i++) {
+    if (!isType(arr[i], type)) return false;
+  }
+  return true;
 }

package/helpers/typeHelpers.js

@@ -13,19 +13,37 @@ const aliasMap = {
   array: "array",
   "[]": "array",
   null: "null",
+  any: "any",
 };
 
+function _isPrimitiveMatch(stuff, norm) {
+  if (norm === "array") return Array.isArray(stuff);
+  if (norm === "null") return stuff === null;
+  if (norm === "any") return true;
+  if (typeofvalidtypes.includes(norm)) return typeof stuff === norm;
+  return false;
+}
+
 export default function isType(stuff, type) {
   if (!type) return false;
-  const raw = String(type);
-  const t = raw.toLowerCase();
+  const raw = String(type).trim();
 
-  const norm = aliasMap[t] || t;
+  // union (e.g. "string|number[]")
+  if (raw.includes("|")) {
+    return raw.split("|").map((p) => p.trim()).some((part) => isType(stuff, part));
+  }
 
-  if (norm === "array") return Array.isArray(stuff);
-  if (norm === "null") return stuff === null;
-  if (typeofvalidtypes.includes(norm)) return typeof stuff === norm;
+  // array-of-type syntax (T[])
+  if (raw.endsWith("[]")) {
+    const elemType = raw.slice(0, -2) || "any";
+    if (!Array.isArray(stuff)) return false;
+    return stuff.every((el) => isType(el, elemType));
+  }
+
+  const t = raw.toLowerCase();
+  const norm = aliasMap[t] || t;
 
+  if (_isPrimitiveMatch(stuff, norm)) return true;
   if (raw === "Array") return Array.isArray(stuff);
 
   return false;

package/index.js

@@ -16,5 +16,4 @@
  *   return Mode === "add" ? Number1 + Number2 : Number1 - Number2;
  * }
  */
-export { default } from "./core/main.js";
-export * from "./core/main.js";
+export * from "./core/main.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@briklab/malle",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "A fast, flexible, developer-first argument parser for modern JavaScript and Node.js.",
   "main": "index.js",
   "publishConfig": {