@briklab/malle 1.0.1 → 1.0.3

package/index.js

@@ -8,12 +8,13 @@
  * @example
  * import malle from "@briklab/malle";
  * function calc(...args) {
- *   const {Number1, Number2, Mode} = malle.expect(
+ *   const {Number1, Number2, Mode} = malle({mode:"strict"}).expect(
  *     {name:"Number1", type:"number"},
  *     {name:"Number2", type:"number"},
  *     {name:"Mode", type:"string"}
- *   );
+ *   ).guess(args);
  *   return Mode === "add" ? Number1 + Number2 : Number1 - Number2;
  * }
  */
-export * from "./core/main.js";
+export { default } from "./core/main.js";
+export * from "./core/main.js";

package/package.json

@@ -1,21 +1,21 @@
 {
   "name": "@briklab/malle",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "A fast, flexible, developer-first argument parser for modern JavaScript and Node.js.",
   "main": "index.js",
   "publishConfig": {
     "access": "public"
   },
+  "exports": {
+    ".": "./index.js",
+    "./class": "./class/index.js"
+  },
   "private": false,
   "keywords": [],
   "author": "EkaanshPC",
   "license": "Apache 2.0",
   "files": [
-    "class/**",
-    "core/**",
-    "helpers/**",
-    "index.js",
-    "index.cjs"
+    "index.js"
   ],
   "scripts": {}
 }

package/class/index.cjs

@@ -1,3 +0,0 @@
-const main = require("../core/class");
-
-module.exports = main

package/class/index.js

@@ -1,8 +0,0 @@
-/**
- * @packageDocumentation
- * exports the class instead of malle function.
- * @example
- * new MalleClass({mode:"strict"}).expect({name:"string",type:"string"}).guess("lol")
- */
-export { default } from "../core/class"
-export * from "../core/class"

package/core/class.js

@@ -1,294 +0,0 @@
-//-----------------------------------------------------------------------------------------------------------
-//#region Helpers
-import getArrFromSpread, { areAllTypes } from "../helpers/arrHelpers";
-import { cM } from "../helpers/consoleManager";
-import isUndefined from "../helpers/isUndefined";
-import loop from "../helpers/loop";
-import checkFormat from "../helpers/objHelpers";
-import isType from "../helpers/typeHelpers";
-
-const expector = {
-  checkSchemas(schemas, debug = false) {
-    const schemasArr = getArrFromSpread(schemas);
-    if (!schemasArr) {
-      new cM.error("Could not get array from spread in expector.", debug);
-      return false;
-    }
-
-    if (!areAllTypes(schemasArr, "object")) {
-      new cM.error("The schema array must consist of only objects.", debug);
-      return false;
-    }
-
-    for (const schema of schemasArr) {
-      if (
-        !checkFormat(
-          { name: "string", type: "string", optional: "boolean", aliasNames: "array", spread: "boolean" },
-          schema,
-        )
-      ) {
-        new cM.error(
-          "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;
-  },
-};
-
-const guessor = {
-  guessBy(args, schemas, mode, debug = false) {
-    if (debug) {
-      cM.log(`[Malle] guessing with mode: ${mode}`, true);
-      cM.log(["args:", args], true);
-      cM.log(["schemas:", schemas], true);
-    }
-
-    if (mode === "loose") return this.looseModeGuessor(args, schemas, debug);
-    return this.strictModeGuessor(args, schemas, debug);
-  },
-  /**
-   *
-   * @param {Array} args
-   * @param {Array} schemas
-   * @param {"strict"|"loose"} mode
-   * @param {Boolean} debug
-   */
-  looseModeGuessor(args, schemas, debug) {
-    const result = {};
-    const errors = [];
-    const consumed = new Set();
-
-    for (let s = 0; s < schemas.length; s++) {
-      const schema = schemas[s];
-      let found = false;
-
-      for (let a = 0; a < args.length; a++) {
-        if (consumed.has(a)) continue;
-        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;
-        }
-      }
-
-      if (!found) {
-        for (let a = 0; a < args.length; a++) {
-          if (consumed.has(a)) continue;
-          if (isType(args[a], schema.type)) {
-            result[schema.name] = args[a];
-            consumed.add(a);
-            found = true;
-            break;
-          }
-        }
-      }
-
-      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}' (loose mode)`,
-          });
-        }
-      }
-    }
-
-    const success = errors.length === 0;
-    const report = Object.assign({}, result, { __DidSucceed: success, __errors: errors });
-    if (!success && debug) cM.log(["malle: loose-mode guess errors", errors], true);
-    return report;
-  },  strictModeGuessor(args, schemas, debug) {
-    const result = {};
-    const errors = [];
-    let onArgCounter = 0;
-
-    for (let s = 0; s < schemas.length; s++) {
-      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")) {
-          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) {
-        if (schema.spread) {
-          let elemType = null;
-          if (typeof schema.type === "string") {
-            if (/\[\]$/.test(schema.type)) elemType = schema.type.replace(/\[\]$/, "");
-            else elemType = schema.type;
-          }
-
-          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 {
-          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}'`,
-            });
-          }
-        }
-      }
-    }
-
-    const success = errors.length === 0;
-    const report = Object.assign({}, result, { __DidSucceed: success, __errors: errors });
-    if (!success && debug) cM.log(["malle: guess errors", errors], true);
-    return report;
-  },
-};
-//#endregion Helpers
-//-----------------------------------------------------------------------------------------------------------
-//#region Main Class
-/**
- * Class representing a Malle argument parser instance.
- */
-export default class MalleClass {
-  #modes = ["strict", "loose"];
-  #mode = "strict";
-  #debug = false;
-
-  #isValidMode(mode) {
-    return this.#modes.includes(mode);
-  }
-
-  constructor(config = {}) {
-    const { mode, debug } = config;
-
-    if (!isUndefined(mode) && this.#isValidMode(mode)) {
-      this.#mode = mode;
-    }
-
-    if (!isUndefined(debug)) {
-      this.#debug = !!debug;
-    }
-  }
-
-  setDebug(value) {
-    this.#debug = !!value;
-    return this;
-  }
-
-  setMode(mode) {
-    if (this.#isValidMode(mode)) {
-      this.#mode = mode;
-    }
-    return this;
-  }
-
-  /**
-   * Define expected argument schemas
-   */
-  expect(...schemas) {
-    const arr = expector.checkSchemas(schemas, this.#debug);
-    if (!arr) return false;
-
-    return {
-      guess: (...args) =>
-        guessor.guessBy(getArrFromSpread(args), arr, this.#mode, this.#debug),
-    };
-  }
-}
-//#endregion Main Class
-//-----------------------------------------------------------------------------------------------------------

package/core/main.js

@@ -1,46 +0,0 @@
-import MalleClass from "./class";
-
-/**
- * The **Malle** argument parser.
- *
- * Allows functions to accept arguments in **any order**, infer intent, 
- * and validate inputs according to schemas.
- * 
- * @param {Object} [config] - Optional configuration object.
- * @param {"strict"|"loose"} [config.mode="strict"] - Parsing mode.
- *        - `"strict"`: matches types and positional args conservatively.
- *        - `"loose"`: more permissive (order-agnostic, type-aliases such as `arr`/`array` allowed).
- * @param {boolean} [config.debug=false] - If `true`, prints debug info to console.
- *
- * @returns {MalleClass}
- *
- * @remarks
- * The object returned by `expect(...).guess(...)` contains the matched keys
- * plus two meta-keys:
- *  - `__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";
- * 
- * function calc(...args) {
- *   const { Number1, Number2, Mode, __DidSucceed } = malle({mode: "strict"})
- *     .expect(
- *       {name:"Number1", type:"number"},
- *       {name:"Number2", type:"number"},
- *       {name:"Mode", type:"string"}
- *     );
- *     
- *   if(!__DidSucceed) return;
- *   return Mode === "add" ? Number1 + Number2 : Number1 - Number2;
- * }
- */
-export default function malle(config) {
-    return new MalleClass(config)
-}
-

package/helpers/arrHelpers.js

@@ -1,14 +0,0 @@
-import isType from "./typeHelpers";
-
-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;
-}

package/helpers/consoleManager.js

@@ -1,22 +0,0 @@
-export const cM = {
-  __name: "Malle",
-  error: class extends Error {
-    constructor(message, debug = false) {
-      super(message);
-      this.name = cM.__name;
-
-      if (debug) {
-        console.log(
-          "%c[Malle]: Error: %c",
-          "color:red;font-weight:bold;",
-          message,
-          ""
-        );
-      }
-    }
-  },
-  log(message,debug){
-    if(!debug)return
-    console.log("%c[Malle] Log: %c","color:lime;font-weight:bold;","",message)
-  }
-};

package/helpers/isUndefined.js

@@ -1 +0,0 @@
-export default function isUndefined(a){return typeof a === "undefined"}

package/helpers/loop.js

@@ -1 +0,0 @@
-export default function loop(t,f,...a){for(let i=0;i<t;i++){f(...a)}}

package/helpers/objHelpers.js

@@ -1,8 +0,0 @@
-import isType from "./typeHelpers";
-
-export default function checkFormat(format,object){
-    for (const [key,value] of Object.entries(format)) {
-        if(!isType(object[key],value)&&!isType(object[key],"undefined"))return false    
-    }
-    return true
-}

package/helpers/typeHelpers.js

@@ -1,50 +0,0 @@
-const typeofvalidtypes = [
-  "boolean",
-  "number",
-  "function",
-  "object",
-  "string",
-  "symbol",
-  "undefined",
-];
-
-const aliasMap = {
-  arr: "array",
-  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).trim();
-
-  // union (e.g. "string|number[]")
-  if (raw.includes("|")) {
-    return raw.split("|").map((p) => p.trim()).some((part) => isType(stuff, part));
-  }
-
-  // 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.cjs

@@ -1,3 +0,0 @@
-const main = require("./core/main.js");
-
-module.exports = main