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

package/src/utils/inline.js

@@ -0,0 +1,210 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRootTsConfigPath = exports.postProcessInlinedDependencies = exports.handleInliningBuild = exports.isInlineGraphEmpty = void 0;
+const devkit_1 = require("@nx/devkit");
+const fs_extra_1 = require("fs-extra");
+const path_1 = require("path");
+const fs_1 = require("fs");
+function isInlineGraphEmpty(inlineGraph) {
+    return Object.keys(inlineGraph.nodes).length === 0;
+}
+exports.isInlineGraphEmpty = isInlineGraphEmpty;
+function handleInliningBuild(context, options, tsConfigPath, projectName = context.projectName) {
+    const tsConfigJson = (0, devkit_1.readJsonFile)(tsConfigPath);
+    const pathAliases = tsConfigJson['compilerOptions']?.['paths'] || readBasePathAliases(context);
+    const inlineGraph = createInlineGraph(context, options, pathAliases, projectName);
+    if (isInlineGraphEmpty(inlineGraph)) {
+        return inlineGraph;
+    }
+    buildInlineGraphExternals(context, inlineGraph, pathAliases);
+    return inlineGraph;
+}
+exports.handleInliningBuild = handleInliningBuild;
+function postProcessInlinedDependencies(outputPath, parentOutputPath, inlineGraph) {
+    if (isInlineGraphEmpty(inlineGraph)) {
+        return;
+    }
+    const parentDistPath = (0, path_1.join)(outputPath, parentOutputPath);
+    const markedForDeletion = new Set();
+    // move parentOutput
+    movePackage(parentDistPath, outputPath);
+    markedForDeletion.add(parentDistPath);
+    const inlinedDepsDestOutputRecord = {};
+    // move inlined outputs
+    for (const inlineDependenciesNames of Object.values(inlineGraph.dependencies)) {
+        for (const inlineDependenciesName of inlineDependenciesNames) {
+            const inlineDependency = inlineGraph.nodes[inlineDependenciesName];
+            const depOutputPath = inlineDependency.buildOutputPath ||
+                (0, path_1.join)(outputPath, inlineDependency.root);
+            const destDepOutputPath = (0, path_1.join)(outputPath, inlineDependency.name);
+            const isBuildable = !!inlineDependency.buildOutputPath;
+            if (isBuildable) {
+                (0, fs_extra_1.copySync)(depOutputPath, destDepOutputPath, { overwrite: true });
+            }
+            else {
+                movePackage(depOutputPath, destDepOutputPath);
+                markedForDeletion.add(depOutputPath);
+            }
+            // TODO: hard-coded "src"
+            inlinedDepsDestOutputRecord[inlineDependency.pathAlias] =
+                destDepOutputPath + '/src';
+        }
+    }
+    markedForDeletion.forEach((path) => (0, fs_extra_1.removeSync)(path));
+    updateImports(outputPath, inlinedDepsDestOutputRecord);
+}
+exports.postProcessInlinedDependencies = postProcessInlinedDependencies;
+function readBasePathAliases(context) {
+    return (0, devkit_1.readJsonFile)(getRootTsConfigPath(context))?.['compilerOptions']['paths'];
+}
+function getRootTsConfigPath(context) {
+    for (const tsConfigName of ['tsconfig.base.json', 'tsconfig.json']) {
+        const tsConfigPath = (0, path_1.join)(context.root, tsConfigName);
+        if ((0, fs_1.existsSync)(tsConfigPath)) {
+            return tsConfigPath;
+        }
+    }
+    throw new Error('Could not find a root tsconfig.json or tsconfig.base.json file.');
+}
+exports.getRootTsConfigPath = getRootTsConfigPath;
+function emptyInlineGraph() {
+    return { nodes: {}, externals: {}, dependencies: {} };
+}
+function projectNodeToInlineProjectNode(projectNode, pathAlias = '', buildOutputPath = '') {
+    return {
+        name: projectNode.name,
+        root: projectNode.data.root,
+        sourceRoot: projectNode.data.sourceRoot,
+        pathAlias,
+        buildOutputPath,
+    };
+}
+function createInlineGraph(context, options, pathAliases, projectName, inlineGraph = emptyInlineGraph()) {
+    if (options.external == null)
+        return inlineGraph;
+    const projectDependencies = context.projectGraph.dependencies[projectName] || [];
+    if (projectDependencies.length === 0)
+        return inlineGraph;
+    if (!inlineGraph.nodes[projectName]) {
+        inlineGraph.nodes[projectName] = projectNodeToInlineProjectNode(context.projectGraph.nodes[projectName]);
+    }
+    const implicitDependencies = context.projectGraph.nodes[projectName].data.implicitDependencies || [];
+    for (const projectDependency of projectDependencies) {
+        // skip npm packages
+        if (projectDependency.target.startsWith('npm')) {
+            continue;
+        }
+        // skip implicitDependencies
+        if (implicitDependencies.includes(projectDependency.target)) {
+            continue;
+        }
+        const pathAlias = getPathAliasForPackage(context.projectGraph.nodes[projectDependency.target], pathAliases);
+        const buildOutputPath = getBuildOutputPath(projectDependency.target, context, options);
+        const shouldInline = 
+        /**
+         * if all buildable libraries are marked as external,
+         * then push the project dependency that doesn't have a build target
+         */
+        (options.external === 'all' && !buildOutputPath) ||
+            /**
+             * if all buildable libraries are marked as internal,
+             * then push every project dependency to be inlined
+             */
+            options.external === 'none' ||
+            /**
+             * if some buildable libraries are marked as external,
+             * then push the project dependency that IS NOT marked as external OR doesn't have a build target
+             */
+            (Array.isArray(options.external) &&
+                options.external.length > 0 &&
+                !options.external.includes(projectDependency.target)) ||
+            !buildOutputPath;
+        if (shouldInline) {
+            inlineGraph.dependencies[projectName] ??= [];
+            inlineGraph.dependencies[projectName].push(projectDependency.target);
+        }
+        inlineGraph.nodes[projectDependency.target] =
+            projectNodeToInlineProjectNode(context.projectGraph.nodes[projectDependency.target], pathAlias, buildOutputPath);
+        if (context.projectGraph.dependencies[projectDependency.target].length > 0) {
+            inlineGraph = createInlineGraph(context, options, pathAliases, projectDependency.target, inlineGraph);
+        }
+    }
+    return inlineGraph;
+}
+function buildInlineGraphExternals(context, inlineProjectGraph, pathAliases) {
+    const allNodes = { ...context.projectGraph.nodes };
+    for (const [parent, dependencies] of Object.entries(inlineProjectGraph.dependencies)) {
+        if (allNodes[parent]) {
+            delete allNodes[parent];
+        }
+        for (const dependencyName of dependencies) {
+            const dependencyNode = inlineProjectGraph.nodes[dependencyName];
+            // buildable is still external even if it is a dependency
+            if (dependencyNode.buildOutputPath) {
+                continue;
+            }
+            if (allNodes[dependencyName]) {
+                delete allNodes[dependencyName];
+            }
+        }
+    }
+    for (const [projectName, projectNode] of Object.entries(allNodes)) {
+        if (!inlineProjectGraph.externals[projectName]) {
+            inlineProjectGraph.externals[projectName] =
+                projectNodeToInlineProjectNode(projectNode, getPathAliasForPackage(projectNode, pathAliases));
+        }
+    }
+}
+function movePackage(from, to) {
+    if (from === to)
+        return;
+    (0, fs_extra_1.copySync)(from, to, { overwrite: true });
+}
+function updateImports(destOutputPath, inlinedDepsDestOutputRecord) {
+    const pathAliases = Object.keys(inlinedDepsDestOutputRecord);
+    if (pathAliases.length == 0) {
+        return;
+    }
+    const importRegex = new RegExp(pathAliases.map((pathAlias) => `["'](${pathAlias})["']`).join('|'), 'g');
+    recursiveUpdateImport(destOutputPath, importRegex, inlinedDepsDestOutputRecord);
+}
+function recursiveUpdateImport(dirPath, importRegex, inlinedDepsDestOutputRecord, rootParentDir) {
+    const files = (0, fs_extra_1.readdirSync)(dirPath, { withFileTypes: true });
+    for (const file of files) {
+        // only check .js and .d.ts files
+        if (file.isFile() &&
+            (file.name.endsWith('.js') || file.name.endsWith('.d.ts'))) {
+            const filePath = (0, path_1.join)(dirPath, file.name);
+            const fileContent = (0, fs_extra_1.readFileSync)(filePath, 'utf-8');
+            const updatedContent = fileContent.replace(importRegex, (matched) => {
+                const result = matched.replace(/['"]/g, '');
+                // If a match is the same as the rootParentDir, we're checking its own files so we return the matched as in no changes.
+                if (result === rootParentDir || !inlinedDepsDestOutputRecord[result])
+                    return matched;
+                const importPath = `"${(0, path_1.relative)(dirPath, inlinedDepsDestOutputRecord[result])}"`;
+                return (0, devkit_1.normalizePath)(importPath);
+            });
+            (0, fs_extra_1.writeFileSync)(filePath, updatedContent);
+        }
+        else if (file.isDirectory()) {
+            recursiveUpdateImport((0, path_1.join)(dirPath, file.name), importRegex, inlinedDepsDestOutputRecord, rootParentDir || file.name);
+        }
+    }
+}
+function getPathAliasForPackage(packageNode, pathAliases) {
+    if (!packageNode)
+        return '';
+    for (const [alias, paths] of Object.entries(pathAliases)) {
+        if (paths.some((path) => path.includes(packageNode.data.root))) {
+            return alias;
+        }
+    }
+    return '';
+}
+function getBuildOutputPath(projectName, context, options) {
+    const projectTargets = context.projectGraph.nodes[projectName]?.data?.targets;
+    if (!projectTargets)
+        return '';
+    const buildTarget = options.externalBuildTargets.find((buildTarget) => projectTargets[buildTarget]);
+    return buildTarget ? projectTargets[buildTarget].options['outputPath'] : '';
+}

package/src/utils/package-json/create-entry-points.d.ts

@@ -0,0 +1 @@
+export declare function createEntryPoints(additionalEntryPoints: undefined | string[], root: string): string[];

package/src/utils/package-json/create-entry-points.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEntryPoints = void 0;
+const fast_glob_1 = require("fast-glob");
+const devkit_1 = require("@nx/devkit");
+function createEntryPoints(additionalEntryPoints, root) {
+    if (!additionalEntryPoints?.length)
+        return [];
+    const files = [];
+    // NOTE: calling globSync for each pattern is slower than calling it all at once.
+    // We're doing it this way in order to show a warning for unmatched patterns.
+    // If a pattern is unmatched, it is very likely a mistake by the user.
+    // Performance impact should be negligible since there shouldn't be that many entry points.
+    // Benchmarks show only 1-3% difference in execution time.
+    for (const pattern of additionalEntryPoints) {
+        const matched = (0, fast_glob_1.sync)([pattern], { cwd: root });
+        if (!matched.length)
+            devkit_1.logger.warn(`The pattern ${pattern} did not match any files.`);
+        files.push(...matched);
+    }
+    return files;
+}
+exports.createEntryPoints = createEntryPoints;

package/src/utils/package-json/get-npm-scope.d.ts

@@ -0,0 +1,5 @@
+import { Tree } from '@nx/devkit';
+/**
+ * Read the npm scope that a workspace should use by default
+ */
+export declare function getNpmScope(tree: Tree): string | undefined;

package/src/utils/package-json/get-npm-scope.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNpmScope = void 0;
+const devkit_1 = require("@nx/devkit");
+/**
+ * Read the npm scope that a workspace should use by default
+ */
+function getNpmScope(tree) {
+    const { name } = tree.exists('package.json')
+        ? (0, devkit_1.readJson)(tree, 'package.json')
+        : { name: null };
+    if (name?.startsWith('@')) {
+        return name.split('/')[0].substring(1);
+    }
+}
+exports.getNpmScope = getNpmScope;

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

@@ -0,0 +1,13 @@
+import { ExecutorContext } from '@nx/devkit';
+import { DependentBuildableProjectNode } from '../buildable-libs-utils';
+import type { UpdatePackageJsonOption } from './update-package-json';
+export interface CopyPackageJsonOptions extends Omit<UpdatePackageJsonOption, 'projectRoot'> {
+    watch?: boolean;
+    extraDependencies?: DependentBuildableProjectNode[];
+    overrideDependencies?: DependentBuildableProjectNode[];
+}
+export interface CopyPackageJsonResult {
+    success?: boolean;
+    stop?: () => void;
+}
+export declare function copyPackageJson(_options: CopyPackageJsonOptions, context: ExecutorContext): Promise<CopyPackageJsonResult>;

package/src/utils/package-json/index.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.copyPackageJson = void 0;
+const watch_for_single_file_changes_1 = require("../watch-for-single-file-changes");
+const update_package_json_1 = require("./update-package-json");
+const check_dependencies_1 = require("../check-dependencies");
+async function copyPackageJson(_options, context) {
+    if (!context.target.options.tsConfig) {
+        throw new Error(`Could not find tsConfig option for "${context.targetName}" target of "${context.projectName}" project. Check that your project configuration is correct.`);
+    }
+    let { target, dependencies, projectRoot } = (0, check_dependencies_1.checkDependencies)(context, context.target.options.tsConfig);
+    const options = { ..._options, projectRoot };
+    if (options.extraDependencies) {
+        dependencies.push(...options.extraDependencies);
+    }
+    if (options.overrideDependencies) {
+        dependencies = options.overrideDependencies;
+    }
+    if (options.watch) {
+        const dispose = await (0, watch_for_single_file_changes_1.watchForSingleFileChanges)(context.projectName, options.projectRoot, 'package.json', () => (0, update_package_json_1.updatePackageJson)(options, context, target, dependencies));
+        // Copy it once before changes
+        (0, update_package_json_1.updatePackageJson)(options, context, target, dependencies);
+        return { success: true, stop: dispose };
+    }
+    else {
+        (0, update_package_json_1.updatePackageJson)(options, context, target, dependencies);
+        return { success: true };
+    }
+}
+exports.copyPackageJson = copyPackageJson;

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

@@ -0,0 +1,30 @@
+import { ExecutorContext, ProjectFileMap, ProjectGraphProjectNode } from '@nx/devkit';
+import { DependentBuildableProjectNode } from '../buildable-libs-utils';
+import type { PackageJson } from 'nx/src/utils/package-json';
+export type SupportedFormat = 'cjs' | 'esm';
+export interface UpdatePackageJsonOption {
+    projectRoot: string;
+    main: string;
+    additionalEntryPoints?: string[];
+    format?: SupportedFormat[];
+    outputPath: string;
+    outputFileName?: string;
+    outputFileExtensionForCjs?: `.${string}`;
+    outputFileExtensionForEsm?: `.${string}`;
+    skipTypings?: boolean;
+    generateExportsField?: boolean;
+    excludeLibsInPackageJson?: boolean;
+    updateBuildableProjectDepsInPackageJson?: boolean;
+    buildableProjectDepsInPackageJsonType?: 'dependencies' | 'peerDependencies';
+    generateLockfile?: boolean;
+}
+export declare function updatePackageJson(options: UpdatePackageJsonOption, context: ExecutorContext, target: ProjectGraphProjectNode, dependencies: DependentBuildableProjectNode[], fileMap?: ProjectFileMap): void;
+interface Exports {
+    '.': string;
+    [name: string]: string;
+}
+export declare function getExports(options: Pick<UpdatePackageJsonOption, 'main' | 'projectRoot' | 'outputFileName' | 'additionalEntryPoints'> & {
+    fileExt: string;
+}): Exports;
+export declare function getUpdatedPackageJsonContent(packageJson: PackageJson, options: UpdatePackageJsonOption): PackageJson;
+export {};

package/src/utils/package-json/update-package-json.js

@@ -0,0 +1,179 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUpdatedPackageJsonContent = exports.getExports = exports.updatePackageJson = void 0;
+// eslint-disable-next-line @typescript-eslint/no-restricted-imports
+const lock_file_1 = require("nx/src/plugins/js/lock-file/lock-file");
+// eslint-disable-next-line @typescript-eslint/no-restricted-imports
+const create_package_json_1 = require("nx/src/plugins/js/package-json/create-package-json");
+const devkit_1 = require("@nx/devkit");
+const path_1 = require("path");
+const fs_extra_1 = require("fs-extra");
+const fileutils_1 = require("nx/src/utils/fileutils");
+const fs_1 = require("fs");
+const nx_deps_cache_1 = require("nx/src/project-graph/nx-deps-cache");
+const get_main_file_dir_1 = require("../get-main-file-dir");
+function updatePackageJson(options, context, target, dependencies, fileMap = null) {
+    let packageJson;
+    if (fileMap == null) {
+        fileMap = (0, nx_deps_cache_1.readFileMapCache)()?.fileMap?.projectFileMap || {};
+    }
+    if (options.updateBuildableProjectDepsInPackageJson) {
+        packageJson = (0, create_package_json_1.createPackageJson)(context.projectName, context.projectGraph, {
+            target: context.targetName,
+            root: context.root,
+            // By default we remove devDependencies since this is a production build.
+            isProduction: true,
+        }, fileMap);
+        if (options.excludeLibsInPackageJson) {
+            dependencies = dependencies.filter((dep) => dep.node.type !== 'lib');
+        }
+        addMissingDependencies(packageJson, context, dependencies, options.buildableProjectDepsInPackageJsonType);
+    }
+    else {
+        const pathToPackageJson = (0, path_1.join)(context.root, options.projectRoot, 'package.json');
+        packageJson = (0, fileutils_1.fileExists)(pathToPackageJson)
+            ? (0, devkit_1.readJsonFile)(pathToPackageJson)
+            : { name: context.projectName, version: '0.0.1' };
+    }
+    // update package specific settings
+    packageJson = getUpdatedPackageJsonContent(packageJson, options);
+    // save files
+    (0, devkit_1.writeJsonFile)(`${options.outputPath}/package.json`, packageJson);
+    if (options.generateLockfile) {
+        const packageManager = (0, devkit_1.detectPackageManager)(context.root);
+        const lockFile = (0, lock_file_1.createLockFile)(packageJson, context.projectGraph, packageManager);
+        (0, fs_extra_1.writeFileSync)(`${options.outputPath}/${(0, lock_file_1.getLockFileName)(packageManager)}`, lockFile, {
+            encoding: 'utf-8',
+        });
+    }
+}
+exports.updatePackageJson = updatePackageJson;
+function isNpmNode(node, graph) {
+    return !!(graph.externalNodes[node.name]?.type === 'npm');
+}
+function isWorkspaceProject(node, graph) {
+    return !!graph.nodes[node.name];
+}
+function addMissingDependencies(packageJson, { projectName, targetName, configurationName, root, projectGraph, }, dependencies, propType = 'dependencies') {
+    const workspacePackageJson = (0, devkit_1.readJsonFile)((0, devkit_1.joinPathFragments)(devkit_1.workspaceRoot, 'package.json'));
+    dependencies.forEach((entry) => {
+        if (isNpmNode(entry.node, projectGraph)) {
+            const { packageName, version } = entry.node.data;
+            if (packageJson.dependencies?.[packageName] ||
+                packageJson.devDependencies?.[packageName] ||
+                packageJson.peerDependencies?.[packageName]) {
+                return;
+            }
+            if (workspacePackageJson.devDependencies?.[packageName]) {
+                return;
+            }
+            packageJson[propType] ??= {};
+            packageJson[propType][packageName] = version;
+        }
+        else if (isWorkspaceProject(entry.node, projectGraph)) {
+            const packageName = entry.name;
+            if (!!workspacePackageJson.devDependencies?.[packageName]) {
+                return;
+            }
+            if (!packageJson.dependencies?.[packageName] &&
+                !packageJson.devDependencies?.[packageName] &&
+                !packageJson.peerDependencies?.[packageName]) {
+                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');
+                if ((0, fs_1.existsSync)(depPackageJsonPath)) {
+                    const version = (0, devkit_1.readJsonFile)(depPackageJsonPath).version;
+                    packageJson[propType] ??= {};
+                    packageJson[propType][packageName] = version;
+                }
+            }
+        }
+    });
+}
+function getExports(options) {
+    const mainFile = options.outputFileName
+        ? options.outputFileName.replace(/\.[tj]s$/, '')
+        : (0, path_1.basename)(options.main).replace(/\.[tj]s$/, '');
+    const relativeMainFileDir = options.outputFileName
+        ? './'
+        : (0, get_main_file_dir_1.getRelativeDirectoryToProjectRoot)(options.main, options.projectRoot);
+    const exports = {
+        '.': relativeMainFileDir + mainFile + options.fileExt,
+    };
+    if (options.additionalEntryPoints) {
+        const jsRegex = /\.[jt]sx?$/;
+        for (const file of options.additionalEntryPoints) {
+            const { ext: fileExt, name: fileName } = (0, path_1.parse)(file);
+            const relativeDir = (0, get_main_file_dir_1.getRelativeDirectoryToProjectRoot)(file, options.projectRoot);
+            const sourceFilePath = relativeDir + fileName;
+            const entryFilepath = sourceFilePath.replace(/^\.\/src\//, './');
+            const isJsFile = jsRegex.test(fileExt);
+            exports[isJsFile ? entryFilepath : entryFilepath + fileExt] =
+                sourceFilePath + (isJsFile ? options.fileExt : fileExt);
+        }
+    }
+    return exports;
+}
+exports.getExports = getExports;
+function getUpdatedPackageJsonContent(packageJson, options) {
+    // Default is CJS unless esm is explicitly passed.
+    const hasCjsFormat = !options.format || options.format?.includes('cjs');
+    const hasEsmFormat = options.format?.includes('esm');
+    if (options.generateExportsField) {
+        packageJson.exports =
+            typeof packageJson.exports === 'string' ? {} : { ...packageJson.exports };
+        packageJson.exports['./package.json'] = './package.json';
+    }
+    if (hasEsmFormat) {
+        const esmExports = getExports({
+            ...options,
+            fileExt: options.outputFileExtensionForEsm ?? '.js',
+        });
+        packageJson.module = esmExports['.'];
+        if (!hasCjsFormat) {
+            packageJson.type = 'module';
+            packageJson.main ??= esmExports['.'];
+        }
+        if (options.generateExportsField) {
+            for (const [exportEntry, filePath] of Object.entries(esmExports)) {
+                packageJson.exports[exportEntry] = hasCjsFormat
+                    ? { import: filePath }
+                    : filePath;
+            }
+        }
+    }
+    // CJS output may have .cjs or .js file extensions.
+    // Bundlers like rollup and esbuild supports .cjs for CJS and .js for ESM.
+    // Bundlers/Compilers like webpack, tsc, swc do not have different file extensions (unless you use .mts or .cts in source).
+    if (hasCjsFormat) {
+        const cjsExports = getExports({
+            ...options,
+            fileExt: options.outputFileExtensionForCjs ?? '.js',
+        });
+        packageJson.main = cjsExports['.'];
+        if (!hasEsmFormat) {
+            packageJson.type = 'commonjs';
+        }
+        if (options.generateExportsField) {
+            for (const [exportEntry, filePath] of Object.entries(cjsExports)) {
+                if (hasEsmFormat) {
+                    packageJson.exports[exportEntry]['default'] ??= filePath;
+                }
+                else {
+                    packageJson.exports[exportEntry] = filePath;
+                }
+            }
+        }
+    }
+    if (!options.skipTypings) {
+        const mainFile = (0, path_1.basename)(options.main).replace(/\.[tj]s$/, '');
+        const relativeMainFileDir = (0, get_main_file_dir_1.getRelativeDirectoryToProjectRoot)(options.main, options.projectRoot);
+        const typingsFile = `${relativeMainFileDir}${mainFile}.d.ts`;
+        packageJson.types = packageJson.types ?? typingsFile;
+    }
+    return packageJson;
+}
+exports.getUpdatedPackageJsonContent = getUpdatedPackageJsonContent;

package/src/utils/prettier.d.ts

@@ -0,0 +1,6 @@
+import type { Options } from 'prettier';
+export interface ExistingPrettierConfig {
+    sourceFilepath: string;
+    config: Options;
+}
+export declare function resolveUserExistingPrettierConfig(): Promise<ExistingPrettierConfig | null>;

package/src/utils/prettier.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveUserExistingPrettierConfig = void 0;
+let prettier;
+try {
+    prettier = require('prettier');
+}
+catch { }
+async function resolveUserExistingPrettierConfig() {
+    if (!prettier) {
+        return null;
+    }
+    try {
+        const filepath = await prettier.resolveConfigFile();
+        if (!filepath) {
+            return null;
+        }
+        const config = await prettier.resolveConfig(process.cwd(), {
+            useCache: false,
+            config: filepath,
+        });
+        if (!config) {
+            return null;
+        }
+        return {
+            sourceFilepath: filepath,
+            config: config,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+exports.resolveUserExistingPrettierConfig = resolveUserExistingPrettierConfig;

package/src/utils/schema.d.ts

@@ -0,0 +1,87 @@
+import type { ProjectNameAndRootFormat } from '@nx/devkit/src/generators/project-name-and-root-utils';
+import type { AssetGlob, FileInputOutput } from './assets/assets';
+import { TransformerEntry } from './typescript/types';
+// nx-ignore-next-line
+const { Linter } = require('@nx/eslint'); // use require to import to avoid circular dependency
+
+export type Compiler = 'tsc' | 'swc';
+export type Bundler = 'swc' | 'tsc' | 'rollup' | 'vite' | 'esbuild' | 'none';
+
+export interface LibraryGeneratorSchema {
+  name: string;
+  directory?: string;
+  projectNameAndRootFormat?: ProjectNameAndRootFormat;
+  skipFormat?: boolean;
+  tags?: string;
+  skipTsConfig?: boolean;
+  skipPackageJson?: boolean;
+  includeBabelRc?: boolean;
+  unitTestRunner?: 'jest' | 'vitest' | 'none';
+  linter?: Linter;
+  testEnvironment?: 'jsdom' | 'node';
+  importPath?: string;
+  js?: boolean;
+  pascalCaseFiles?: boolean;
+  strict?: boolean;
+  publishable?: boolean;
+  buildable?: boolean;
+  setParserOptionsProject?: boolean;
+  config?: 'workspace' | 'project' | 'npm-scripts';
+  compiler?: Compiler;
+  bundler?: Bundler;
+  skipTypeCheck?: boolean;
+  minimal?: boolean;
+  rootProject?: boolean;
+  simpleName?: boolean;
+  addPlugin?: boolean;
+}
+
+export interface ExecutorOptions {
+  assets: Array<AssetGlob | string>;
+  main: string;
+  rootDir?: string;
+  outputPath: string;
+  tsConfig: string;
+  generateExportsField?: boolean;
+  additionalEntryPoints?: string[];
+  swcrc?: string;
+  watch: boolean;
+  clean?: boolean;
+  transformers: TransformerEntry[];
+  external?: 'all' | 'none' | string[];
+  externalBuildTargets?: string[];
+  generateLockfile?: boolean;
+}
+
+export interface NormalizedExecutorOptions extends ExecutorOptions {
+  rootDir: string;
+  projectRoot: string;
+  mainOutputPath: string;
+  files: Array<FileInputOutput>;
+  root?: string;
+  sourceRoot?: string;
+}
+
+export interface SwcExecutorOptions extends ExecutorOptions {
+  skipTypeCheck?: boolean;
+  /**
+   * @deprecated
+   */
+  swcExclude?: string[];
+}
+
+export interface SwcCliOptions {
+  srcPath: string;
+  destPath: string;
+  swcrcPath: string;
+  swcCwd: string;
+}
+
+export interface NormalizedSwcExecutorOptions
+  extends NormalizedExecutorOptions {
+  originalProjectRoot: string;
+  swcExclude: string[];
+  skipTypeCheck: boolean;
+  swcCliOptions: SwcCliOptions;
+  tmpSwcrcPath: string;
+}

package/src/utils/swc/add-swc-config.d.ts

@@ -0,0 +1,3 @@
+import { type Tree } from '@nx/devkit';
+export declare const defaultExclude: string[];
+export declare function addSwcConfig(tree: Tree, projectDir: string, type?: 'commonjs' | 'es6'): void;