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

package/src/utils/assets/copy-assets-handler.js

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CopyAssetsHandler = exports.defaultFileEventHandler = void 0;
+const minimatch_1 = require("minimatch");
+const path = require("path");
+const fse = require("fs-extra");
+const ignore_1 = require("ignore");
+const fg = require("fast-glob");
+const devkit_1 = require("@nx/devkit");
+const client_1 = require("nx/src/daemon/client/client");
+const defaultFileEventHandler = (events) => {
+    const dirs = new Set(events.map((event) => path.dirname(event.dest)));
+    dirs.forEach((d) => fse.ensureDirSync(d));
+    events.forEach((event) => {
+        if (event.type === 'create' || event.type === 'update') {
+            if (fse.lstatSync(event.src).isFile()) {
+                fse.copyFileSync(event.src, event.dest);
+            }
+        }
+        else if (event.type === 'delete') {
+            fse.removeSync(event.dest);
+        }
+        else {
+            devkit_1.logger.error(`Unknown file event: ${event.type}`);
+        }
+    });
+};
+exports.defaultFileEventHandler = defaultFileEventHandler;
+class CopyAssetsHandler {
+    constructor(opts) {
+        this.rootDir = opts.rootDir;
+        this.projectDir = opts.projectDir;
+        this.outputDir = opts.outputDir;
+        this.callback = opts.callback ?? exports.defaultFileEventHandler;
+        // TODO(jack): Should handle nested .gitignore files
+        this.ignore = (0, ignore_1.default)();
+        const gitignore = path.join(opts.rootDir, '.gitignore');
+        const nxignore = path.join(opts.rootDir, '.nxignore');
+        if (fse.existsSync(gitignore))
+            this.ignore.add(fse.readFileSync(gitignore).toString());
+        if (fse.existsSync(nxignore))
+            this.ignore.add(fse.readFileSync(nxignore).toString());
+        this.assetGlobs = opts.assets.map((f) => {
+            let isGlob = false;
+            let pattern;
+            // Input and output directories are normalized to be relative to root
+            let input;
+            let output;
+            let ignore = null;
+            if (typeof f === 'string') {
+                pattern = f;
+                input = path.relative(opts.rootDir, opts.projectDir);
+                output = path.relative(opts.rootDir, opts.outputDir);
+            }
+            else {
+                isGlob = true;
+                pattern = path.join(f.input, f.glob);
+                input = f.input;
+                output = path.join(path.relative(opts.rootDir, opts.outputDir), f.output);
+                if (f.ignore)
+                    ignore = f.ignore.map((ig) => path.join(f.input, ig));
+            }
+            return {
+                isGlob,
+                input,
+                pattern,
+                ignore,
+                output,
+            };
+        });
+    }
+    async processAllAssetsOnce() {
+        await Promise.all(this.assetGlobs.map(async (ag) => {
+            const pattern = this.normalizeAssetPattern(ag);
+            // fast-glob only supports Unix paths
+            const files = await fg(pattern.replace(/\\/g, '/'), {
+                cwd: this.rootDir,
+                dot: true, // enable hidden files
+            });
+            this.callback(this.filesToEvent(files, ag));
+        }));
+    }
+    processAllAssetsOnceSync() {
+        this.assetGlobs.forEach((ag) => {
+            const pattern = this.normalizeAssetPattern(ag);
+            // fast-glob only supports Unix paths
+            const files = fg.sync(pattern.replace(/\\/g, '/'), {
+                cwd: this.rootDir,
+                dot: true, // enable hidden files
+            });
+            this.callback(this.filesToEvent(files, ag));
+        });
+    }
+    async watchAndProcessOnAssetChange() {
+        const unregisterFileWatcher = await client_1.daemonClient.registerFileWatcher({
+            watchProjects: 'all',
+            includeGlobalWorkspaceFiles: true,
+        }, (err, data) => {
+            if (err === 'closed') {
+                devkit_1.logger.error(`Watch error: Daemon closed the connection`);
+                process.exit(1);
+            }
+            else if (err) {
+                devkit_1.logger.error(`Watch error: ${err?.message ?? 'Unknown'}`);
+            }
+            else {
+                this.processWatchEvents(data.changedFiles);
+            }
+        });
+        return () => unregisterFileWatcher();
+    }
+    async processWatchEvents(events) {
+        const fileEvents = [];
+        for (const event of events) {
+            const pathFromRoot = path.relative(this.rootDir, event.path);
+            for (const ag of this.assetGlobs) {
+                if ((0, minimatch_1.minimatch)(pathFromRoot, ag.pattern) &&
+                    !ag.ignore?.some((ig) => (0, minimatch_1.minimatch)(pathFromRoot, ig)) &&
+                    !this.ignore.ignores(pathFromRoot)) {
+                    const relPath = path.relative(ag.input, pathFromRoot);
+                    const destPath = relPath.startsWith('..') ? pathFromRoot : relPath;
+                    fileEvents.push({
+                        type: event.type,
+                        src: path.join(this.rootDir, pathFromRoot),
+                        dest: path.join(this.rootDir, ag.output, destPath),
+                    });
+                    // Match first entry and skip the rest for this file.
+                    break;
+                }
+            }
+        }
+        if (fileEvents.length > 0)
+            this.callback(fileEvents);
+    }
+    filesToEvent(files, assetGlob) {
+        return files.reduce((acc, src) => {
+            if (!assetGlob.ignore?.some((ig) => (0, minimatch_1.minimatch)(src, ig)) &&
+                !this.ignore.ignores(src)) {
+                const relPath = path.relative(assetGlob.input, src);
+                const dest = relPath.startsWith('..') ? src : relPath;
+                acc.push({
+                    type: 'create',
+                    src: path.join(this.rootDir, src),
+                    dest: path.join(this.rootDir, assetGlob.output, dest),
+                });
+            }
+            return acc;
+        }, []);
+    }
+    normalizeAssetPattern(assetEntry) {
+        return typeof assetEntry === 'string' ? assetEntry : assetEntry.pattern;
+    }
+}
+exports.CopyAssetsHandler = CopyAssetsHandler;

package/src/utils/assets/index.d.ts

@@ -0,0 +1,16 @@
+import { AssetGlob } from './assets';
+import { FileEvent } from './copy-assets-handler';
+import { ExecutorContext } from '@nx/devkit';
+export interface CopyAssetsOptions {
+    outputPath: string;
+    assets: (string | AssetGlob)[];
+    watch?: boolean | WatchMode;
+}
+export interface CopyAssetsResult {
+    success?: boolean;
+    stop?: () => void;
+}
+export interface WatchMode {
+    onCopy?: (events: FileEvent[]) => void;
+}
+export declare function copyAssets(options: CopyAssetsOptions, context: ExecutorContext): Promise<CopyAssetsResult>;

package/src/utils/assets/index.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.copyAssets = void 0;
+const copy_assets_handler_1 = require("./copy-assets-handler");
+async function copyAssets(options, context) {
+    const assetHandler = new copy_assets_handler_1.CopyAssetsHandler({
+        projectDir: context.projectsConfigurations.projects[context.projectName].root,
+        rootDir: context.root,
+        outputDir: options.outputPath,
+        assets: options.assets,
+        callback: typeof options?.watch === 'object' ? options.watch.onCopy : undefined,
+    });
+    const result = {
+        success: true,
+    };
+    if (options.watch) {
+        result.stop = await assetHandler.watchAndProcessOnAssetChange();
+    }
+    try {
+        await assetHandler.processAllAssetsOnce();
+    }
+    catch {
+        result.success = false;
+    }
+    return result;
+}
+exports.copyAssets = copyAssets;

package/src/utils/buildable-libs-utils.d.ts

@@ -0,0 +1,43 @@
+import type { ProjectGraph, ProjectGraphExternalNode, ProjectGraphProjectNode, TaskGraph } from '@nx/devkit';
+import type * as ts from 'typescript';
+export type DependentBuildableProjectNode = {
+    name: string;
+    outputs: string[];
+    node: ProjectGraphProjectNode | ProjectGraphExternalNode;
+};
+export declare function calculateProjectBuildableDependencies(taskGraph: TaskGraph | undefined, projGraph: ProjectGraph, root: string, projectName: string, targetName: string, configurationName: string, shallow?: boolean): {
+    target: ProjectGraphProjectNode;
+    dependencies: DependentBuildableProjectNode[];
+    nonBuildableDependencies: string[];
+    topLevelDependencies: DependentBuildableProjectNode[];
+};
+export declare function calculateProjectDependencies(projGraph: ProjectGraph, root: string, projectName: string, targetName: string, configurationName: string, shallow?: boolean): {
+    target: ProjectGraphProjectNode;
+    dependencies: DependentBuildableProjectNode[];
+    nonBuildableDependencies: string[];
+    topLevelDependencies: DependentBuildableProjectNode[];
+};
+export declare function calculateDependenciesFromTaskGraph(taskGraph: TaskGraph, projectGraph: ProjectGraph, root: string, projectName: string, targetName: string, configurationName: string, shallow?: boolean): {
+    target: ProjectGraphProjectNode;
+    dependencies: DependentBuildableProjectNode[];
+    nonBuildableDependencies: string[];
+    topLevelDependencies: DependentBuildableProjectNode[];
+};
+/**
+ * Util function to create tsconfig compilerOptions object with support for workspace libs paths.
+ *
+ *
+ *
+ * @param tsConfig String of config path or object parsed via ts.parseJsonConfigFileContent.
+ * @param dependencies Dependencies calculated by Nx.
+ */
+export declare function computeCompilerOptionsPaths(tsConfig: string | ts.ParsedCommandLine, dependencies: DependentBuildableProjectNode[]): ts.MapLike<string[]>;
+export declare function createTmpTsConfig(tsconfigPath: string, workspaceRoot: string, projectRoot: string, dependencies: DependentBuildableProjectNode[]): string;
+export declare function checkDependentProjectsHaveBeenBuilt(root: string, projectName: string, targetName: string, projectDependencies: DependentBuildableProjectNode[]): boolean;
+export declare function findMissingBuildDependencies(root: string, projectName: string, targetName: string, projectDependencies: DependentBuildableProjectNode[]): DependentBuildableProjectNode[];
+export declare function updatePaths(dependencies: DependentBuildableProjectNode[], paths: Record<string, string[]>): void;
+/**
+ * Updates the peerDependencies section in the `dist/lib/xyz/package.json` with
+ * the proper dependency and version
+ */
+export declare function updateBuildableProjectPackageJsonDependencies(root: string, projectName: string, targetName: string, configurationName: string, node: ProjectGraphProjectNode, dependencies: DependentBuildableProjectNode[], typeOfDependency?: 'dependencies' | 'peerDependencies'): void;

package/src/utils/buildable-libs-utils.js

@@ -0,0 +1,375 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateBuildableProjectPackageJsonDependencies = exports.updatePaths = exports.findMissingBuildDependencies = exports.checkDependentProjectsHaveBeenBuilt = exports.createTmpTsConfig = exports.computeCompilerOptionsPaths = exports.calculateDependenciesFromTaskGraph = exports.calculateProjectDependencies = exports.calculateProjectBuildableDependencies = void 0;
+const devkit_1 = require("@nx/devkit");
+const fs_1 = require("fs");
+const operators_1 = require("nx/src/project-graph/operators");
+const fileutils_1 = require("nx/src/utils/fileutils");
+const output_1 = require("nx/src/utils/output");
+const path_1 = require("path");
+const ts_config_1 = require("./typescript/ts-config");
+function isBuildable(target, node) {
+    return (node.data.targets &&
+        node.data.targets[target] &&
+        node.data.targets[target].executor !== '');
+}
+function calculateProjectBuildableDependencies(taskGraph, projGraph, root, projectName, targetName, configurationName, shallow) {
+    if (process.env.NX_BUILDABLE_LIBRARIES_TASK_GRAPH === 'true' && taskGraph) {
+        return calculateDependenciesFromTaskGraph(taskGraph, projGraph, root, projectName, targetName, configurationName, shallow);
+    }
+    return calculateProjectDependencies(projGraph, root, projectName, targetName, configurationName, shallow);
+}
+exports.calculateProjectBuildableDependencies = calculateProjectBuildableDependencies;
+function calculateProjectDependencies(projGraph, root, projectName, targetName, configurationName, shallow) {
+    const target = projGraph.nodes[projectName];
+    // gather the library dependencies
+    const nonBuildableDependencies = [];
+    const topLevelDependencies = [];
+    const collectedDeps = collectDependencies(projectName, projGraph, [], shallow);
+    const missing = collectedDeps.reduce((missing, { name: dep }) => {
+        const depNode = projGraph.nodes[dep] || projGraph.externalNodes[dep];
+        if (!depNode) {
+            missing = missing || [];
+            missing.push(dep);
+        }
+        return missing;
+    }, null);
+    if (missing) {
+        throw new Error(`Unable to find ${missing.join(', ')} in project graph.`);
+    }
+    const dependencies = collectedDeps
+        .map(({ name: dep, isTopLevel }) => {
+        let project = null;
+        const depNode = projGraph.nodes[dep] || projGraph.externalNodes[dep];
+        if (depNode.type === 'lib') {
+            if (isBuildable(targetName, depNode)) {
+                const libPackageJsonPath = (0, path_1.join)(root, depNode.data.root, 'package.json');
+                project = {
+                    name: (0, fileutils_1.fileExists)(libPackageJsonPath)
+                        ? (0, devkit_1.readJsonFile)(libPackageJsonPath).name // i.e. @workspace/mylib
+                        : dep,
+                    outputs: (0, devkit_1.getOutputsForTargetAndConfiguration)({
+                        project: projectName,
+                        target: targetName,
+                        configuration: configurationName,
+                    }, {}, depNode),
+                    node: depNode,
+                };
+            }
+            else {
+                nonBuildableDependencies.push(dep);
+            }
+        }
+        else if (depNode.type === 'npm') {
+            project = {
+                name: depNode.data.packageName,
+                outputs: [],
+                node: depNode,
+            };
+        }
+        if (project && isTopLevel) {
+            topLevelDependencies.push(project);
+        }
+        return project;
+    })
+        .filter((x) => !!x);
+    dependencies.sort((a, b) => (a.name > b.name ? 1 : b.name > a.name ? -1 : 0));
+    return {
+        target,
+        dependencies,
+        nonBuildableDependencies,
+        topLevelDependencies,
+    };
+}
+exports.calculateProjectDependencies = calculateProjectDependencies;
+function collectDependencies(project, projGraph, acc, shallow, areTopLevelDeps = true) {
+    (projGraph.dependencies[project] || []).forEach((dependency) => {
+        const existingEntry = acc.find((dep) => dep.name === dependency.target);
+        if (!existingEntry) {
+            // Temporary skip this. Currently the set of external nodes is built from package.json, not lock file.
+            // As a result, some nodes might be missing. This should not cause any issues, we can just skip them.
+            if (dependency.target.startsWith('npm:') &&
+                !projGraph.externalNodes[dependency.target])
+                return;
+            acc.push({ name: dependency.target, isTopLevel: areTopLevelDeps });
+            const isInternalTarget = projGraph.nodes[dependency.target];
+            if (!shallow && isInternalTarget) {
+                collectDependencies(dependency.target, projGraph, acc, shallow, false);
+            }
+        }
+        else if (areTopLevelDeps && !existingEntry.isTopLevel) {
+            existingEntry.isTopLevel = true;
+        }
+    });
+    return acc;
+}
+function readTsConfigWithRemappedPaths(tsConfig, generatedTsConfigPath, dependencies) {
+    const generatedTsConfig = { compilerOptions: {} };
+    generatedTsConfig.extends = (0, path_1.relative)((0, path_1.dirname)(generatedTsConfigPath), tsConfig);
+    generatedTsConfig.compilerOptions.paths = computeCompilerOptionsPaths(tsConfig, dependencies);
+    if (process.env.NX_VERBOSE_LOGGING_PATH_MAPPINGS === 'true') {
+        output_1.output.log({
+            title: 'TypeScript path mappings have been rewritten.',
+        });
+        console.log(JSON.stringify(generatedTsConfig.compilerOptions.paths, null, 2));
+    }
+    return generatedTsConfig;
+}
+function calculateDependenciesFromTaskGraph(taskGraph, projectGraph, root, projectName, targetName, configurationName, shallow) {
+    const target = projectGraph.nodes[projectName];
+    const nonBuildableDependencies = [];
+    const topLevelDependencies = [];
+    const dependentTasks = collectDependentTasks(projectName, `${projectName}:${targetName}${configurationName ? `:${configurationName}` : ''}`, taskGraph, projectGraph, shallow);
+    const npmDependencies = collectNpmDependencies(projectName, projectGraph, !shallow ? dependentTasks : undefined);
+    const dependencies = [];
+    for (const [taskName, { isTopLevel }] of dependentTasks) {
+        let project = null;
+        const depTask = taskGraph.tasks[taskName];
+        const depProjectNode = projectGraph.nodes?.[depTask.target.project];
+        if (depProjectNode?.type !== 'lib') {
+            continue;
+        }
+        let outputs = (0, devkit_1.getOutputsForTargetAndConfiguration)(depTask.target, depTask.overrides, depProjectNode);
+        if (outputs.length === 0) {
+            nonBuildableDependencies.push(depTask.target.project);
+            continue;
+        }
+        const libPackageJsonPath = (0, path_1.join)(root, depProjectNode.data.root, 'package.json');
+        project = {
+            name: (0, fileutils_1.fileExists)(libPackageJsonPath)
+                ? (0, devkit_1.readJsonFile)(libPackageJsonPath).name // i.e. @workspace/mylib
+                : depTask.target.project,
+            outputs,
+            node: depProjectNode,
+        };
+        if (isTopLevel) {
+            topLevelDependencies.push(project);
+        }
+        dependencies.push(project);
+    }
+    for (const { project, isTopLevel } of npmDependencies) {
+        if (isTopLevel) {
+            topLevelDependencies.push(project);
+        }
+        dependencies.push(project);
+    }
+    dependencies.sort((a, b) => (a.name > b.name ? 1 : b.name > a.name ? -1 : 0));
+    return {
+        target,
+        dependencies,
+        nonBuildableDependencies,
+        topLevelDependencies,
+    };
+}
+exports.calculateDependenciesFromTaskGraph = calculateDependenciesFromTaskGraph;
+function collectNpmDependencies(projectName, projectGraph, dependentTasks, collectedPackages = new Set(), isTopLevel = true) {
+    const dependencies = projectGraph.dependencies[projectName]
+        .map((dep) => {
+        const projectNode = projectGraph.nodes?.[dep.target] ??
+            projectGraph.externalNodes?.[dep.target];
+        if (projectNode?.type !== 'npm' ||
+            collectedPackages.has(projectNode.data.packageName)) {
+            return null;
+        }
+        const project = {
+            name: projectNode.data.packageName,
+            outputs: [],
+            node: projectNode,
+        };
+        collectedPackages.add(project.name);
+        return { project, isTopLevel };
+    })
+        .filter((x) => !!x);
+    if (dependentTasks?.size) {
+        for (const [, { project: projectName }] of dependentTasks) {
+            dependencies.push(...collectNpmDependencies(projectName, projectGraph, undefined, collectedPackages, false));
+        }
+    }
+    return dependencies;
+}
+function collectDependentTasks(project, task, taskGraph, projectGraph, shallow, areTopLevelDeps = true, dependentTasks = new Map()) {
+    for (const depTask of taskGraph.dependencies[task] ?? []) {
+        if (dependentTasks.has(depTask)) {
+            if (!dependentTasks.get(depTask).isTopLevel && areTopLevelDeps) {
+                dependentTasks.get(depTask).isTopLevel = true;
+            }
+            continue;
+        }
+        const { project: depTaskProject } = (0, devkit_1.parseTargetString)(depTask, projectGraph);
+        if (depTaskProject !== project) {
+            dependentTasks.set(depTask, {
+                project: depTaskProject,
+                isTopLevel: areTopLevelDeps,
+            });
+        }
+        if (!shallow) {
+            collectDependentTasks(depTaskProject, depTask, taskGraph, projectGraph, shallow, depTaskProject === project && areTopLevelDeps, dependentTasks);
+        }
+    }
+    return dependentTasks;
+}
+/**
+ * Util function to create tsconfig compilerOptions object with support for workspace libs paths.
+ *
+ *
+ *
+ * @param tsConfig String of config path or object parsed via ts.parseJsonConfigFileContent.
+ * @param dependencies Dependencies calculated by Nx.
+ */
+function computeCompilerOptionsPaths(tsConfig, dependencies) {
+    const paths = (0, ts_config_1.readTsConfigPaths)(tsConfig) || {};
+    updatePaths(dependencies, paths);
+    return paths;
+}
+exports.computeCompilerOptionsPaths = computeCompilerOptionsPaths;
+function createTmpTsConfig(tsconfigPath, workspaceRoot, projectRoot, dependencies) {
+    const tmpTsConfigPath = (0, path_1.join)(workspaceRoot, 'tmp', projectRoot, 'tsconfig.generated.json');
+    const parsedTSConfig = readTsConfigWithRemappedPaths(tsconfigPath, tmpTsConfigPath, dependencies);
+    process.on('exit', () => cleanupTmpTsConfigFile(tmpTsConfigPath));
+    (0, devkit_1.writeJsonFile)(tmpTsConfigPath, parsedTSConfig);
+    return (0, path_1.join)(tmpTsConfigPath);
+}
+exports.createTmpTsConfig = createTmpTsConfig;
+function cleanupTmpTsConfigFile(tmpTsConfigPath) {
+    try {
+        if (tmpTsConfigPath) {
+            (0, fs_1.unlinkSync)(tmpTsConfigPath);
+        }
+    }
+    catch (e) { }
+}
+function checkDependentProjectsHaveBeenBuilt(root, projectName, targetName, projectDependencies) {
+    const missing = findMissingBuildDependencies(root, projectName, targetName, projectDependencies);
+    if (missing.length > 0) {
+        console.error((0, devkit_1.stripIndents) `
+      It looks like all of ${projectName}'s dependencies have not been built yet:
+      ${missing.map((x) => ` - ${x.node.name}`).join('\n')}
+
+      You might be missing a "targetDefaults" configuration in your root nx.json (https://nx.dev/reference/project-configuration#target-defaults),
+      or "dependsOn" configured in ${projectName}'s project.json (https://nx.dev/reference/project-configuration#dependson) 
+    `);
+        return false;
+    }
+    else {
+        return true;
+    }
+}
+exports.checkDependentProjectsHaveBeenBuilt = checkDependentProjectsHaveBeenBuilt;
+function findMissingBuildDependencies(root, projectName, targetName, projectDependencies) {
+    const depLibsToBuildFirst = [];
+    // verify whether all dependent libraries have been built
+    projectDependencies.forEach((dep) => {
+        if (dep.node.type !== 'lib') {
+            return;
+        }
+        const paths = dep.outputs.map((p) => (0, path_1.join)(root, p));
+        if (!paths.some(fileutils_1.directoryExists)) {
+            depLibsToBuildFirst.push(dep);
+        }
+    });
+    return depLibsToBuildFirst;
+}
+exports.findMissingBuildDependencies = findMissingBuildDependencies;
+function updatePaths(dependencies, paths) {
+    const pathsKeys = Object.keys(paths);
+    // For each registered dependency
+    dependencies.forEach((dep) => {
+        // If there are outputs
+        if (dep.outputs && dep.outputs.length > 0) {
+            // Directly map the dependency name to the output paths (dist/packages/..., etc.)
+            paths[dep.name] = dep.outputs;
+            // check for secondary entrypoints
+            // For each registered path
+            for (const path of pathsKeys) {
+                const nestedName = `${dep.name}/`;
+                // If the path points to the current dependency and is nested (/)
+                if (path.startsWith(nestedName)) {
+                    const nestedPart = path.slice(nestedName.length);
+                    // Bind secondary endpoints for ng-packagr projects
+                    let mappedPaths = dep.outputs.map((output) => `${output}/${nestedPart}`);
+                    // Get the dependency's package name
+                    const { root } = (dep.node?.data || {});
+                    if (root) {
+                        // Update nested mappings to point to the dependency's output paths
+                        mappedPaths = mappedPaths.concat(paths[path].flatMap((path) => dep.outputs.map((output) => path.replace(root, output))));
+                    }
+                    paths[path] = mappedPaths;
+                }
+            }
+        }
+    });
+}
+exports.updatePaths = updatePaths;
+/**
+ * Updates the peerDependencies section in the `dist/lib/xyz/package.json` with
+ * the proper dependency and version
+ */
+function updateBuildableProjectPackageJsonDependencies(root, projectName, targetName, configurationName, node, dependencies, typeOfDependency = 'dependencies') {
+    const outputs = (0, devkit_1.getOutputsForTargetAndConfiguration)({
+        project: projectName,
+        target: targetName,
+        configuration: configurationName,
+    }, {}, node);
+    const packageJsonPath = `${outputs[0]}/package.json`;
+    let packageJson;
+    let workspacePackageJson;
+    try {
+        packageJson = (0, devkit_1.readJsonFile)(packageJsonPath);
+        workspacePackageJson = (0, devkit_1.readJsonFile)(`${root}/package.json`);
+    }
+    catch (e) {
+        // cannot find or invalid package.json
+        return;
+    }
+    packageJson.dependencies = packageJson.dependencies || {};
+    packageJson.peerDependencies = packageJson.peerDependencies || {};
+    let updatePackageJson = false;
+    dependencies.forEach((entry) => {
+        const packageName = (0, operators_1.isNpmProject)(entry.node)
+            ? entry.node.data.packageName
+            : entry.name;
+        if (!hasDependency(packageJson, 'dependencies', packageName) &&
+            !hasDependency(packageJson, 'devDependencies', packageName) &&
+            !hasDependency(packageJson, 'peerDependencies', packageName)) {
+            try {
+                let depVersion;
+                if (entry.node.type === 'lib') {
+                    const outputs = (0, devkit_1.getOutputsForTargetAndConfiguration)({
+                        project: projectName,
+                        target: targetName,
+                        configuration: configurationName,
+                    }, {}, entry.node);
+                    const depPackageJsonPath = (0, path_1.join)(root, outputs[0], 'package.json');
+                    depVersion = (0, devkit_1.readJsonFile)(depPackageJsonPath).version;
+                    packageJson[typeOfDependency][packageName] = depVersion;
+                }
+                else if ((0, operators_1.isNpmProject)(entry.node)) {
+                    // If an npm dep is part of the workspace devDependencies, do not include it the library
+                    if (!!workspacePackageJson.devDependencies?.[entry.node.data.packageName]) {
+                        return;
+                    }
+                    depVersion = entry.node.data.version;
+                    packageJson[typeOfDependency][entry.node.data.packageName] =
+                        depVersion;
+                }
+                updatePackageJson = true;
+            }
+            catch (e) {
+                // skip if cannot find package.json
+            }
+        }
+    });
+    if (updatePackageJson) {
+        (0, devkit_1.writeJsonFile)(packageJsonPath, packageJson);
+    }
+}
+exports.updateBuildableProjectPackageJsonDependencies = updateBuildableProjectPackageJsonDependencies;
+// verify whether the package.json already specifies the dep
+function hasDependency(outputJson, depConfigName, packageName) {
+    if (outputJson[depConfigName]) {
+        return outputJson[depConfigName][packageName];
+    }
+    else {
+        return false;
+    }
+}

package/src/utils/check-dependencies.d.ts

@@ -0,0 +1,8 @@
+import { ExecutorContext, ProjectGraphProjectNode } from '@nx/devkit';
+import { DependentBuildableProjectNode } from './buildable-libs-utils';
+export declare function checkDependencies(context: ExecutorContext, tsConfigPath: string): {
+    tmpTsConfig: string | null;
+    projectRoot: string;
+    target: ProjectGraphProjectNode;
+    dependencies: DependentBuildableProjectNode[];
+};

package/src/utils/check-dependencies.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkDependencies = void 0;
+const buildable_libs_utils_1 = require("./buildable-libs-utils");
+function checkDependencies(context, tsConfigPath) {
+    const { target, dependencies } = (0, buildable_libs_utils_1.calculateProjectBuildableDependencies)(context.taskGraph, context.projectGraph, context.root, context.projectName, context.targetName, context.configurationName);
+    const projectRoot = target.data.root;
+    if (dependencies.length > 0) {
+        return {
+            tmpTsConfig: (0, buildable_libs_utils_1.createTmpTsConfig)(tsConfigPath, context.root, projectRoot, dependencies),
+            projectRoot,
+            target,
+            dependencies,
+        };
+    }
+    return {
+        tmpTsConfig: null,
+        projectRoot,
+        target,
+        dependencies,
+    };
+}
+exports.checkDependencies = checkDependencies;

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

@@ -0,0 +1 @@
+export declare function highlight(code: string): string;