@oclif/core 3.0.0-beta.9 → 3.0.0

package/lib/util/aggregate-flags.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.aggregateFlags = void 0;
+const flags_1 = require("../flags");
+const json = (0, flags_1.boolean)({
+    description: 'Format output as json.',
+    helpGroup: 'GLOBAL',
+});
+function aggregateFlags(flags, baseFlags, enableJsonFlag) {
+    const combinedFlags = { ...baseFlags, ...flags };
+    return (enableJsonFlag ? { json, ...combinedFlags } : combinedFlags);
+}
+exports.aggregateFlags = aggregateFlags;

package/lib/util/cache-command.d.ts

@@ -0,0 +1,3 @@
+import { Command } from '../command';
+import { Plugin as IPlugin } from '../interfaces/plugin';
+export declare function cacheCommand(uncachedCmd: Command.Class, plugin?: IPlugin, respectNoCacheDefault?: boolean): Promise<Command.Cached>;

package/lib/util/cache-command.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cacheCommand = void 0;
+const aggregate_flags_1 = require("./aggregate-flags");
+const cache_default_value_1 = require("./cache-default-value");
+const ensure_arg_object_1 = require("./ensure-arg-object");
+const util_1 = require("./util");
+// In order to collect static properties up the inheritance chain, we need to recursively
+// access the prototypes until there's nothing left. This allows us to combine baseFlags
+// and flags as well as add in the json flag if enableJsonFlag is enabled.
+function mergePrototype(result, cmd) {
+    const proto = Object.getPrototypeOf(cmd);
+    const filteredProto = (0, util_1.pickBy)(proto, (v) => v !== undefined);
+    return Object.keys(proto).length > 0 ? mergePrototype({ ...filteredProto, ...result }, proto) : result;
+}
+async function cacheFlags(cmdFlags, respectNoCacheDefault) {
+    const promises = Object.entries(cmdFlags).map(async ([name, flag]) => [
+        name,
+        {
+            aliases: flag.aliases,
+            char: flag.char,
+            charAliases: flag.charAliases,
+            dependsOn: flag.dependsOn,
+            deprecateAliases: flag.deprecateAliases,
+            deprecated: flag.deprecated,
+            description: flag.description,
+            exclusive: flag.exclusive,
+            helpGroup: flag.helpGroup,
+            helpLabel: flag.helpLabel,
+            hidden: flag.hidden,
+            name,
+            noCacheDefault: flag.noCacheDefault,
+            relationships: flag.relationships,
+            required: flag.required,
+            summary: flag.summary,
+            ...(flag.type === 'boolean'
+                ? {
+                    allowNo: flag.allowNo,
+                    type: flag.type,
+                }
+                : {
+                    default: await (0, cache_default_value_1.cacheDefaultValue)(flag, respectNoCacheDefault),
+                    delimiter: flag.delimiter,
+                    hasDynamicHelp: typeof flag.defaultHelp === 'function',
+                    helpValue: flag.helpValue,
+                    multiple: flag.multiple,
+                    options: flag.options,
+                    type: flag.type,
+                }),
+        },
+    ]);
+    return Object.fromEntries(await Promise.all(promises));
+}
+async function cacheArgs(cmdArgs, respectNoCacheDefault) {
+    const promises = Object.entries(cmdArgs).map(async ([name, arg]) => [
+        name,
+        {
+            default: await (0, cache_default_value_1.cacheDefaultValue)(arg, respectNoCacheDefault),
+            description: arg.description,
+            hidden: arg.hidden,
+            name,
+            noCacheDefault: arg.noCacheDefault,
+            options: arg.options,
+            required: arg.required,
+        },
+    ]);
+    return Object.fromEntries(await Promise.all(promises));
+}
+async function cacheCommand(uncachedCmd, plugin, respectNoCacheDefault = false) {
+    const cmd = mergePrototype(uncachedCmd, uncachedCmd);
+    const flags = await cacheFlags((0, aggregate_flags_1.aggregateFlags)(cmd.flags, cmd.baseFlags, cmd.enableJsonFlag), respectNoCacheDefault);
+    const args = await cacheArgs((0, ensure_arg_object_1.ensureArgObject)(cmd.args), respectNoCacheDefault);
+    const stdProperties = {
+        aliases: cmd.aliases || [],
+        args,
+        deprecateAliases: cmd.deprecateAliases,
+        deprecationOptions: cmd.deprecationOptions,
+        description: cmd.description,
+        examples: cmd.examples || cmd.example,
+        flags,
+        hasDynamicHelp: Object.values(flags).some((f) => f.hasDynamicHelp),
+        hidden: cmd.hidden,
+        id: cmd.id,
+        pluginAlias: plugin && plugin.alias,
+        pluginName: plugin && plugin.name,
+        pluginType: plugin && plugin.type,
+        state: cmd.state,
+        strict: cmd.strict,
+        summary: cmd.summary,
+        usage: cmd.usage,
+    };
+    // do not include these properties in manifest
+    const ignoreCommandProperties = [
+        'plugin',
+        '_flags',
+        '_enableJsonFlag',
+        '_globalFlags',
+        '_baseFlags',
+        'baseFlags',
+        '_--',
+        '_base',
+    ];
+    // Add in any additional properties that are not standard command properties.
+    const stdKeysAndIgnored = new Set([...Object.keys(stdProperties), ...ignoreCommandProperties]);
+    const keysToAdd = Object.keys(cmd).filter((property) => !stdKeysAndIgnored.has(property));
+    const additionalProperties = Object.fromEntries(keysToAdd.map((key) => [key, cmd[key]]));
+    return { ...stdProperties, ...additionalProperties };
+}
+exports.cacheCommand = cacheCommand;

package/lib/util/cache-default-value.d.ts

@@ -0,0 +1,2 @@
+import { Arg, OptionFlag } from '../interfaces/parser';
+export declare const cacheDefaultValue: (flagOrArg: Arg<any> | OptionFlag<any>, respectNoCacheDefault: boolean) => Promise<any>;

package/lib/util/cache-default-value.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cacheDefaultValue = void 0;
+// when no manifest exists, the default is calculated.  This may throw, so we need to catch it
+const cacheDefaultValue = async (flagOrArg, respectNoCacheDefault) => {
+    if (respectNoCacheDefault && flagOrArg.noCacheDefault)
+        return;
+    // Prefer the defaultHelp function (returns a friendly string for complex types)
+    if (typeof flagOrArg.defaultHelp === 'function') {
+        try {
+            return await flagOrArg.defaultHelp({ flags: {}, options: flagOrArg });
+        }
+        catch {
+            return;
+        }
+    }
+    // if not specified, try the default function
+    if (typeof flagOrArg.default === 'function') {
+        try {
+            return await flagOrArg.default({ flags: {}, options: flagOrArg });
+        }
+        catch { }
+    }
+    else {
+        return flagOrArg.default;
+    }
+};
+exports.cacheDefaultValue = cacheDefaultValue;

package/lib/util/ensure-arg-object.d.ts

@@ -0,0 +1,12 @@
+import { Command } from '../command';
+import { ArgInput } from '../interfaces/parser';
+/**
+ * Ensure that the provided args are an object. This is for backwards compatibility with v1 commands which
+ * defined args as an array.
+ *
+ * @param args Either an array of args or an object of args
+ * @returns ArgInput
+ */
+export declare function ensureArgObject(args?: {
+    [name: string]: Command.Arg.Cached;
+} | ArgInput | any[]): ArgInput;

package/lib/util/ensure-arg-object.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureArgObject = void 0;
+/**
+ * Ensure that the provided args are an object. This is for backwards compatibility with v1 commands which
+ * defined args as an array.
+ *
+ * @param args Either an array of args or an object of args
+ * @returns ArgInput
+ */
+function ensureArgObject(args) {
+    return (Array.isArray(args) ? (args ?? []).reduce((x, y) => ({ ...x, [y.name]: y }), {}) : args ?? {});
+}
+exports.ensureArgObject = ensureArgObject;

package/lib/util/fs.d.ts

@@ -0,0 +1,7 @@
+export declare function requireJson<T>(...pathParts: string[]): T;
+export declare function exists(path: string): Promise<boolean>;
+export declare const dirExists: (input: string) => 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;

package/lib/util/fs.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readJsonSync = exports.readJson = exports.fileExists = exports.dirExists = exports.exists = 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");
+const debug = require('debug');
+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) {
+    try {
+        await (0, promises_1.access)(path);
+        return true;
+    }
+    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()) {
+        throw new Error(`${input} exists but is not a directory`);
+    }
+    return input;
+};
+exports.dirExists = dirExists;
+const fileExists = async (input) => {
+    if (!(await exists(input))) {
+        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`);
+    }
+    return input;
+};
+exports.fileExists = fileExists;
+async function readJson(path) {
+    debug('config')('readJson %s', path);
+    const contents = await (0, promises_1.readFile)(path, 'utf8');
+    return JSON.parse(contents);
+}
+exports.readJson = readJson;
+function readJsonSync(path, parse = true) {
+    const contents = (0, node_fs_1.readFileSync)(path, 'utf8');
+    return parse ? JSON.parse(contents) : contents;
+}
+exports.readJsonSync = readJsonSync;

package/lib/util/os.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="node" />
+/**
+ * Call os.homedir() and return the result
+ *
+ * Wrapping this allows us to stub these in tests since os.homedir() is
+ * non-configurable and non-writable.
+ *
+ * @returns The user's home directory
+ */
+export declare function getHomeDir(): string;
+/**
+ * Call os.platform() and return the result
+ *
+ * Wrapping this allows us to stub these in tests since os.platform() is
+ * non-configurable and non-writable.
+ *
+ * @returns The process' platform
+ */
+export declare function getPlatform(): NodeJS.Platform;

package/lib/util/os.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPlatform = exports.getHomeDir = void 0;
+const node_os_1 = require("node:os");
+/**
+ * Call os.homedir() and return the result
+ *
+ * Wrapping this allows us to stub these in tests since os.homedir() is
+ * non-configurable and non-writable.
+ *
+ * @returns The user's home directory
+ */
+function getHomeDir() {
+    return (0, node_os_1.homedir)();
+}
+exports.getHomeDir = getHomeDir;
+/**
+ * Call os.platform() and return the result
+ *
+ * Wrapping this allows us to stub these in tests since os.platform() is
+ * non-configurable and non-writable.
+ *
+ * @returns The process' platform
+ */
+function getPlatform() {
+    return (0, node_os_1.platform)();
+}
+exports.getPlatform = getPlatform;

package/lib/{util.d.ts → util/util.d.ts}

@@ -1,31 +1,22 @@
-import { Command } from './command';
-import { ArgInput } from './interfaces/parser';
 export declare function pickBy<T extends {
     [s: string]: T[keyof T];
 } | ArrayLike<T[keyof T]>>(obj: T, fn: (i: T[keyof T]) => boolean): Partial<T>;
 export declare function compact<T>(a: (T | undefined)[]): T[];
 export declare function uniqBy<T>(arr: T[], fn: (cur: T) => any): T[];
 export declare function last<T>(arr?: T[]): T | undefined;
-type SortTypes = string | number | undefined | boolean;
+type SortTypes = boolean | number | string | undefined;
 export declare function sortBy<T>(arr: T[], fn: (i: T) => SortTypes | SortTypes[]): T[];
 export declare function castArray<T>(input?: T | T[]): T[];
 export declare function isProd(): boolean;
 export declare function maxBy<T>(arr: T[], fn: (i: T) => number): T | undefined;
 export declare function sumBy<T>(arr: T[], fn: (i: T) => number): number;
 export declare function capitalize(s: string): string;
-export declare const dirExists: (input: string) => Promise<string>;
-export declare const fileExists: (input: string) => Promise<string>;
 export declare function isTruthy(input: string): boolean;
 export declare function isNotFalsy(input: string): boolean;
-export declare function requireJson<T>(...pathParts: string[]): T;
-/**
- * Ensure that the provided args are an object. This is for backwards compatibility with v1 commands which
- * defined args as an array.
- *
- * @param args Either an array of args or an object of args
- * @returns ArgInput
- */
-export declare function ensureArgObject(args?: any[] | ArgInput | {
-    [name: string]: Command.Arg.Cached;
-}): ArgInput;
+export declare function uniq<T>(arr: T[]): T[];
+export declare function mapValues<T extends Record<string, any>, TResult>(obj: {
+    [P in keyof T]: T[P];
+}, fn: (i: T[keyof T], k: keyof T) => TResult): {
+    [P in keyof T]: TResult;
+};
 export {};

package/lib/util/util.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapValues = exports.uniq = exports.isNotFalsy = exports.isTruthy = exports.capitalize = exports.sumBy = exports.maxBy = exports.isProd = exports.castArray = exports.sortBy = exports.last = exports.uniqBy = exports.compact = exports.pickBy = void 0;
+function pickBy(obj, fn) {
+    return Object.entries(obj).reduce((o, [k, v]) => {
+        if (fn(v))
+            o[k] = v;
+        return o;
+    }, {});
+}
+exports.pickBy = pickBy;
+function compact(a) {
+    // eslint-disable-next-line unicorn/prefer-native-coercion-functions
+    return a.filter((a) => Boolean(a));
+}
+exports.compact = compact;
+function uniqBy(arr, fn) {
+    return arr.filter((a, i) => {
+        const aVal = fn(a);
+        return !arr.some((b, j) => j > i && fn(b) === aVal);
+    });
+}
+exports.uniqBy = uniqBy;
+function last(arr) {
+    if (!arr)
+        return;
+    return arr.at(-1);
+}
+exports.last = last;
+function compare(a, b) {
+    a = a === undefined ? 0 : a;
+    b = b === undefined ? 0 : b;
+    if (Array.isArray(a) && Array.isArray(b)) {
+        if (a.length === 0 && b.length === 0)
+            return 0;
+        const diff = compare(a[0], b[0]);
+        if (diff !== 0)
+            return diff;
+        return compare(a.slice(1), b.slice(1));
+    }
+    if (a < b)
+        return -1;
+    if (a > b)
+        return 1;
+    return 0;
+}
+function sortBy(arr, fn) {
+    return arr.sort((a, b) => compare(fn(a), fn(b)));
+}
+exports.sortBy = sortBy;
+function castArray(input) {
+    if (input === undefined)
+        return [];
+    return Array.isArray(input) ? input : [input];
+}
+exports.castArray = castArray;
+function isProd() {
+    return !['development', 'test'].includes(process.env.NODE_ENV ?? '');
+}
+exports.isProd = isProd;
+function maxBy(arr, fn) {
+    if (arr.length === 0) {
+        return undefined;
+    }
+    return arr.reduce((maxItem, i) => {
+        const curr = fn(i);
+        const max = fn(maxItem);
+        return curr > max ? i : maxItem;
+    });
+}
+exports.maxBy = maxBy;
+function sumBy(arr, fn) {
+    return arr.reduce((sum, i) => sum + fn(i), 0);
+}
+exports.sumBy = sumBy;
+function capitalize(s) {
+    return s ? s.charAt(0).toUpperCase() + s.slice(1).toLowerCase() : '';
+}
+exports.capitalize = capitalize;
+function isTruthy(input) {
+    return ['1', 'true', 'y', 'yes'].includes(input.toLowerCase());
+}
+exports.isTruthy = isTruthy;
+function isNotFalsy(input) {
+    return !['0', 'false', 'n', 'no'].includes(input.toLowerCase());
+}
+exports.isNotFalsy = isNotFalsy;
+function uniq(arr) {
+    return [...new Set(arr)].sort();
+}
+exports.uniq = uniq;
+function mapValues(obj, fn) {
+    return Object.entries(obj).reduce((o, [k, v]) => {
+        o[k] = fn(v, k);
+        return o;
+    }, {});
+}
+exports.mapValues = mapValues;

package/package.json

@@ -1,11 +1,10 @@
 {
   "name": "@oclif/core",
   "description": "base library for oclif CLIs",
-  "version": "3.0.0-beta.9",
+  "version": "3.0.0",
   "author": "Salesforce",
   "bugs": "https://github.com/oclif/core/issues",
   "dependencies": {
-    "@types/cli-progress": "^3.11.0",
     "ansi-escapes": "^4.3.2",
     "ansi-styles": "^4.3.0",
     "cardinal": "^2.1.1",
@@ -28,32 +27,28 @@
     "strip-ansi": "^6.0.1",
     "supports-color": "^8.1.1",
     "supports-hyperlinks": "^2.2.0",
-    "ts-node": "^10.9.1",
-    "tslib": "^2.5.0",
     "widest-line": "^3.1.0",
     "wordwrap": "^1.0.0",
     "wrap-ansi": "^7.0.0"
   },
   "devDependencies": {
-    "@commitlint/config-conventional": "^12.1.4",
+    "@commitlint/config-conventional": "^17.7.0",
     "@oclif/plugin-help": "^5.2.8",
     "@oclif/plugin-plugins": "^3.3.0",
-    "@oclif/test": "^2.4.7",
+    "@oclif/prettier-config": "^0.2.1",
+    "@oclif/test": "^3.0.1",
     "@types/ansi-styles": "^3.2.1",
     "@types/benchmark": "^2.1.2",
     "@types/chai": "^4.3.4",
     "@types/chai-as-promised": "^7.1.5",
     "@types/clean-stack": "^2.1.1",
+    "@types/cli-progress": "^3.11.0",
     "@types/ejs": "^3.1.2",
-    "@types/glob": "^8.1.0",
     "@types/indent-string": "^4.0.1",
     "@types/js-yaml": "^3.12.7",
-    "@types/mocha": "^8.2.3",
-    "@types/nock": "^11.1.0",
-    "@types/node": "^16",
+    "@types/mocha": "^10.0.2",
+    "@types/node": "^18",
     "@types/node-notifier": "^8.0.2",
-    "@types/proxyquire": "^1.3.28",
-    "@types/shelljs": "^0.8.12",
     "@types/slice-ansi": "^4.0.0",
     "@types/strip-ansi": "^5.2.1",
     "@types/supports-color": "^8.1.1",
@@ -62,28 +57,36 @@
     "benchmark": "^2.1.4",
     "chai": "^4.3.7",
     "chai-as-promised": "^7.1.1",
-    "commitlint": "^12.1.4",
+    "commitlint": "^17.7.2",
     "cross-env": "^7.0.3",
-    "eslint": "^7.32.0",
-    "eslint-config-oclif": "^4.0.0",
-    "eslint-config-oclif-typescript": "^1.0.3",
-    "fancy-test": "^2.0.16",
+    "eslint": "^8.50.0",
+    "eslint-config-oclif": "^5.0.0",
+    "eslint-config-oclif-typescript": "^2.0.1",
+    "eslint-config-prettier": "^9.0.0",
+    "eslint-plugin-perfectionist": "^2.1.0",
+    "fancy-test": "^3.0.1",
     "globby": "^11.1.0",
-    "husky": "6",
+    "husky": "^8",
+    "lint-staged": "^14.0.1",
+    "madge": "^6.1.0",
     "mocha": "^10.2.0",
-    "nock": "^13.3.0",
-    "proxyquire": "^2.1.3",
-    "shelljs": "^0.8.5",
+    "nyc": "^15.1.0",
+    "prettier": "^3.0.3",
     "shx": "^0.3.4",
     "sinon": "^11.1.2",
-    "tsd": "^0.25.0",
-    "typescript": "^4.9.5"
+    "ts-node": "^10.9.1",
+    "tsd": "^0.29.0",
+    "tslib": "^2.5.0",
+    "typescript": "^5"
   },
   "engines": {
-    "node": ">=16.0.0"
+    "node": ">=18.0.0"
   },
   "files": [
-    "/lib"
+    "/lib",
+    "/flush.js",
+    "/flush.d.ts",
+    "/handle.js"
   ],
   "homepage": "https://github.com/oclif/core",
   "keywords": [
@@ -91,14 +94,6 @@
   ],
   "license": "MIT",
   "main": "./lib/index.js",
-  "exports": {
-    ".": "./lib/index.js",
-    "./execute": "./lib/execute.js",
-    "./flush": "./lib/ux/flush.js",
-    "./handle": "./lib/errors/handle.js",
-    "./run": "./lib/main.js",
-    "./settings": "./lib/settings.js"
-  },
   "repository": "oclif/core",
   "oclif": {
     "bin": "oclif",
@@ -114,14 +109,17 @@
     "build": "shx rm -rf lib && tsc",
     "commitlint": "commitlint",
     "compile": "tsc",
-    "lint": "eslint . --ext .ts --config .eslintrc",
-    "posttest": "yarn lint",
+    "format": "prettier --write \"+(src|test)/**/*.+(ts|js|json)\"",
+    "lint": "eslint . --ext .ts",
+    "posttest": "yarn lint && yarn test:circular-deps",
     "prepack": "yarn run build",
-    "pretest": "yarn build --noEmit && tsc -p test --noEmit --skipLibCheck",
+    "prepare": "husky install",
+    "pretest": "yarn build && tsc -p test --noEmit --skipLibCheck",
+    "test:circular-deps": "madge lib/ -c",
     "test:e2e": "mocha --forbid-only \"test/**/*.e2e.ts\" --parallel --timeout 1200000",
     "test:esm-cjs": "cross-env DEBUG=e2e:* ts-node test/integration/esm-cjs.ts",
     "test:perf": "ts-node test/perf/parser.perf.ts",
-    "test": "mocha --forbid-only \"test/**/*.test.ts\""
+    "test": "nyc mocha --forbid-only \"test/**/*.test.ts\""
   },
   "types": "lib/index.d.ts"
 }