@henderea/arg-helper 1.2.2 → 1.2.4

package/package.json

@@ -1,19 +1,37 @@
 {
   "name": "@henderea/arg-helper",
-  "version": "1.2.2",
+  "version": "1.2.4",
   "description": "A utility wrapper around the arg command-line parser",
   "main": "src/index.js",
   "types": "src/index.d.ts",
   "repository": "git@github.com:henderea/arg-helper.git",
   "author": "Eric Henderson <henderea@gmail.com>",
   "license": "MIT",
+  "scripts": {
+    "lint": "eslint src",
+    "lint:fix": "eslint --fix src"
+  },
   "peerDependencies": {
     "arg": "5.x"
   },
   "dependencies": {
     "escalade": "^3.1.1"
   },
+  "devDependencies": {
+    "@typescript-eslint/eslint-plugin": "^5.58.0",
+    "@typescript-eslint/parser": "^5.58.0",
+    "eslint": "^8.38.0",
+    "eslint-config-henderea": "1.1.7",
+    "eslint-plugin-import": "^2.27.5",
+    "typescript": "^5.0.4"
+  },
   "files": [
     "src/**/*"
-  ]
+  ],
+  "eslintConfig": {
+    "extends": "henderea",
+    "rules": {
+      "@typescript-eslint/ban-types": 0
+    }
+  }
 }

package/src/index.d.ts

@@ -1,4 +1,4 @@
-declare function argHelper(arg: any): {argParser: argHelper.argParser};
+declare function argHelper(arg: any): { argParser: argHelper.argParser };
 
 declare namespace argHelper {
     export interface Map<V> {
@@ -19,10 +19,14 @@ declare namespace argHelper {
         findVersion(callerPath: string, ...names: Array<string>): this;
         version(packageJsonFile: string, ...names: Array<string>): this;
         parse(argv?: Array<any> | null): Map<any>;
-        readonly argv: Map<any>;
+        get argv(): Map<any>;
+        static terminalWidth(multiplier?: number): number;
     }
 
-    export type argParser = () => ArgParser;
+    export interface argParser {
+        (): ArgParser;
+        terminalWidth(multiplier?: number): number;
+    }
 }
 
-export = argHelper;
+export = argHelper;

package/src/index.js

@@ -2,85 +2,95 @@ const fs = require('fs');
 const escalade = require('escalade/sync');
 
 class ArgParser {
-    constructor(arg) {
-        this._arg = arg;
-        this._opts = {};
-        this._names = {};
-        this._helpText = null;
-        this._packageJsonFile = null;
-    }
+  constructor(arg) {
+    this._arg = arg;
+    this._opts = {};
+    this._names = {};
+    this._helpText = null;
+    this._packageJsonFile = null;
+  }
 
-    flag(name, ...names) {
-        let type = names.pop();
-        let mainName = names.shift();
-        this._opts[mainName] = type;
-        this._names[mainName] = name;
-        if(names.length > 0) {
-            names.forEach(n => {
-                this._opts[n] = mainName;
-            });
-        }
-        return this;
-    }
-    flags(name, ...names) {
-        let type = names.pop();
-        return this.flag(name, ...names, [type]);
+  flag(name, ...names) {
+    let type = names.pop();
+    let mainName = names.shift();
+    this._opts[mainName] = type;
+    this._names[mainName] = name;
+    if(names.length > 0) {
+      names.forEach((n) => {
+        this._opts[n] = mainName;
+      });
     }
+    return this;
+  }
+  flags(name, ...names) {
+    let type = names.pop();
+    return this.flag(name, ...names, [type]);
+  }
 
-    string(name, ...names) { return this.flag(name, ...names, String); }
-    strings(name, ...names) { return this.flags(name, ...names, String); }
-    bool(name, ...names) { return this.flag(name, ...names, Boolean); }
-    bools(name, ...names) { return this.flags(name, ...names, Boolean); }
-    number(name, ...names) { return this.flag(name, ...names, Number); }
-    numbers(name, ...names) { return this.flags(name, ...names, Number); }
-    count(name, ...names) { return this.flag(name, ...names, this._arg.COUNT); }
-    help(helpText, ...names) {
-        this._helpText = helpText;
-        return this.bool('help', ...names);
+  string(name, ...names) { return this.flag(name, ...names, String); }
+  strings(name, ...names) { return this.flags(name, ...names, String); }
+  bool(name, ...names) { return this.flag(name, ...names, Boolean); }
+  bools(name, ...names) { return this.flags(name, ...names, Boolean); }
+  number(name, ...names) { return this.flag(name, ...names, Number); }
+  numbers(name, ...names) { return this.flags(name, ...names, Number); }
+  count(name, ...names) { return this.flag(name, ...names, this._arg.COUNT); }
+  help(helpText, ...names) {
+    this._helpText = helpText;
+    return this.bool('help', ...names);
+  }
+  findVersion(callerPath, ...names) {
+    const packageJsonFile = escalade(callerPath, (dir, fileNames) => fileNames.includes('package.json') && 'package.json');
+    if(packageJsonFile && fs.existsSync(packageJsonFile)) {
+      this.version(packageJsonFile, ...names);
     }
-    findVersion(callerPath, ...names) {
-        const packageJsonFile = escalade(callerPath, (dir, fileNames) => fileNames.includes('package.json') && 'package.json');
-        if(packageJsonFile && fs.existsSync(packageJsonFile)) {
-            this.version(packageJsonFile, ...names);
-        }
-        return this;
+    return this;
+  }
+  version(packageJsonFile, ...names) {
+    this._packageJsonFile = packageJsonFile;
+    return this.bool('version', ...names);
+  }
+
+  parse(argv = null) {
+    let config = { permissive: true };
+    if(argv !== null) { config.argv = argv; }
+    let options = this._arg(this._opts, config);
+    let rv = {};
+    Object.keys(options).forEach((k) => {
+      rv[k] = options[k];
+      if(Object.prototype.hasOwnProperty.call(this._names, k)) {
+        rv[this._names[k]] = options[k];
+      }
+    });
+    if(this._helpText && rv.help) {
+      console.log(this._helpText);
+      process.exit(0);
     }
-    version(packageJsonFile, ...names) {
-        this._packageJsonFile = packageJsonFile;
-        return this.bool('version', ...names);
+    if(rv.version && this._packageJsonFile && fs.existsSync(this._packageJsonFile)) {
+      const packageJson = JSON.parse(fs.readFileSync(this._packageJsonFile));
+      const version = packageJson.version;
+      if(version) {
+        console.log(version);
+        process.exit(0);
+      }
     }
+    return rv;
+  }
 
-    parse(argv = null) {
-        let config = { permissive: true };
-        if(argv !== null) { config.argv = argv; }
-        let options = this._arg(this._opts, config);
-        let rv = {};
-        Object.keys(options).forEach(k => {
-            rv[k] = options[k];
-            if(this._names.hasOwnProperty(k)) {
-                rv[this._names[k]] = options[k];
-            }
-        });
-        if(this._helpText && rv.help) {
-            console.log(this._helpText);
-            process.exit(0);
-        }
-        if(rv.version && this._packageJsonFile && fs.existsSync(this._packageJsonFile)) {
-            const packageJson = JSON.parse(fs.readFileSync(this._packageJsonFile));
-            const version = packageJson.version;
-            if(version) {
-                console.log(version);
-                process.exit(0);
-            }
-        }
-        return rv;
-    }
+  get argv() {
+    return this.parse();
+  }
 
-    get argv() {
-        return this.parse();
+  static terminalWidth(multiplier = 1) {
+    const cols = process.stdout.columns;
+    if(cols) {
+      return Math.round(cols * multiplier);
     }
+    return undefined;
+  }
 }
 
 module.exports = (arg) => {
-    return { argParser: () => new ArgParser(arg) };
-}
+  const argParser = () => new ArgParser(arg);
+  argParser.terminalWidth = ArgParser.terminalWidth;
+  return { argParser };
+};