@depup/nx 22.5.4-depup.0

package/src/utils/is-using-prettier.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isUsingPrettier = isUsingPrettier;
+exports.isUsingPrettierInTree = isUsingPrettierInTree;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const json_1 = require("../generators/utils/json");
+const fileutils_1 = require("./fileutils");
+/**
+ * Possible configuration files are taken from https://prettier.io/docs/configuration
+ */
+const configFiles = [
+    '.prettierrc',
+    '.prettierrc.json',
+    '.prettierrc.yml',
+    '.prettierrc.yaml',
+    '.prettierrc.json5',
+    '.prettierrc.js',
+    'prettier.config.js',
+    '.prettierrc.ts',
+    'prettier.config.ts',
+    '.prettierrc.mjs',
+    'prettier.config.mjs',
+    '.prettierrc.mts',
+    'prettier.config.mts',
+    '.prettierrc.cjs',
+    'prettier.config.cjs',
+    '.prettierrc.cts',
+    'prettier.config.cts',
+    '.prettierrc.toml',
+];
+function isUsingPrettier(root) {
+    for (const file of configFiles) {
+        if ((0, node_fs_1.existsSync)(file)) {
+            return true;
+        }
+    }
+    // Even if no file is present, it is possible the user is configuring prettier via their package.json
+    const packageJsonPath = (0, node_path_1.join)(root, 'package.json');
+    if ((0, node_fs_1.existsSync)(packageJsonPath)) {
+        const packageJson = (0, fileutils_1.readJsonFile)(packageJsonPath);
+        if (packageJson.prettier) {
+            return true;
+        }
+    }
+    return false;
+}
+function isUsingPrettierInTree(tree) {
+    for (const file of configFiles) {
+        if (tree.exists(file)) {
+            return true;
+        }
+    }
+    // Even if no file is present, it is possible the user is configuring prettier via their package.json
+    if (tree.exists('package.json')) {
+        const packageJson = (0, json_1.readJson)(tree, 'package.json');
+        if (packageJson.prettier) {
+            return true;
+        }
+    }
+    return false;
+}

package/src/utils/json-diff.d.ts

@@ -0,0 +1,19 @@
+import { Change } from '../project-graph/file-utils';
+export declare enum JsonDiffType {
+    Deleted = "JsonPropertyDeleted",
+    Added = "JsonPropertyAdded",
+    Modified = "JsonPropertyModified"
+}
+export interface JsonChange extends Change {
+    type: JsonDiffType;
+    path: string[];
+    value: {
+        lhs: any;
+        rhs: any;
+    };
+}
+export declare function isJsonChange(change: Change): change is JsonChange;
+export declare function jsonDiff(lhs: any, rhs: any): JsonChange[];
+export declare function walkJsonTree(json: any, currPath: string[], visitor: (path: string[], value: any) => boolean): void;
+export declare function deepEquals(a: any, b: any): boolean;
+//# sourceMappingURL=json-diff.d.ts.map

package/src/utils/json-diff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-diff.d.ts","sourceRoot":"","sources":["../../../../../packages/nx/src/utils/json-diff.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,6BAA6B,CAAC;AAErD,oBAAY,YAAY;IACtB,OAAO,wBAAwB;IAC/B,KAAK,sBAAsB;IAC3B,QAAQ,yBAAyB;CAClC;AAED,MAAM,WAAW,UAAW,SAAQ,MAAM;IACxC,IAAI,EAAE,YAAY,CAAC;IACnB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,KAAK,EAAE;QACL,GAAG,EAAE,GAAG,CAAC;QACT,GAAG,EAAE,GAAG,CAAC;KACV,CAAC;CACH;AAED,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,IAAI,UAAU,CAMjE;AAED,wBAAgB,QAAQ,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,GAAG,UAAU,EAAE,CA6CzD;AAGD,wBAAgB,YAAY,CAC1B,IAAI,EAAE,GAAG,EACT,QAAQ,EAAE,MAAM,EAAE,EAClB,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,GAAG,KAAK,OAAO,QAYjD;AAiBD,wBAAgB,UAAU,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,GAAG,OAAO,CA2BlD"}

package/src/utils/json-diff.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonDiffType = void 0;
+exports.isJsonChange = isJsonChange;
+exports.jsonDiff = jsonDiff;
+exports.walkJsonTree = walkJsonTree;
+exports.deepEquals = deepEquals;
+var JsonDiffType;
+(function (JsonDiffType) {
+    JsonDiffType["Deleted"] = "JsonPropertyDeleted";
+    JsonDiffType["Added"] = "JsonPropertyAdded";
+    JsonDiffType["Modified"] = "JsonPropertyModified";
+})(JsonDiffType || (exports.JsonDiffType = JsonDiffType = {}));
+function isJsonChange(change) {
+    return (change.type === JsonDiffType.Added ||
+        change.type === JsonDiffType.Deleted ||
+        change.type === JsonDiffType.Modified);
+}
+function jsonDiff(lhs, rhs) {
+    const result = [];
+    const seenInLhs = new Set();
+    walkJsonTree(lhs, [], (path, lhsValue) => {
+        seenInLhs.add(hashArray(path));
+        const rhsValue = getJsonValue(path, rhs);
+        if (rhsValue === undefined) {
+            result.push({
+                type: JsonDiffType.Deleted,
+                path,
+                value: {
+                    lhs: lhsValue,
+                    rhs: undefined,
+                },
+            });
+        }
+        else if (!deepEquals(lhsValue, rhsValue)) {
+            result.push({
+                type: JsonDiffType.Modified,
+                path,
+                value: {
+                    lhs: lhsValue,
+                    rhs: rhsValue,
+                },
+            });
+        }
+        return typeof lhsValue === 'object' || Array.isArray(lhsValue);
+    });
+    walkJsonTree(rhs, [], (path, rhsValue) => {
+        const addedInRhs = !seenInLhs.has(hashArray(path));
+        if (addedInRhs) {
+            result.push({
+                type: JsonDiffType.Added,
+                path,
+                value: {
+                    lhs: undefined,
+                    rhs: rhsValue,
+                },
+            });
+        }
+        return typeof rhsValue === 'object' || Array.isArray(rhsValue);
+    });
+    return result;
+}
+// Depth-first walk down JSON tree.
+function walkJsonTree(json, currPath, visitor) {
+    if (!json || typeof json !== 'object') {
+        return;
+    }
+    Object.keys(json).forEach((key) => {
+        const path = currPath.concat([key]);
+        const shouldContinue = visitor(path, json[key]);
+        if (shouldContinue) {
+            walkJsonTree(json[key], path, visitor);
+        }
+    });
+}
+function hashArray(ary) {
+    return JSON.stringify(ary);
+}
+function getJsonValue(path, json) {
+    let curr = json;
+    for (const k of path) {
+        curr = curr[k];
+        if (curr === undefined) {
+            break;
+        }
+    }
+    return curr;
+}
+function deepEquals(a, b) {
+    if (a === b) {
+        return true;
+    }
+    // Values do not need to be checked for deep equality and the above is false
+    if (
+    // Values are different types
+    typeof a !== typeof b ||
+        // Values are the same type but not an object or array
+        (typeof a !== 'object' && !Array.isArray(a)) ||
+        // Objects are the same type, objects or arrays, but do not have the same number of keys
+        Object.keys(a).length !== Object.keys(b).length) {
+        return false;
+    }
+    // Values need to be checked for deep equality
+    return Object.entries(a).reduce((equal, [key, aValue]) => {
+        // Skip other keys if it is already not equal.
+        if (!equal) {
+            return equal;
+        }
+        // Traverse the object
+        return deepEquals(aValue, b[key]);
+    }, true);
+}

package/src/utils/json.d.ts

@@ -0,0 +1,45 @@
+import { stripComments } from 'jsonc-parser';
+import type { ParseOptions } from 'jsonc-parser';
+export { stripComments as stripJsonComments };
+export interface JsonParseOptions extends ParseOptions {
+    /**
+     * Expect JSON with javascript-style
+     * @default false
+     */
+    expectComments?: boolean;
+    /**
+     * Disallow javascript-style
+     * @default false
+     */
+    disallowComments?: boolean;
+    /**
+     * Allow trailing commas in the JSON content
+     */
+    allowTrailingComma?: boolean;
+}
+export interface JsonSerializeOptions {
+    /**
+     * the whitespaces to add as indentation to make the output more readable.
+     * @default 2
+     */
+    spaces?: number;
+}
+/**
+ * Parses the given JSON string and returns the object the JSON content represents.
+ * By default javascript-style comments and trailing commas are allowed.
+ *
+ * @param input JSON content as string
+ * @param options JSON parse options
+ * @returns Object the JSON content represents
+ */
+export declare function parseJson<T extends object = any>(input: string, options?: JsonParseOptions): T;
+/**
+ * Serializes the given data to a JSON string.
+ * By default the JSON string is formatted with a 2 space indentation to be easy readable.
+ *
+ * @param input Object which should be serialized to JSON
+ * @param options JSON serialize options
+ * @returns the formatted JSON representation of the object
+ */
+export declare function serializeJson<T extends object = object>(input: T, options?: JsonSerializeOptions): string;
+//# sourceMappingURL=json.d.ts.map

package/src/utils/json.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json.d.ts","sourceRoot":"","sources":["../../../../../packages/nx/src/utils/json.ts"],"names":[],"mappings":"AAAA,OAAO,EAA8B,aAAa,EAAE,MAAM,cAAc,CAAC;AACzE,OAAO,KAAK,EAAc,YAAY,EAAE,MAAM,cAAc,CAAC;AAI7D,OAAO,EAAE,aAAa,IAAI,iBAAiB,EAAE,CAAC;AAE9C,MAAM,WAAW,gBAAiB,SAAQ,YAAY;IACpD;;;OAGG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB;;;OAGG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAE3B;;OAEG;IACH,kBAAkB,CAAC,EAAE,OAAO,CAAC;CAC9B;AAED,MAAM,WAAW,oBAAoB;IACnC;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;GAOG;AACH,wBAAgB,SAAS,CAAC,CAAC,SAAS,MAAM,GAAG,GAAG,EAC9C,KAAK,EAAE,MAAM,EACb,OAAO,CAAC,EAAE,gBAAgB,GACzB,CAAC,CAiBH;AAyBD;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,EACrD,KAAK,EAAE,CAAC,EACR,OAAO,CAAC,EAAE,oBAAoB,GAC7B,MAAM,CAER"}

package/src/utils/json.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stripJsonComments = void 0;
+exports.parseJson = parseJson;
+exports.serializeJson = serializeJson;
+const jsonc_parser_1 = require("jsonc-parser");
+Object.defineProperty(exports, "stripJsonComments", { enumerable: true, get: function () { return jsonc_parser_1.stripComments; } });
+const lines_and_columns_1 = require("lines-and-columns");
+const code_frames_1 = require("./code-frames");
+/**
+ * Parses the given JSON string and returns the object the JSON content represents.
+ * By default javascript-style comments and trailing commas are allowed.
+ *
+ * @param input JSON content as string
+ * @param options JSON parse options
+ * @returns Object the JSON content represents
+ */
+function parseJson(input, options) {
+    try {
+        if (options?.expectComments !== true) {
+            return JSON.parse(input);
+        }
+    }
+    catch { }
+    options = { allowTrailingComma: true, ...options };
+    const errors = [];
+    const result = (0, jsonc_parser_1.parse)(input, errors, options);
+    if (errors.length > 0) {
+        throw new Error(formatParseError(input, errors[0]));
+    }
+    return result;
+}
+/**
+ * Nicely formats a JSON error with context
+ *
+ * @param input JSON content as string
+ * @param parseError jsonc ParseError
+ * @returns
+ */
+function formatParseError(input, parseError) {
+    const { error, offset, length } = parseError;
+    let { line, column } = new lines_and_columns_1.LinesAndColumns(input).locationForIndex(offset);
+    line++;
+    column++;
+    return (`${(0, jsonc_parser_1.printParseErrorCode)(error)} in JSON at ${line}:${column}\n` +
+        (0, code_frames_1.codeFrameColumns)(input, {
+            start: { line, column },
+            end: { line, column: column + length },
+        }) +
+        '\n');
+}
+/**
+ * Serializes the given data to a JSON string.
+ * By default the JSON string is formatted with a 2 space indentation to be easy readable.
+ *
+ * @param input Object which should be serialized to JSON
+ * @param options JSON serialize options
+ * @returns the formatted JSON representation of the object
+ */
+function serializeJson(input, options) {
+    return JSON.stringify(input, null, options?.spaces ?? 2);
+}

package/src/utils/legacy-task-history.d.ts

@@ -0,0 +1,9 @@
+declare const taskRunKeys: readonly ["project", "target", "configuration", "hash", "code", "status", "start", "end"];
+export type TaskRun = Record<(typeof taskRunKeys)[number], string>;
+export declare function getHistoryForHashes(hashes: string[]): Promise<{
+    [hash: string]: TaskRun[];
+}>;
+export declare function writeTaskRunsToHistory(taskRuns: TaskRun[]): Promise<void>;
+export declare const taskHistoryFile: string;
+export {};
+//# sourceMappingURL=legacy-task-history.d.ts.map

package/src/utils/legacy-task-history.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"legacy-task-history.d.ts","sourceRoot":"","sources":["../../../../../packages/nx/src/utils/legacy-task-history.ts"],"names":[],"mappings":"AAIA,QAAA,MAAM,WAAW,2FASP,CAAC;AAEX,MAAM,MAAM,OAAO,GAAG,MAAM,CAAC,CAAC,OAAO,WAAW,CAAC,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,CAAC;AAKnE,wBAAsB,mBAAmB,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC;IACnE,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,EAAE,CAAC;CAC3B,CAAC,CAgBD;AAED,wBAAsB,sBAAsB,CAC1C,QAAQ,EAAE,OAAO,EAAE,GAClB,OAAO,CAAC,IAAI,CAAC,CAgBf;AAED,eAAO,MAAM,eAAe,QAAmD,CAAC"}

package/src/utils/legacy-task-history.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.taskHistoryFile = void 0;
+exports.getHistoryForHashes = getHistoryForHashes;
+exports.writeTaskRunsToHistory = writeTaskRunsToHistory;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const cache_directory_1 = require("./cache-directory");
+const taskRunKeys = [
+    'project',
+    'target',
+    'configuration',
+    'hash',
+    'code',
+    'status',
+    'start',
+    'end',
+];
+let taskHistory = undefined;
+let taskHashToIndicesMap = new Map();
+async function getHistoryForHashes(hashes) {
+    if (taskHistory === undefined) {
+        loadTaskHistoryFromDisk();
+    }
+    const result = {};
+    for (let hash of hashes) {
+        const indices = taskHashToIndicesMap.get(hash);
+        if (!indices) {
+            result[hash] = [];
+        }
+        else {
+            result[hash] = indices.map((index) => taskHistory[index]);
+        }
+    }
+    return result;
+}
+async function writeTaskRunsToHistory(taskRuns) {
+    if (taskHistory === undefined) {
+        loadTaskHistoryFromDisk();
+    }
+    const serializedLines = [];
+    for (let taskRun of taskRuns) {
+        const serializedLine = taskRunKeys.map((key) => taskRun[key]).join(',');
+        serializedLines.push(serializedLine);
+        recordTaskRunInMemory(taskRun);
+    }
+    if (!(0, fs_1.existsSync)(exports.taskHistoryFile)) {
+        (0, fs_1.writeFileSync)(exports.taskHistoryFile, `${taskRunKeys.join(',')}\n`);
+    }
+    (0, fs_1.appendFileSync)(exports.taskHistoryFile, serializedLines.join('\n') + '\n');
+}
+exports.taskHistoryFile = (0, path_1.join)(cache_directory_1.workspaceDataDirectory, 'task-history.csv');
+function loadTaskHistoryFromDisk() {
+    taskHashToIndicesMap.clear();
+    taskHistory = [];
+    if (!(0, fs_1.existsSync)(exports.taskHistoryFile)) {
+        return;
+    }
+    const fileContent = (0, fs_1.readFileSync)(exports.taskHistoryFile, 'utf8');
+    if (!fileContent) {
+        return;
+    }
+    const lines = fileContent.split('\n');
+    // if there are no lines or just the header, return
+    if (lines.length <= 1) {
+        return;
+    }
+    const contentLines = lines.slice(1).filter((l) => l.trim() !== '');
+    // read the values from csv format where each header is a key and the value is the value
+    for (let line of contentLines) {
+        const values = line.trim().split(',');
+        const run = {};
+        taskRunKeys.forEach((header, index) => {
+            run[header] = values[index];
+        });
+        recordTaskRunInMemory(run);
+    }
+}
+function recordTaskRunInMemory(taskRun) {
+    const index = taskHistory.push(taskRun) - 1;
+    if (taskHashToIndicesMap.has(taskRun.hash)) {
+        taskHashToIndicesMap.get(taskRun.hash).push(index);
+    }
+    else {
+        taskHashToIndicesMap.set(taskRun.hash, [index]);
+    }
+}

package/src/utils/logger.d.ts

@@ -0,0 +1,13 @@
+export declare const NX_PREFIX: string;
+export declare const NX_ERROR: string;
+export declare const logger: {
+    warn: (s: any) => void;
+    error: (s: any) => void;
+    info: (s: any) => void;
+    log: (...s: any[]) => void;
+    debug: (...s: any[]) => void;
+    fatal: (...s: any[]) => void;
+    verbose: (...s: any[]) => void;
+};
+export declare function stripIndent(str: string): string;
+//# sourceMappingURL=logger.d.ts.map

package/src/utils/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../../../../packages/nx/src/utils/logger.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,SAAS,QAAuC,CAAC;AAE9D,eAAO,MAAM,QAAQ,QAAyC,CAAC;AAE/D,eAAO,MAAM,MAAM;;;;;;;;CAgClB,CAAC;AAEF,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAQ/C"}

package/src/utils/logger.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = exports.NX_ERROR = exports.NX_PREFIX = void 0;
+exports.stripIndent = stripIndent;
+const pc = require("picocolors");
+exports.NX_PREFIX = pc.inverse(pc.bold(pc.cyan(' NX ')));
+exports.NX_ERROR = pc.inverse(pc.bold(pc.red(' ERROR ')));
+exports.logger = {
+    warn: (s) => console.warn(pc.bold(pc.yellow(s))),
+    error: (s) => {
+        if (typeof s === 'string' && s.startsWith('NX ')) {
+            console.error(`\n${exports.NX_ERROR} ${pc.bold(pc.red(s.slice(3)))}\n`);
+        }
+        else if (s instanceof Error && s.stack) {
+            console.error(pc.bold(pc.red(s.stack)));
+        }
+        else {
+            console.error(pc.bold(pc.red(s)));
+        }
+    },
+    info: (s) => {
+        if (typeof s === 'string' && s.startsWith('NX ')) {
+            console.info(`\n${exports.NX_PREFIX} ${pc.bold(s.slice(3))}\n`);
+        }
+        else {
+            console.info(s);
+        }
+    },
+    log: (...s) => {
+        console.log(...s);
+    },
+    debug: (...s) => {
+        console.debug(...s);
+    },
+    fatal: (...s) => {
+        console.error(...s);
+    },
+    verbose: (...s) => {
+        if (process.env.NX_VERBOSE_LOGGING === 'true') {
+            console.log(...s);
+        }
+    },
+};
+function stripIndent(str) {
+    const match = str.match(/^[ \t]*(?=\S)/gm);
+    if (!match) {
+        return str;
+    }
+    const indent = match.reduce((r, a) => Math.min(r, a.length), Infinity);
+    const regex = new RegExp(`^[ \\t]{${indent}}`, 'gm');
+    return str.replace(regex, '');
+}

package/src/utils/nx-cloud-utils.d.ts

@@ -0,0 +1,4 @@
+import { NxJsonConfiguration } from '../config/nx-json';
+export declare function isNxCloudUsed(nxJson: NxJsonConfiguration): boolean;
+export declare function getNxCloudUrl(nxJson: NxJsonConfiguration): string;
+//# sourceMappingURL=nx-cloud-utils.d.ts.map

package/src/utils/nx-cloud-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nx-cloud-utils.d.ts","sourceRoot":"","sources":["../../../../../packages/nx/src/utils/nx-cloud-utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAExD,wBAAgB,aAAa,CAAC,MAAM,EAAE,mBAAmB,GAAG,OAAO,CAclE;AAED,wBAAgB,aAAa,CAAC,MAAM,EAAE,mBAAmB,GAAG,MAAM,CAejE"}

package/src/utils/nx-cloud-utils.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNxCloudUsed = isNxCloudUsed;
+exports.getNxCloudUrl = getNxCloudUrl;
+function isNxCloudUsed(nxJson) {
+    if (process.env.NX_NO_CLOUD === 'true' || nxJson.neverConnectToCloud) {
+        return false;
+    }
+    return (!!process.env.NX_CLOUD_AUTH_TOKEN ||
+        !!process.env.NX_CLOUD_ACCESS_TOKEN ||
+        !!nxJson.nxCloudAccessToken ||
+        !!nxJson.nxCloudId ||
+        !!Object.values(nxJson.tasksRunnerOptions ?? {}).find((r) => r.runner == '@nrwl/nx-cloud' || r.runner == 'nx-cloud'));
+}
+function getNxCloudUrl(nxJson) {
+    const cloudRunner = Object.values(nxJson.tasksRunnerOptions ?? {}).find((r) => r.runner == '@nrwl/nx-cloud' || r.runner == 'nx-cloud');
+    if (!cloudRunner &&
+        !(nxJson.nxCloudAccessToken ||
+            process.env.NX_CLOUD_AUTH_TOKEN ||
+            process.env.NX_CLOUD_ACCESS_TOKEN) &&
+        !nxJson.nxCloudId)
+        throw new Error('nx-cloud runner not found in nx.json');
+    return cloudRunner?.options?.url ?? nxJson.nxCloudUrl ?? 'https://nx.app';
+}

package/src/utils/nx-console-prompt.d.ts

@@ -0,0 +1,2 @@
+export declare function ensureNxConsoleInstalled(): Promise<void>;
+//# sourceMappingURL=nx-console-prompt.d.ts.map

package/src/utils/nx-console-prompt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nx-console-prompt.d.ts","sourceRoot":"","sources":["../../../../../packages/nx/src/utils/nx-console-prompt.ts"],"names":[],"mappings":"AAUA,wBAAsB,wBAAwB,kBAkC7C"}

package/src/utils/nx-console-prompt.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureNxConsoleInstalled = ensureNxConsoleInstalled;
+const enquirer_1 = require("enquirer");
+const os_1 = require("os");
+const output_1 = require("./output");
+const native_1 = require("../native");
+const is_ci_1 = require("./is-ci");
+async function ensureNxConsoleInstalled() {
+    const preferences = new native_1.NxConsolePreferences((0, os_1.homedir)());
+    let setting = preferences.getAutoInstallPreference();
+    const canInstallConsole = (0, native_1.canInstallNxConsole)();
+    // If user previously opted in but extension is not installed,
+    // they must have manually uninstalled it - respect that choice
+    if (setting === true && canInstallConsole) {
+        // User had auto-install enabled but extension is missing
+        // This means they manually uninstalled it
+        preferences.setAutoInstallPreference(false);
+        return;
+    }
+    // Noop
+    if (!canInstallConsole) {
+        return;
+    }
+    // Only prompt if both stdin and stdout are TTY (interactive terminal)
+    // and we're not in a CI environment
+    const isInteractive = process.stdin.isTTY && process.stdout.isTTY && !(0, is_ci_1.isCI)();
+    if (isInteractive && typeof setting !== 'boolean') {
+        setting = await promptForNxConsoleInstallation();
+        preferences.setAutoInstallPreference(setting);
+    }
+    if (setting) {
+        const installed = (0, native_1.installNxConsole)();
+        if (installed) {
+            output_1.output.log({ title: 'Successfully installed Nx Console!' });
+        }
+    }
+}
+/**
+ * Prompts the user whether they want to automatically install the Nx Console extension
+ * and persists their preference using the NxConsolePreferences struct
+ */
+async function promptForNxConsoleInstallation() {
+    try {
+        output_1.output.log({
+            title: "Install Nx's official editor extension to:",
+            bodyLines: [
+                '- Enable your AI assistant to do more by understanding your workspace',
+                '- Add IntelliSense for Nx configuration files',
+                '- Explore your workspace visually',
+            ],
+        });
+        const { shouldInstallNxConsole } = await (0, enquirer_1.prompt)({
+            type: 'confirm',
+            name: 'shouldInstallNxConsole',
+            message: 'Install Nx Console? (you can uninstall anytime)',
+            initial: true,
+        });
+        return shouldInstallNxConsole;
+    }
+    catch (error) {
+        return false;
+    }
+}

package/src/utils/nx-key.d.ts

@@ -0,0 +1,8 @@
+import type { NxKey } from '@nx/key';
+export declare function createNxKeyLicenseeInformation(nxKey: NxKey): string;
+export declare function printNxKey(): Promise<void>;
+export declare function getNxKeyInformation(): Promise<NxKey | null>;
+export declare class NxKeyNotInstalledError extends Error {
+    constructor(e: Error);
+}
+//# sourceMappingURL=nx-key.d.ts.map

package/src/utils/nx-key.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nx-key.d.ts","sourceRoot":"","sources":["../../../../../packages/nx/src/utils/nx-key.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAErC,wBAAgB,8BAA8B,CAAC,KAAK,EAAE,KAAK,UAY1D;AAED,wBAAsB,UAAU,kBAO/B;AAED,wBAAsB,mBAAmB,IAAI,OAAO,CAAC,KAAK,GAAG,IAAI,CAAC,CAwBjE;AAED,qBAAa,sBAAuB,SAAQ,KAAK;gBACnC,CAAC,EAAE,KAAK;CAQrB"}

package/src/utils/nx-key.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NxKeyNotInstalledError = void 0;
+exports.createNxKeyLicenseeInformation = createNxKeyLicenseeInformation;
+exports.printNxKey = printNxKey;
+exports.getNxKeyInformation = getNxKeyInformation;
+const logger_1 = require("./logger");
+const package_manager_1 = require("./package-manager");
+const workspace_root_1 = require("./workspace-root");
+function createNxKeyLicenseeInformation(nxKey) {
+    if ('isPowerpack' in nxKey && nxKey.isPowerpack) {
+        return `Licensed to ${nxKey.organizationName} for ${nxKey.seatCount} user${nxKey.seatCount > 1 ? 's' : ''} in ${nxKey.workspaceCount === 9999
+            ? 'an unlimited number of'
+            : nxKey.workspaceCount} workspace${nxKey.workspaceCount > 1 ? 's' : ''}.`;
+    }
+    else {
+        return `Licensed to ${nxKey.organizationName}.`;
+    }
+}
+async function printNxKey() {
+    try {
+        const key = await getNxKeyInformation();
+        if (key) {
+            logger_1.logger.log(createNxKeyLicenseeInformation(key));
+        }
+    }
+    catch { }
+}
+async function getNxKeyInformation() {
+    try {
+        const { getPowerpackLicenseInformation, getPowerpackLicenseInformationAsync, } = (await Promise.resolve().then(() => require('@nx/powerpack-license')));
+        return (getPowerpackLicenseInformationAsync ?? getPowerpackLicenseInformation)(workspace_root_1.workspaceRoot);
+    }
+    catch (e) {
+        try {
+            const { getNxKeyInformationAsync } = (await Promise.resolve().then(() => require('@nx/key')));
+            return getNxKeyInformationAsync(workspace_root_1.workspaceRoot);
+        }
+        catch (e) {
+            if ('code' in e && e.code === 'MODULE_NOT_FOUND') {
+                throw new NxKeyNotInstalledError(e);
+            }
+            throw e;
+        }
+    }
+}
+class NxKeyNotInstalledError extends Error {
+    constructor(e) {
+        super(`The "@nx/key" package is needed to use Nx key enabled features. Please install it with ${(0, package_manager_1.getPackageManagerCommand)().addDev} @nx/key`, { cause: e });
+    }
+}
+exports.NxKeyNotInstalledError = NxKeyNotInstalledError;

package/src/utils/object-sort.d.ts

@@ -0,0 +1,2 @@
+export declare function sortObjectByKeys(originalObject: object): {};
+//# sourceMappingURL=object-sort.d.ts.map

package/src/utils/object-sort.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"object-sort.d.ts","sourceRoot":"","sources":["../../../../../packages/nx/src/utils/object-sort.ts"],"names":[],"mappings":"AAAA,wBAAgB,gBAAgB,CAAC,cAAc,EAAE,MAAM,MAOtD"}