@ohos-ports/nx 17.3.2-beta.0

package/src/utils/find-matching-projects.js

@@ -0,0 +1,198 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMatchingStringsWithCache = exports.findMatchingProjects = void 0;
+const minimatch_1 = require("minimatch");
+const validPatternTypes = [
+    'name', // Pattern is based on the project's name
+    'tag', // Pattern is based on the project's tags
+    'directory', // Pattern is based on the project's root directory
+    'unlabeled', // Pattern was passed without specifying a type
+];
+const globCharacters = ['*', '|', '{', '}', '(', ')'];
+/**
+ * Find matching project names given a list of potential project names or globs.
+ *
+ * @param patterns A list of project names or globs to match against.
+ * @param projects A map of {@link ProjectGraphProjectNode} by project name.
+ * @returns
+ */
+function findMatchingProjects(patterns = [], projects) {
+    if (!patterns.length || patterns.filter((p) => p.length).length === 0) {
+        return []; // Short circuit if called with no patterns
+    }
+    const projectNames = Object.keys(projects);
+    const matchedProjects = new Set();
+    for (const stringPattern of patterns) {
+        if (!stringPattern.length) {
+            continue;
+        }
+        const pattern = parseStringPattern(stringPattern, projects);
+        // Handle wildcard with short-circuit, as its a common case with potentially
+        // large project sets and we can avoid the more expensive glob matching.
+        if (pattern.value === '*') {
+            for (const projectName of projectNames) {
+                if (pattern.exclude) {
+                    matchedProjects.delete(projectName);
+                }
+                else {
+                    matchedProjects.add(projectName);
+                }
+            }
+            continue;
+        }
+        switch (pattern.type) {
+            case 'tag': {
+                addMatchingProjectsByTag(projectNames, projects, pattern, matchedProjects);
+                continue;
+            }
+            case 'name': {
+                addMatchingProjectsByName(projectNames, projects, pattern, matchedProjects);
+                continue;
+            }
+            case 'directory': {
+                addMatchingProjectsByDirectory(projectNames, projects, pattern, matchedProjects);
+                continue;
+            }
+            // Same thing as `type:unlabeled`. If no specific type is set,
+            // we can waterfall through the different types until we find a match
+            default: {
+                // The size of the selected and excluded projects set, before we
+                // start updating it with this pattern. If the size changes, we
+                // know we found a match and can skip the other types.
+                const originalSize = matchedProjects.size;
+                addMatchingProjectsByName(projectNames, projects, pattern, matchedProjects);
+                if (matchedProjects.size !== originalSize) {
+                    // There was some match by name, don't check other types
+                    continue;
+                }
+                addMatchingProjectsByDirectory(projectNames, projects, pattern, matchedProjects);
+                if (matchedProjects.size !== originalSize) {
+                    // There was some match by directory, don't check other types
+                    // Note - this doesn't do anything currently, but preps for future
+                    // types
+                    continue;
+                }
+            }
+        }
+    }
+    return Array.from(matchedProjects);
+}
+exports.findMatchingProjects = findMatchingProjects;
+function addMatchingProjectsByDirectory(projectNames, projects, pattern, matchedProjects) {
+    for (const projectName of projectNames) {
+        const root = projects[projectName].data.root;
+        if ((0, exports.getMatchingStringsWithCache)(pattern.value, [root]).length > 0) {
+            if (pattern.exclude) {
+                matchedProjects.delete(projectName);
+            }
+            else {
+                matchedProjects.add(projectName);
+            }
+        }
+    }
+}
+function addMatchingProjectsByName(projectNames, projects, pattern, matchedProjects) {
+    if (projects[pattern.value]) {
+        if (pattern.exclude) {
+            matchedProjects.delete(pattern.value);
+        }
+        else {
+            matchedProjects.add(pattern.value);
+        }
+        return;
+    }
+    if (!globCharacters.some((c) => pattern.value.includes(c))) {
+        return;
+    }
+    const matchedProjectNames = (0, exports.getMatchingStringsWithCache)(pattern.value, projectNames);
+    for (const projectName of matchedProjectNames) {
+        if (pattern.exclude) {
+            matchedProjects.delete(projectName);
+        }
+        else {
+            matchedProjects.add(projectName);
+        }
+    }
+}
+function addMatchingProjectsByTag(projectNames, projects, pattern, matchedProjects) {
+    for (const projectName of projectNames) {
+        const tags = projects[projectName].data.tags || [];
+        if (tags.includes(pattern.value)) {
+            if (pattern.exclude) {
+                matchedProjects.delete(projectName);
+            }
+            else {
+                matchedProjects.add(projectName);
+            }
+            continue;
+        }
+        if (!globCharacters.some((c) => pattern.value.includes(c))) {
+            continue;
+        }
+        if ((0, exports.getMatchingStringsWithCache)(pattern.value, tags).length) {
+            if (pattern.exclude) {
+                matchedProjects.delete(projectName);
+            }
+            else {
+                matchedProjects.add(projectName);
+            }
+        }
+    }
+}
+function parseStringPattern(pattern, projects) {
+    const isExclude = pattern.startsWith('!');
+    // Support for things like: `!{type}:value`
+    if (isExclude) {
+        pattern = pattern.substring(1);
+    }
+    const indexOfFirstPotentialSeparator = pattern.indexOf(':');
+    // There is a project that matches directly
+    if (projects[pattern]) {
+        return { type: 'name', value: pattern, exclude: isExclude };
+        // The pattern does not contain a label
+    }
+    else if (indexOfFirstPotentialSeparator === -1) {
+        return { type: 'unlabeled', value: pattern, exclude: isExclude };
+        // The pattern may contain a label
+    }
+    else {
+        const potentialType = pattern.substring(0, indexOfFirstPotentialSeparator);
+        return {
+            type: isValidPatternType(potentialType) ? potentialType : 'unlabeled',
+            value: pattern.substring(indexOfFirstPotentialSeparator + 1),
+            exclude: isExclude,
+        };
+    }
+}
+function isValidPatternType(type) {
+    return validPatternTypes.includes(type);
+}
+exports.getMatchingStringsWithCache = (() => {
+    // Map< Pattern, Map< Item, Result >>
+    const minimatchCache = new Map();
+    const regexCache = new Map();
+    return (pattern, items) => {
+        if (!minimatchCache.has(pattern)) {
+            minimatchCache.set(pattern, new Map());
+        }
+        const patternCache = minimatchCache.get(pattern);
+        if (!regexCache.has(pattern)) {
+            const regex = minimatch_1.minimatch.makeRe(pattern, { dot: true });
+            if (regex) {
+                regexCache.set(pattern, regex);
+            }
+            else {
+                throw new Error('Invalid glob pattern ' + pattern);
+            }
+        }
+        const matcher = regexCache.get(pattern);
+        return items.filter((item) => {
+            let entry = patternCache.get(item);
+            if (entry === undefined || entry === null) {
+                entry = item === pattern ? true : matcher.test(item);
+                patternCache.set(item, entry);
+            }
+            return entry;
+        });
+    };
+})();

package/src/utils/find-workspace-root.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Recursive function that walks back up the directory
+ * tree to try and find a workspace file.
+ *
+ * @param dir Directory to start searching with
+ */
+export declare function findWorkspaceRoot(dir: string): WorkspaceTypeAndRoot | null;
+export interface WorkspaceTypeAndRoot {
+    type: 'nx' | 'angular';
+    dir: string;
+}

package/src/utils/find-workspace-root.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findWorkspaceRoot = void 0;
+const workspace_root_1 = require("./workspace-root");
+/**
+ * Recursive function that walks back up the directory
+ * tree to try and find a workspace file.
+ *
+ * @param dir Directory to start searching with
+ */
+function findWorkspaceRoot(dir) {
+    const r = (0, workspace_root_1.workspaceRootInner)(dir, null);
+    if (r === null)
+        return null;
+    if (isAngularCliInstalled(r)) {
+        return { type: 'angular', dir: r };
+    }
+    else {
+        return { type: 'nx', dir: r };
+    }
+}
+exports.findWorkspaceRoot = findWorkspaceRoot;
+function isAngularCliInstalled(root) {
+    try {
+        // nx-ignore-next-line
+        require.resolve('@angular/cli', {
+            paths: [root],
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/src/utils/globs.d.ts

@@ -0,0 +1 @@
+export declare function combineGlobPatterns(...patterns: (string | string[])[]): string;

package/src/utils/globs.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.combineGlobPatterns = void 0;
+function combineGlobPatterns(...patterns) {
+    const p = patterns.flat();
+    return p.length > 1 ? '{' + p.join(',') + '}' : p.length === 1 ? p[0] : '';
+}
+exports.combineGlobPatterns = combineGlobPatterns;

package/src/utils/ignore.d.ts

@@ -0,0 +1,8 @@
+import ignore from 'ignore';
+/**
+ * An array of glob patterns that should always be ignored.
+ */
+export declare const ALWAYS_IGNORE: string[];
+export declare function getIgnoredGlobs(root?: string, prependRoot?: boolean): string[];
+export declare function getAlwaysIgnore(root?: string): string[];
+export declare function getIgnoreObject(root?: string): ReturnType<typeof ignore>;

package/src/utils/ignore.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getIgnoreObject = exports.getAlwaysIgnore = exports.getIgnoredGlobs = exports.ALWAYS_IGNORE = void 0;
+const fs_extra_1 = require("fs-extra");
+const ignore_1 = require("ignore");
+const fileutils_1 = require("./fileutils");
+const path_1 = require("./path");
+const workspace_root_1 = require("./workspace-root");
+/**
+ * An array of glob patterns that should always be ignored.
+ */
+exports.ALWAYS_IGNORE = getAlwaysIgnore();
+function getIgnoredGlobs(root = workspace_root_1.workspaceRoot, prependRoot = true) {
+    const files = ['.gitignore', '.nxignore'];
+    if (prependRoot) {
+        return [
+            ...getAlwaysIgnore(root),
+            ...files.flatMap((f) => getIgnoredGlobsFromFile((0, path_1.joinPathFragments)(root, f), root)),
+        ];
+    }
+    else {
+        return [
+            ...getAlwaysIgnore(),
+            ...files.flatMap((f) => getIgnoredGlobsFromFile((0, path_1.joinPathFragments)(root, f))),
+        ];
+    }
+}
+exports.getIgnoredGlobs = getIgnoredGlobs;
+function getAlwaysIgnore(root) {
+    const paths = ['node_modules', '**/node_modules', '.git'];
+    return root ? paths.map((x) => (0, path_1.joinPathFragments)(root, x)) : paths;
+}
+exports.getAlwaysIgnore = getAlwaysIgnore;
+function getIgnoreObject(root = workspace_root_1.workspaceRoot) {
+    const ig = (0, ignore_1.default)();
+    ig.add((0, fileutils_1.readFileIfExisting)(`${root}/.gitignore`));
+    ig.add((0, fileutils_1.readFileIfExisting)(`${root}/.nxignore`));
+    return ig;
+}
+exports.getIgnoreObject = getIgnoreObject;
+function getIgnoredGlobsFromFile(file, root) {
+    try {
+        const results = [];
+        const contents = (0, fs_extra_1.readFileSync)(file, 'utf-8');
+        const lines = contents.split('\n');
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith('#')) {
+                continue;
+            }
+            else if (trimmed.startsWith('/')) {
+                if (root) {
+                    results.push((0, path_1.joinPathFragments)(root, trimmed));
+                }
+                else {
+                    results.push((0, path_1.joinPathFragments)('.', trimmed));
+                }
+            }
+            else {
+                results.push(trimmed);
+            }
+        }
+        return results;
+    }
+    catch (e) {
+        return [];
+    }
+}

package/src/utils/installation-directory.d.ts

@@ -0,0 +1,2 @@
+export declare function getNxInstallationPath(root?: string): string;
+export declare function getNxRequirePaths(root?: string): string[];

package/src/utils/installation-directory.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNxRequirePaths = exports.getNxInstallationPath = void 0;
+const path_1 = require("path");
+const workspace_root_1 = require("./workspace-root");
+function getNxInstallationPath(root = workspace_root_1.workspaceRoot) {
+    return (0, path_1.join)(root, '.nx', 'installation');
+}
+exports.getNxInstallationPath = getNxInstallationPath;
+function getNxRequirePaths(root = workspace_root_1.workspaceRoot) {
+    return [root, getNxInstallationPath(root)];
+}
+exports.getNxRequirePaths = getNxRequirePaths;

package/src/utils/is-ci.d.ts

@@ -0,0 +1 @@
+export declare function isCI(): boolean;

package/src/utils/is-ci.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isCI = void 0;
+function isCI() {
+    return (process.env.CI === 'true' ||
+        process.env.TF_BUILD === 'true' ||
+        process.env.GITHUB_ACTIONS === 'true' ||
+        process.env.BUILDKITE === 'true' ||
+        process.env.CIRCLECI === 'true' ||
+        process.env.CIRRUS_CI === 'true' ||
+        process.env.TRAVIS === 'true' ||
+        !!process.env['bamboo.buildKey'] ||
+        !!process.env.CODEBUILD_BUILD_ID ||
+        !!process.env.GITLAB_CI ||
+        !!process.env.HEROKU_TEST_RUN_ID ||
+        !!process.env.BUILD_ID ||
+        !!process.env.BUILD_BUILDID ||
+        !!process.env.TEAMCITY_VERSION);
+}
+exports.isCI = isCI;

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

@@ -0,0 +1,18 @@
+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;

package/src/utils/json-diff.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deepEquals = exports.walkJsonTree = exports.jsonDiff = exports.isJsonChange = exports.JsonDiffType = void 0;
+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);
+}
+exports.isJsonChange = isJsonChange;
+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;
+}
+exports.jsonDiff = jsonDiff;
+// 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);
+        }
+    });
+}
+exports.walkJsonTree = walkJsonTree;
+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);
+}
+exports.deepEquals = deepEquals;

package/src/utils/json.d.ts

@@ -0,0 +1,44 @@
+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;

package/src/utils/json.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeJson = exports.parseJson = exports.stripJsonComments = void 0;
+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 {
+        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;
+}
+exports.parseJson = parseJson;
+/**
+ * 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) + '\n';
+}
+exports.serializeJson = serializeJson;

package/src/utils/logger.d.ts

@@ -0,0 +1,11 @@
+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;
+};
+export declare function stripIndent(str: string): string;

package/src/utils/logger.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stripIndent = exports.logger = exports.NX_ERROR = exports.NX_PREFIX = void 0;
+const chalk = require("chalk");
+exports.NX_PREFIX = `${chalk.cyan('>')} ${chalk.inverse(chalk.bold(chalk.cyan(' NX ')))}`;
+exports.NX_ERROR = chalk.inverse(chalk.bold(chalk.red(' ERROR ')));
+exports.logger = {
+    warn: (s) => console.warn(chalk.bold(chalk.yellow(s))),
+    error: (s) => {
+        if (typeof s === 'string' && s.startsWith('NX ')) {
+            console.error(`\n${exports.NX_ERROR} ${chalk.bold(chalk.red(s.slice(3)))}\n`);
+        }
+        else if (s instanceof Error && s.stack) {
+            console.error(chalk.bold(chalk.red(s.stack)));
+        }
+        else {
+            console.error(chalk.bold(chalk.red(s)));
+        }
+    },
+    info: (s) => {
+        if (typeof s === 'string' && s.startsWith('NX ')) {
+            console.info(`\n${exports.NX_PREFIX} ${chalk.bold(s.slice(3))}\n`);
+        }
+        else {
+            console.info(s);
+        }
+    },
+    log: (...s) => {
+        console.log(...s);
+    },
+    debug: (...s) => {
+        console.debug(...s);
+    },
+    fatal: (...s) => {
+        console.error(...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, '');
+}
+exports.stripIndent = stripIndent;

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

@@ -0,0 +1,4 @@
+import { NxJsonConfiguration } from '../config/nx-json';
+export declare function isNxCloudUsed(nxJson: NxJsonConfiguration): string | boolean;
+export declare function getNxCloudUrl(nxJson: NxJsonConfiguration): string;
+export declare function getNxCloudToken(nxJson: NxJsonConfiguration): string;