@nx/js 0.0.0-pr-22179-271588f

package/src/utils/code-frames/highlight.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.highlight = void 0;
+// Adapted from https://raw.githubusercontent.com/babel/babel/4108524/packages/babel-highlight/src/index.js
+const jsTokens = require("js-tokens");
+const chalk = require("chalk");
+const identifiers_1 = require("./identifiers");
+/**
+ * Chalk styles for token types.
+ */
+function getDefs(chalk) {
+    return {
+        keyword: chalk.cyan,
+        capitalized: chalk.yellow,
+        jsx_tag: chalk.yellow,
+        punctuator: chalk.yellow,
+        // bracket:  intentionally omitted.
+        number: chalk.magenta,
+        string: chalk.green,
+        regex: chalk.magenta,
+        comment: chalk.grey,
+        invalid: chalk.white.bgRed.bold,
+    };
+}
+/**
+ * RegExp to test for newlines in terminal.
+ */
+const NEWLINE = /\r\n|[\n\r\u2028\u2029]/;
+/**
+ * RegExp to test for what seems to be a JSX tag name.
+ */
+const JSX_TAG = /^[a-z][\w-]*$/i;
+/**
+ * RegExp to test for the three types of brackets.
+ */
+const BRACKET = /^[()[\]{}]$/;
+/**
+ * Get the type of token, specifying punctuator type.
+ */
+function getTokenType(match) {
+    const [offset, text] = match.slice(-2);
+    const token = jsTokens.matchToToken(match);
+    if (token.type === 'name') {
+        if ((0, identifiers_1.isKeyword)(token.value) || (0, identifiers_1.isReservedWord)(token.value)) {
+            return 'keyword';
+        }
+        if (JSX_TAG.test(token.value) &&
+            (text[offset - 1] === '<' || text.slice(offset - 2, 2) == '</')) {
+            return 'jsx_tag';
+        }
+        if (token.value[0] !== token.value[0].toLowerCase()) {
+            return 'capitalized';
+        }
+    }
+    if (token.type === 'punctuator' && BRACKET.test(token.value)) {
+        return 'bracket';
+    }
+    if (token.type === 'invalid' &&
+        (token.value === '@' || token.value === '#')) {
+        return 'punctuator';
+    }
+    return token.type;
+}
+/**
+ * Highlight `text` using the token definitions in `defs`.
+ */
+function highlightTokens(defs, text) {
+    return text.replace(jsTokens.default, function (...args) {
+        const type = getTokenType(args);
+        const colorize = defs[type];
+        if (colorize) {
+            return args[0]
+                .split(NEWLINE)
+                .map((str) => colorize(str))
+                .join('\n');
+        }
+        else {
+            return args[0];
+        }
+    });
+}
+function highlight(code) {
+    const defs = getDefs(chalk);
+    return highlightTokens(defs, code);
+}
+exports.highlight = highlight;

package/src/utils/code-frames/identifiers.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Checks if word is a reserved word in non-strict mode
+ */
+export declare function isReservedWord(word: string, inModule?: boolean): boolean;
+export declare function isKeyword(word: string): boolean;

package/src/utils/code-frames/identifiers.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isKeyword = exports.isReservedWord = void 0;
+// Adapted from https://raw.githubusercontent.com/babel/babel/e39b508030a9f696584d21b0eb9677498e3ca231/packages/babel-helper-validator-identifier/src/keyword.js
+const keywords = new Set([
+    'break',
+    'case',
+    'catch',
+    'continue',
+    'debugger',
+    'default',
+    'do',
+    'else',
+    'finally',
+    'for',
+    'function',
+    'if',
+    'return',
+    'switch',
+    'throw',
+    'try',
+    'var',
+    'const',
+    'while',
+    'with',
+    'new',
+    'this',
+    'super',
+    'class',
+    'extends',
+    'export',
+    'import',
+    'null',
+    'true',
+    'false',
+    'in',
+    'instanceof',
+    'typeof',
+    'void',
+    'delete',
+]);
+/**
+ * Checks if word is a reserved word in non-strict mode
+ */
+function isReservedWord(word, inModule) {
+    return (inModule && word === 'await') || word === 'enum';
+}
+exports.isReservedWord = isReservedWord;
+function isKeyword(word) {
+    return keywords.has(word);
+}
+exports.isKeyword = isKeyword;

package/src/utils/compiler-helper-dependency.d.ts

@@ -0,0 +1,18 @@
+import { type ProjectGraph, type ProjectGraphDependency } from '@nx/devkit';
+import { DependentBuildableProjectNode } from './buildable-libs-utils';
+export declare enum HelperDependency {
+    tsc = "npm:tslib",
+    swc = "npm:@swc/helpers"
+}
+/**
+ * Check and return a DependencyNode for the compiler's external helpers npm package. Return "null"
+ * if it doesn't need it or it cannot be found in the Project Graph
+ *
+ * @param {HelperDependency} helperDependency
+ * @param {string} configPath
+ * @param {DependentBuildableProjectNode[]} dependencies
+ * @param {ProjectGraph} projectGraph
+ * @param {boolean=false} returnDependencyIfFound
+ */
+export declare function getHelperDependency(helperDependency: HelperDependency, configPath: string, dependencies: DependentBuildableProjectNode[], projectGraph: ProjectGraph, returnDependencyIfFound?: boolean): DependentBuildableProjectNode | null;
+export declare function getHelperDependenciesFromProjectGraph(contextRoot: string, sourceProject: string, projectGraph: ProjectGraph): ProjectGraphDependency[];

package/src/utils/compiler-helper-dependency.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getHelperDependenciesFromProjectGraph = exports.getHelperDependency = exports.HelperDependency = void 0;
+const devkit_1 = require("@nx/devkit");
+const path_1 = require("path");
+const ts_config_1 = require("./typescript/ts-config");
+const get_swcrc_path_1 = require("./swc/get-swcrc-path");
+var HelperDependency;
+(function (HelperDependency) {
+    HelperDependency["tsc"] = "npm:tslib";
+    HelperDependency["swc"] = "npm:@swc/helpers";
+})(HelperDependency || (exports.HelperDependency = HelperDependency = {}));
+const jsExecutors = {
+    '@nx/js:tsc': {
+        helperDependency: HelperDependency.tsc,
+        getConfigPath: (options, contextRoot, _) => (0, path_1.join)(contextRoot, options.tsConfig),
+    },
+    '@nx/js:swc': {
+        helperDependency: HelperDependency.swc,
+        getConfigPath: (options, contextRoot, projectRoot) => (0, get_swcrc_path_1.getSwcrcPath)(options, contextRoot, projectRoot),
+    },
+};
+/**
+ * Check and return a DependencyNode for the compiler's external helpers npm package. Return "null"
+ * if it doesn't need it or it cannot be found in the Project Graph
+ *
+ * @param {HelperDependency} helperDependency
+ * @param {string} configPath
+ * @param {DependentBuildableProjectNode[]} dependencies
+ * @param {ProjectGraph} projectGraph
+ * @param {boolean=false} returnDependencyIfFound
+ */
+function getHelperDependency(helperDependency, configPath, dependencies, projectGraph, returnDependencyIfFound = false) {
+    const dependency = dependencies.find((dep) => dep.name === helperDependency);
+    if (!!dependency) {
+        // if a helperDependency is found, we either return null or the found dependency
+        // We return the found return dependency for the cases where it is a part of a
+        // project's dependency's dependency instead
+        // eg: app-a -> lib-a (helperDependency is on lib-a instead of app-a)
+        // When building app-a, we'd want to know about the found helper dependency still
+        return returnDependencyIfFound ? dependency : null;
+    }
+    let isHelperNeeded = false;
+    switch (helperDependency) {
+        case HelperDependency.tsc:
+            isHelperNeeded = !!(0, ts_config_1.readTsConfig)(configPath).options['importHelpers'];
+            break;
+        case HelperDependency.swc:
+            isHelperNeeded = !!(0, devkit_1.readJsonFile)(configPath)['jsc']['externalHelpers'];
+            break;
+    }
+    if (!isHelperNeeded)
+        return null;
+    let libNode = projectGraph[helperDependency];
+    // If libNode is not found due to the version suffix from pnpm lockfile, try to match it by package name.
+    if (!libNode) {
+        for (const nodeName of Object.keys(projectGraph.externalNodes)) {
+            const node = projectGraph.externalNodes[nodeName];
+            if (`npm:${node.data.packageName}` === helperDependency) {
+                libNode = node;
+                break;
+            }
+        }
+    }
+    if (!libNode) {
+        devkit_1.logger.warn(`Your library compilation option specifies that the compiler external helper (${helperDependency.split(':')[1]}) is needed but it is not installed.`);
+        return null;
+    }
+    return {
+        name: helperDependency,
+        outputs: [],
+        node: libNode,
+    };
+}
+exports.getHelperDependency = getHelperDependency;
+function getHelperDependenciesFromProjectGraph(contextRoot, sourceProject, projectGraph) {
+    // if the source project isn't part of the projectGraph nodes; skip
+    if (!projectGraph.nodes[sourceProject])
+        return [];
+    // if the source project does not have any dependencies; skip
+    if (!projectGraph.dependencies[sourceProject] ||
+        !projectGraph.dependencies[sourceProject].length)
+        return [];
+    const sourceDependencies = projectGraph.dependencies[sourceProject];
+    const internalDependencies = sourceDependencies.reduce((result, dependency) => {
+        // we check if a dependency is part of the workspace and if it's a library
+        // because we wouldn't want to include external dependencies (npm packages)
+        if (projectGraph.nodes[dependency.target] &&
+            projectGraph.nodes[dependency.target].type === 'lib') {
+            const targetData = projectGraph.nodes[dependency.target].data;
+            // check if the dependency has a buildable target with one of the jsExecutors
+            const targetExecutor = Object.values(targetData.targets).find(({ executor }) => !!jsExecutors[executor]);
+            if (targetExecutor) {
+                const jsExecutor = jsExecutors[targetExecutor['executor']];
+                const { root: projectRoot } = targetData;
+                const configPath = jsExecutor.getConfigPath(targetExecutor['options'], contextRoot, projectRoot);
+                // construct the correct helperDependency configurations
+                // so we can compute the ProjectGraphDependency later
+                result.push({
+                    helperDependency: jsExecutors[targetExecutor['executor']].helperDependency,
+                    dependencies: projectGraph.dependencies[dependency.target],
+                    configPath,
+                });
+            }
+        }
+        return result;
+    }, []);
+    return internalDependencies.reduce((result, { helperDependency, configPath, dependencies }) => {
+        const dependency = getHelperDependency(helperDependency, configPath, dependencies, projectGraph, true);
+        if (dependency) {
+            result.push({
+                type: 'static',
+                source: sourceProject,
+                target: dependency.name,
+            });
+        }
+        return result;
+    }, []);
+}
+exports.getHelperDependenciesFromProjectGraph = getHelperDependenciesFromProjectGraph;

package/src/utils/find-npm-dependencies.d.ts

@@ -0,0 +1,9 @@
+import { type ProjectFileMap, type ProjectGraph, type ProjectGraphProjectNode } from '@nx/devkit';
+/**
+ * Finds all npm dependencies and their expected versions for a given project.
+ */
+export declare function findNpmDependencies(workspaceRoot: string, sourceProject: ProjectGraphProjectNode, projectGraph: ProjectGraph, projectFileMap: ProjectFileMap, buildTarget: string, options?: {
+    includeTransitiveDependencies?: boolean;
+    ignoredFiles?: string[];
+    useLocalPathsForWorkspaceDependencies?: boolean;
+}): Record<string, string>;

package/src/utils/find-npm-dependencies.js

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findNpmDependencies = void 0;
+const path_1 = require("path");
+const configuration_1 = require("nx/src/config/configuration");
+const devkit_1 = require("@nx/devkit");
+const fileutils_1 = require("nx/src/utils/fileutils");
+const project_graph_1 = require("nx/src/config/project-graph");
+const ts_config_1 = require("./typescript/ts-config");
+const task_hasher_1 = require("nx/src/hasher/task-hasher");
+/**
+ * Finds all npm dependencies and their expected versions for a given project.
+ */
+function findNpmDependencies(workspaceRoot, sourceProject, projectGraph, projectFileMap, buildTarget, options = {}) {
+    let seen = null;
+    if (options.includeTransitiveDependencies) {
+        seen = new Set();
+    }
+    const results = {};
+    function collectAll(currentProject, collectedDeps) {
+        if (seen?.has(currentProject.name))
+            return;
+        seen?.add(currentProject.name);
+        collectDependenciesFromFileMap(workspaceRoot, currentProject, projectGraph, projectFileMap, buildTarget, options.ignoredFiles, options.useLocalPathsForWorkspaceDependencies, collectedDeps);
+        collectHelperDependencies(workspaceRoot, currentProject, projectGraph, buildTarget, collectedDeps);
+        if (options.includeTransitiveDependencies) {
+            const projectDeps = projectGraph.dependencies[currentProject.name];
+            for (const dep of projectDeps) {
+                const projectDep = projectGraph.nodes[dep.target];
+                if (projectDep)
+                    collectAll(projectDep, collectedDeps);
+            }
+        }
+    }
+    collectAll(sourceProject, results);
+    return results;
+}
+exports.findNpmDependencies = findNpmDependencies;
+// Keep track of workspace libs we already read package.json for so we don't read from disk again.
+const seenWorkspaceDeps = {};
+function collectDependenciesFromFileMap(workspaceRoot, sourceProject, projectGraph, projectFileMap, buildTarget, ignoredFiles, useLocalPathsForWorkspaceDependencies, npmDeps) {
+    const rawFiles = projectFileMap[sourceProject.name];
+    if (!rawFiles)
+        return;
+    // If build target does not exist in project, use all files as input.
+    // This is needed for transitive dependencies for apps -- where libs may not be buildable.
+    const inputs = sourceProject.data.targets[buildTarget]
+        ? (0, task_hasher_1.getTargetInputs)((0, configuration_1.readNxJson)(), sourceProject, buildTarget).selfInputs
+        : ['{projectRoot}/**/*'];
+    if (ignoredFiles) {
+        for (const pattern of ignoredFiles) {
+            inputs.push(`!${pattern}`);
+        }
+    }
+    const files = (0, task_hasher_1.filterUsingGlobPatterns)(sourceProject.data.root, projectFileMap[sourceProject.name] || [], inputs);
+    for (const fileData of files) {
+        if (!fileData.deps ||
+            fileData.file ===
+                (0, devkit_1.joinPathFragments)(sourceProject.data.root, 'package.json')) {
+            continue;
+        }
+        for (const dep of fileData.deps) {
+            const target = (0, project_graph_1.fileDataDepTarget)(dep);
+            // If the node is external, then read package info from `data`.
+            const externalDep = projectGraph.externalNodes[target];
+            if (externalDep?.type === 'npm') {
+                npmDeps[externalDep.data.packageName] = externalDep.data.version;
+                continue;
+            }
+            // If node is internal, then try reading package info from `package.json` (which must exist for this to work).
+            const workspaceDep = projectGraph.nodes[target];
+            if (!workspaceDep)
+                continue;
+            const cached = seenWorkspaceDeps[workspaceDep.name];
+            if (cached) {
+                npmDeps[cached.name] = cached.version;
+            }
+            else {
+                const packageJson = readPackageJson(workspaceDep, workspaceRoot);
+                if (
+                // Check that this is a buildable project, otherwise it cannot be a dependency in package.json.
+                workspaceDep.data.targets[buildTarget] &&
+                    // Make sure package.json exists and has a valid name.
+                    packageJson?.name) {
+                    let version;
+                    if (useLocalPathsForWorkspaceDependencies) {
+                        // Find the relative `file:...` path and use that as the version value.
+                        // This is useful for monorepos like Nx where the release will handle setting the correct version in dist.
+                        const depRoot = (0, path_1.join)(workspaceRoot, workspaceDep.data.root);
+                        const ownRoot = (0, path_1.join)(workspaceRoot, sourceProject.data.root);
+                        const relativePath = (0, path_1.relative)(ownRoot, depRoot);
+                        const filePath = (0, devkit_1.normalizePath)(relativePath); // normalize slashes for windows
+                        version = `file:${filePath}`;
+                    }
+                    else {
+                        // Otherwise, read the version from the dependencies `package.json` file.
+                        // This is useful for monorepos that commit release versions.
+                        // Users can also set version as "*" in source `package.json` files, which will be the value set here.
+                        // This is useful if they use custom scripts to update them in dist.
+                        version = packageJson.version ?? '*'; // fallback in case version is missing
+                    }
+                    npmDeps[packageJson.name] = version;
+                    seenWorkspaceDeps[workspaceDep.name] = {
+                        name: packageJson.name,
+                        version,
+                    };
+                }
+            }
+        }
+    }
+}
+function readPackageJson(project, workspaceRoot) {
+    const packageJsonPath = (0, path_1.join)(workspaceRoot, project.data.root, 'package.json');
+    if ((0, fileutils_1.fileExists)(packageJsonPath))
+        return (0, devkit_1.readJsonFile)(packageJsonPath);
+    return null;
+}
+function collectHelperDependencies(workspaceRoot, sourceProject, projectGraph, buildTarget, npmDeps) {
+    const target = sourceProject.data.targets[buildTarget];
+    if (!target)
+        return;
+    if (target.executor === '@nx/js:tsc' && target.options?.tsConfig) {
+        const tsConfig = (0, ts_config_1.readTsConfig)((0, path_1.join)(workspaceRoot, target.options.tsConfig));
+        if (tsConfig?.options['importHelpers']) {
+            npmDeps['tslib'] = projectGraph.externalNodes['npm:tslib']?.data.version;
+        }
+    }
+    if (target.executor === '@nx/js:swc') {
+        const swcConfigPath = target.options.swcrc
+            ? (0, path_1.join)(workspaceRoot, target.options.swcrc)
+            : (0, path_1.join)(workspaceRoot, sourceProject.data.root, '.swcrc');
+        const swcConfig = (0, fileutils_1.fileExists)(swcConfigPath)
+            ? (0, devkit_1.readJsonFile)(swcConfigPath)
+            : {};
+        if (swcConfig?.jsc?.externalHelpers) {
+            npmDeps['@swc/helpers'] =
+                projectGraph.externalNodes['npm:@swc/helpers']?.data.version;
+        }
+    }
+}

package/src/utils/generate-globs.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Generates a set of glob patterns based off the source root of the app and its dependencies
+ * @param dirPath workspace relative directory path that will be used to infer the parent project and dependencies
+ * @param fileGlobPattern pass a custom glob pattern to be used
+ */
+export declare function createGlobPatternsForDependencies(dirPath: string, fileGlobPattern: string): string[];

package/src/utils/generate-globs.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createGlobPatternsForDependencies = void 0;
+const devkit_1 = require("@nx/devkit");
+const workspace_root_1 = require("nx/src/utils/workspace-root");
+const path_1 = require("path");
+const project_graph_1 = require("nx/src/project-graph/project-graph");
+const project_graph_utils_1 = require("nx/src/utils/project-graph-utils");
+const fs_1 = require("fs");
+const ignore_1 = require("ignore");
+const find_project_for_path_1 = require("nx/src/project-graph/utils/find-project-for-path");
+function configureIgnore() {
+    let ig;
+    const pathToGitIgnore = (0, path_1.join)(workspace_root_1.workspaceRoot, '.gitignore');
+    if ((0, fs_1.existsSync)(pathToGitIgnore)) {
+        ig = (0, ignore_1.default)();
+        ig.add((0, fs_1.readFileSync)(pathToGitIgnore, { encoding: 'utf-8' }));
+    }
+    return ig;
+}
+/**
+ * Generates a set of glob patterns based off the source root of the app and its dependencies
+ * @param dirPath workspace relative directory path that will be used to infer the parent project and dependencies
+ * @param fileGlobPattern pass a custom glob pattern to be used
+ */
+function createGlobPatternsForDependencies(dirPath, fileGlobPattern) {
+    let ig = configureIgnore();
+    const filenameRelativeToWorkspaceRoot = (0, devkit_1.normalizePath)((0, path_1.relative)(workspace_root_1.workspaceRoot, dirPath));
+    const projectGraph = (0, project_graph_1.readCachedProjectGraph)();
+    const projectRootMappings = (0, find_project_for_path_1.createProjectRootMappings)(projectGraph.nodes);
+    // find the project
+    let projectName;
+    try {
+        projectName = (0, find_project_for_path_1.findProjectForPath)(filenameRelativeToWorkspaceRoot, projectRootMappings);
+        if (!projectName) {
+            throw new Error(`createGlobPatternsForDependencies: Could not find any project containing the file "${filenameRelativeToWorkspaceRoot}" among it's project files`);
+        }
+    }
+    catch (e) {
+        throw new Error(`createGlobPatternsForDependencies: Error when trying to determine main project.\n${e?.message}`);
+    }
+    // generate the glob
+    try {
+        const [projectDirs, warnings] = (0, project_graph_utils_1.getSourceDirOfDependentProjects)(projectName, projectGraph);
+        const dirsToUse = [];
+        const recursiveScanDirs = (dirPath) => {
+            const children = (0, fs_1.readdirSync)((0, path_1.resolve)(workspace_root_1.workspaceRoot, dirPath));
+            for (const child of children) {
+                const childPath = (0, path_1.join)(dirPath, child);
+                if (ig?.ignores(childPath) ||
+                    !(0, fs_1.lstatSync)((0, path_1.resolve)(workspace_root_1.workspaceRoot, childPath)).isDirectory()) {
+                    continue;
+                }
+                if ((0, fs_1.existsSync)((0, path_1.join)(workspace_root_1.workspaceRoot, childPath, 'ng-package.json'))) {
+                    dirsToUse.push(childPath);
+                }
+                else {
+                    recursiveScanDirs(childPath);
+                }
+            }
+        };
+        for (const srcDir of projectDirs) {
+            dirsToUse.push(srcDir);
+            const root = (0, path_1.dirname)(srcDir);
+            recursiveScanDirs(root);
+        }
+        if (warnings.length > 0) {
+            devkit_1.logger.warn(`
+[createGlobPatternsForDependencies] Failed to generate glob pattern for the following:
+${warnings.join('\n- ')}\n
+due to missing "sourceRoot" in the dependencies' project configuration
+      `);
+        }
+        return dirsToUse.map((sourceDir) => (0, path_1.resolve)(workspace_root_1.workspaceRoot, (0, devkit_1.joinPathFragments)(sourceDir, fileGlobPattern)));
+    }
+    catch (e) {
+        throw new Error(`createGlobPatternsForDependencies: Error when generating globs.\n${e?.message}`);
+    }
+}
+exports.createGlobPatternsForDependencies = createGlobPatternsForDependencies;

package/src/utils/get-import-path.d.ts

@@ -0,0 +1,5 @@
+import { Tree } from '@nx/devkit';
+/**
+ * Prefixes project name with npm scope
+ */
+export declare function getImportPath(tree: Tree, projectDirectory: string): string;

package/src/utils/get-import-path.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getImportPath = void 0;
+const get_npm_scope_1 = require("./package-json/get-npm-scope");
+/**
+ * Prefixes project name with npm scope
+ */
+function getImportPath(tree, projectDirectory) {
+    const npmScope = (0, get_npm_scope_1.getNpmScope)(tree);
+    return npmScope
+        ? `${npmScope === '@' ? '' : '@'}${npmScope}/${projectDirectory}`
+        : projectDirectory;
+}
+exports.getImportPath = getImportPath;

package/src/utils/get-main-file-dir.d.ts

@@ -0,0 +1 @@
+export declare function getRelativeDirectoryToProjectRoot(file: string, projectRoot: string): string;

package/src/utils/get-main-file-dir.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRelativeDirectoryToProjectRoot = void 0;
+const path_1 = require("path");
+const path_2 = require("nx/src/utils/path");
+function getRelativeDirectoryToProjectRoot(file, projectRoot) {
+    const dir = (0, path_1.dirname)(file);
+    const relativeDir = (0, path_2.normalizePath)((0, path_1.relative)(projectRoot, dir));
+    return relativeDir === '' ? `./` : `./${relativeDir}/`;
+}
+exports.getRelativeDirectoryToProjectRoot = getRelativeDirectoryToProjectRoot;

package/src/utils/inline.d.ts

@@ -0,0 +1,19 @@
+import type { ExecutorContext } from '@nx/devkit';
+import type { NormalizedExecutorOptions } from './schema';
+interface InlineProjectNode {
+    name: string;
+    root: string;
+    sourceRoot: string;
+    pathAlias: string;
+    buildOutputPath?: string;
+}
+export interface InlineProjectGraph {
+    nodes: Record<string, InlineProjectNode>;
+    externals: Record<string, InlineProjectNode>;
+    dependencies: Record<string, string[]>;
+}
+export declare function isInlineGraphEmpty(inlineGraph: InlineProjectGraph): boolean;
+export declare function handleInliningBuild(context: ExecutorContext, options: NormalizedExecutorOptions, tsConfigPath: string, projectName?: string): InlineProjectGraph;
+export declare function postProcessInlinedDependencies(outputPath: string, parentOutputPath: string, inlineGraph: InlineProjectGraph): void;
+export declare function getRootTsConfigPath(context: ExecutorContext): string | null;
+export {};