@oclif/core 3.0.4 → 3.0.5

package/lib/parser/parse.js

@@ -78,8 +78,92 @@ class Parser {
         this.booleanFlags = (0, util_1.pickBy)(input.flags, (f) => f.type === 'boolean');
         this.flagAliases = Object.fromEntries(Object.values(input.flags).flatMap((flag) => [...(flag.aliases ?? []), ...(flag.charAliases ?? [])].map((a) => [a, flag])));
     }
-    get _argTokens() {
-        return this.raw.filter((o) => o.type === 'arg');
+    async parse() {
+        this._debugInput();
+        const parseFlag = (arg) => {
+            const { isLong, name } = this.findFlag(arg);
+            if (!name) {
+                const i = arg.indexOf('=');
+                if (i !== -1) {
+                    const sliced = arg.slice(i + 1);
+                    this.argv.unshift(sliced);
+                    const equalsParsed = parseFlag(arg.slice(0, i));
+                    if (!equalsParsed) {
+                        this.argv.shift();
+                    }
+                    return equalsParsed;
+                }
+                return false;
+            }
+            const flag = this.input.flags[name];
+            if (flag.type === 'option') {
+                if (!flag.multiple && this.raw.some((o) => o.type === 'flag' && o.flag === name)) {
+                    throw new errors_1.CLIError(`Flag --${name} can only be specified once`);
+                }
+                this.currentFlag = flag;
+                const input = isLong || arg.length < 3 ? this.argv.shift() : arg.slice(arg[2] === '=' ? 3 : 2);
+                // if the value ends up being one of the command's flags, the user didn't provide an input
+                if (typeof input !== 'string' || this.findFlag(input).name) {
+                    throw new errors_1.CLIError(`Flag --${name} expects a value`);
+                }
+                this.raw.push({ flag: flag.name, input, type: 'flag' });
+            }
+            else {
+                this.raw.push({ flag: flag.name, input: arg, type: 'flag' });
+                // push the rest of the short characters back on the stack
+                if (!isLong && arg.length > 2) {
+                    this.argv.unshift(`-${arg.slice(2)}`);
+                }
+            }
+            return true;
+        };
+        let parsingFlags = true;
+        const nonExistentFlags = [];
+        let dashdash = false;
+        const originalArgv = [...this.argv];
+        while (this.argv.length > 0) {
+            const input = this.argv.shift();
+            if (parsingFlags && input.startsWith('-') && input !== '-') {
+                // attempt to parse as arg
+                if (this.input['--'] !== false && input === '--') {
+                    parsingFlags = false;
+                    continue;
+                }
+                if (parseFlag(input)) {
+                    continue;
+                }
+                if (input === '--') {
+                    dashdash = true;
+                    continue;
+                }
+                if (this.input['--'] !== false && !isNegativeNumber(input)) {
+                    // At this point we have a value that begins with '-' or '--'
+                    // but doesn't match up to a flag definition. So we assume that
+                    // this is a misspelled flag or a non-existent flag,
+                    // e.g. --hekp instead of --help
+                    nonExistentFlags.push(input);
+                    continue;
+                }
+            }
+            if (parsingFlags && this.currentFlag && this.currentFlag.multiple) {
+                this.raw.push({ flag: this.currentFlag.name, input, type: 'flag' });
+                continue;
+            }
+            // not a flag, parse as arg
+            const arg = Object.keys(this.input.args)[this._argTokens.length];
+            this.raw.push({ arg, input, type: 'arg' });
+        }
+        const [{ args, argv }, { flags, metadata }] = await Promise.all([this._args(), this._flags()]);
+        this._debugOutput(argv, args, flags);
+        const unsortedArgv = (dashdash ? [...argv, ...nonExistentFlags, '--'] : [...argv, ...nonExistentFlags]);
+        return {
+            args: args,
+            argv: unsortedArgv.sort((a, b) => originalArgv.indexOf(a) - originalArgv.indexOf(b)),
+            flags,
+            metadata,
+            nonExistentFlags,
+            raw: this.raw,
+        };
     }
     async _args() {
         const argv = [];
@@ -127,6 +211,9 @@ class Parser {
         }
         return { args, argv };
     }
+    get _argTokens() {
+        return this.raw.filter((o) => o.type === 'arg');
+    }
     _debugInput() {
         debug('input: %s', this.argv.join(' '));
         const args = Object.keys(this.input.args);
@@ -360,92 +447,5 @@ class Parser {
         }
         return flagTokenMap;
     }
-    async parse() {
-        this._debugInput();
-        const parseFlag = (arg) => {
-            const { isLong, name } = this.findFlag(arg);
-            if (!name) {
-                const i = arg.indexOf('=');
-                if (i !== -1) {
-                    const sliced = arg.slice(i + 1);
-                    this.argv.unshift(sliced);
-                    const equalsParsed = parseFlag(arg.slice(0, i));
-                    if (!equalsParsed) {
-                        this.argv.shift();
-                    }
-                    return equalsParsed;
-                }
-                return false;
-            }
-            const flag = this.input.flags[name];
-            if (flag.type === 'option') {
-                if (!flag.multiple && this.raw.some((o) => o.type === 'flag' && o.flag === name)) {
-                    throw new errors_1.CLIError(`Flag --${name} can only be specified once`);
-                }
-                this.currentFlag = flag;
-                const input = isLong || arg.length < 3 ? this.argv.shift() : arg.slice(arg[2] === '=' ? 3 : 2);
-                // if the value ends up being one of the command's flags, the user didn't provide an input
-                if (typeof input !== 'string' || this.findFlag(input).name) {
-                    throw new errors_1.CLIError(`Flag --${name} expects a value`);
-                }
-                this.raw.push({ flag: flag.name, input, type: 'flag' });
-            }
-            else {
-                this.raw.push({ flag: flag.name, input: arg, type: 'flag' });
-                // push the rest of the short characters back on the stack
-                if (!isLong && arg.length > 2) {
-                    this.argv.unshift(`-${arg.slice(2)}`);
-                }
-            }
-            return true;
-        };
-        let parsingFlags = true;
-        const nonExistentFlags = [];
-        let dashdash = false;
-        const originalArgv = [...this.argv];
-        while (this.argv.length > 0) {
-            const input = this.argv.shift();
-            if (parsingFlags && input.startsWith('-') && input !== '-') {
-                // attempt to parse as arg
-                if (this.input['--'] !== false && input === '--') {
-                    parsingFlags = false;
-                    continue;
-                }
-                if (parseFlag(input)) {
-                    continue;
-                }
-                if (input === '--') {
-                    dashdash = true;
-                    continue;
-                }
-                if (this.input['--'] !== false && !isNegativeNumber(input)) {
-                    // At this point we have a value that begins with '-' or '--'
-                    // but doesn't match up to a flag definition. So we assume that
-                    // this is a misspelled flag or a non-existent flag,
-                    // e.g. --hekp instead of --help
-                    nonExistentFlags.push(input);
-                    continue;
-                }
-            }
-            if (parsingFlags && this.currentFlag && this.currentFlag.multiple) {
-                this.raw.push({ flag: this.currentFlag.name, input, type: 'flag' });
-                continue;
-            }
-            // not a flag, parse as arg
-            const arg = Object.keys(this.input.args)[this._argTokens.length];
-            this.raw.push({ arg, input, type: 'arg' });
-        }
-        const [{ args, argv }, { flags, metadata }] = await Promise.all([this._args(), this._flags()]);
-        this._debugOutput(argv, args, flags);
-        const unsortedArgv = (dashdash ? [...argv, ...nonExistentFlags, '--'] : [...argv, ...nonExistentFlags]);
-        return {
-            args: args,
-            argv: unsortedArgv.sort((a, b) => originalArgv.indexOf(a) - originalArgv.indexOf(b)),
-            flags,
-            metadata,
-            nonExistentFlags,
-            raw: this.raw,
-        };
-    }
 }
 exports.Parser = Parser;

package/lib/performance.d.ts

@@ -30,12 +30,12 @@ declare class Marker {
     owner: string;
     name: string;
     details: Details;
-    private startMarker;
-    private stopMarker;
     method: string;
     module: string;
     scope: string;
     stopped: boolean;
+    private startMarker;
+    private stopMarker;
     constructor(owner: string, name: string, details?: Details);
     addDetails(details: Details): void;
     measure(): void;

package/lib/performance.js

@@ -8,12 +8,12 @@ class Marker {
     owner;
     name;
     details;
-    startMarker;
-    stopMarker;
     method;
     module;
     scope;
     stopped = false;
+    startMarker;
+    stopMarker;
     constructor(owner, name, details = {}) {
         this.owner = owner;
         this.name = name;

package/lib/util/fs.d.ts

@@ -1,7 +1,19 @@
 export declare function requireJson<T>(...pathParts: string[]): T;
-export declare function exists(path: string): Promise<boolean>;
+/**
+ * Parser for Args.directory and Flags.directory. Checks that the provided path
+ * exists and is a directory.
+ * @param input flag or arg input
+ * @returns Promise<string>
+ */
 export declare const dirExists: (input: string) => Promise<string>;
+/**
+ * Parser for Args.file and Flags.file. Checks that the provided path
+ * exists and is a file.
+ * @param input flag or arg input
+ * @returns Promise<string>
+ */
 export declare const fileExists: (input: string) => Promise<string>;
 export declare function readJson<T = unknown>(path: string): Promise<T>;
 export declare function readJsonSync(path: string, parse: false): string;
 export declare function readJsonSync<T = unknown>(path: string, parse?: true): T;
+export declare function safeReadJson<T>(path: string): Promise<T | undefined>;

package/lib/util/fs.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.readJsonSync = exports.readJson = exports.fileExists = exports.dirExists = exports.exists = exports.requireJson = void 0;
+exports.safeReadJson = exports.readJsonSync = exports.readJson = exports.fileExists = exports.dirExists = exports.requireJson = void 0;
 const node_fs_1 = require("node:fs");
 const promises_1 = require("node:fs/promises");
 const node_path_1 = require("node:path");
@@ -9,32 +9,40 @@ function requireJson(...pathParts) {
     return JSON.parse((0, node_fs_1.readFileSync)((0, node_path_1.join)(...pathParts), 'utf8'));
 }
 exports.requireJson = requireJson;
-async function exists(path) {
+/**
+ * Parser for Args.directory and Flags.directory. Checks that the provided path
+ * exists and is a directory.
+ * @param input flag or arg input
+ * @returns Promise<string>
+ */
+const dirExists = async (input) => {
+    let dirStat;
     try {
-        await (0, promises_1.access)(path);
-        return true;
+        dirStat = await (0, promises_1.stat)(input);
     }
     catch {
-        return false;
-    }
-}
-exports.exists = exists;
-const dirExists = async (input) => {
-    if (!(await exists(input))) {
         throw new Error(`No directory found at ${input}`);
     }
-    const fileStat = await (0, promises_1.stat)(input);
-    if (!fileStat.isDirectory()) {
+    if (!dirStat.isDirectory()) {
         throw new Error(`${input} exists but is not a directory`);
     }
     return input;
 };
 exports.dirExists = dirExists;
+/**
+ * Parser for Args.file and Flags.file. Checks that the provided path
+ * exists and is a file.
+ * @param input flag or arg input
+ * @returns Promise<string>
+ */
 const fileExists = async (input) => {
-    if (!(await exists(input))) {
+    let fileStat;
+    try {
+        fileStat = await (0, promises_1.stat)(input);
+    }
+    catch {
         throw new Error(`No file found at ${input}`);
     }
-    const fileStat = await (0, promises_1.stat)(input);
     if (!fileStat.isFile()) {
         throw new Error(`${input} exists but is not a file`);
     }
@@ -52,3 +60,10 @@ function readJsonSync(path, parse = true) {
     return parse ? JSON.parse(contents) : contents;
 }
 exports.readJsonSync = readJsonSync;
+async function safeReadJson(path) {
+    try {
+        return await readJson(path);
+    }
+    catch { }
+}
+exports.safeReadJson = safeReadJson;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@oclif/core",
   "description": "base library for oclif CLIs",
-  "version": "3.0.4",
+  "version": "3.0.5",
   "author": "Salesforce",
   "bugs": "https://github.com/oclif/core/issues",
   "dependencies": {
@@ -61,9 +61,8 @@
     "cross-env": "^7.0.3",
     "eslint": "^8.50.0",
     "eslint-config-oclif": "^5.0.0",
-    "eslint-config-oclif-typescript": "^2.0.1",
+    "eslint-config-oclif-typescript": "^3.0.1",
     "eslint-config-prettier": "^9.0.0",
-    "eslint-plugin-perfectionist": "^2.1.0",
     "fancy-test": "^3.0.1",
     "globby": "^11.1.0",
     "husky": "^8",