@ohos-ports/nx 17.3.2-beta.0

package/src/plugins/js/project-graph/build-dependencies/target-project-locator.js

@@ -0,0 +1,183 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TargetProjectLocator = void 0;
+const typescript_1 = require("../../utils/typescript");
+const fileutils_1 = require("../../../../utils/fileutils");
+const path_1 = require("path");
+const workspace_root_1 = require("../../../../utils/workspace-root");
+const module_1 = require("module");
+const find_project_for_path_1 = require("../../../../project-graph/utils/find-project-for-path");
+const builtInModuleSet = new Set([
+    ...module_1.builtinModules,
+    ...module_1.builtinModules.map((x) => `node:${x}`),
+]);
+class TargetProjectLocator {
+    constructor(nodes, externalNodes) {
+        this.nodes = nodes;
+        this.externalNodes = externalNodes;
+        this.projectRootMappings = (0, find_project_for_path_1.createProjectRootMappings)(this.nodes);
+        this.npmProjects = filterRootExternalDependencies(this.externalNodes);
+        this.tsConfig = this.getRootTsConfig();
+        this.paths = this.tsConfig.config?.compilerOptions?.paths;
+        this.typescriptResolutionCache = new Map();
+        this.npmResolutionCache = new Map();
+    }
+    /**
+     * Find a project based on its import
+     *
+     * @param importExpr
+     * @param filePath
+     */
+    findProjectWithImport(importExpr, filePath) {
+        if ((0, fileutils_1.isRelativePath)(importExpr)) {
+            const resolvedModule = path_1.posix.join((0, path_1.dirname)(filePath), importExpr);
+            return this.findProjectOfResolvedModule(resolvedModule);
+        }
+        // find project using tsconfig paths
+        const results = this.findPaths(importExpr);
+        if (results) {
+            const [path, paths] = results;
+            for (let p of paths) {
+                const r = p.endsWith('/*')
+                    ? (0, path_1.join)((0, path_1.dirname)(p), (0, path_1.relative)(path.replace(/\*$/, ''), importExpr))
+                    : p;
+                const maybeResolvedProject = this.findProjectOfResolvedModule(r);
+                if (maybeResolvedProject) {
+                    return maybeResolvedProject;
+                }
+            }
+        }
+        if (builtInModuleSet.has(importExpr)) {
+            this.npmResolutionCache.set(importExpr, null);
+            return null;
+        }
+        // try to find npm package before using expensive typescript resolution
+        const npmProject = this.findNpmPackage(importExpr);
+        if (npmProject) {
+            return npmProject;
+        }
+        if (this.tsConfig.config) {
+            // TODO(meeroslav): this block is probably obsolete
+            // and existed only because of the incomplete `paths` matching
+            // if import cannot be matched using tsconfig `paths` the compilation would fail anyway
+            const resolvedProject = this.resolveImportWithTypescript(importExpr, filePath);
+            if (resolvedProject) {
+                return resolvedProject;
+            }
+        }
+        try {
+            const resolvedModule = this.resolveImportWithRequire(importExpr, filePath);
+            return this.findProjectOfResolvedModule(resolvedModule);
+        }
+        catch { }
+        // nothing found, cache for later
+        this.npmResolutionCache.set(importExpr, null);
+        return null;
+    }
+    /**
+     * Return file paths matching the import relative to the repo root
+     * @param normalizedImportExpr
+     * @returns
+     */
+    findPaths(normalizedImportExpr) {
+        if (!this.paths) {
+            return undefined;
+        }
+        if (this.paths[normalizedImportExpr]) {
+            return [normalizedImportExpr, this.paths[normalizedImportExpr]];
+        }
+        const wildcardPath = Object.keys(this.paths).find((path) => path.endsWith('/*') &&
+            (normalizedImportExpr.startsWith(path.replace(/\*$/, '')) ||
+                normalizedImportExpr === path.replace(/\/\*$/, '')));
+        if (wildcardPath) {
+            return [wildcardPath, this.paths[wildcardPath]];
+        }
+        return undefined;
+    }
+    resolveImportWithTypescript(normalizedImportExpr, filePath) {
+        let resolvedModule;
+        if (this.typescriptResolutionCache.has(normalizedImportExpr)) {
+            resolvedModule = this.typescriptResolutionCache.get(normalizedImportExpr);
+        }
+        else {
+            resolvedModule = (0, typescript_1.resolveModuleByImport)(normalizedImportExpr, filePath, this.tsConfig.absolutePath);
+            this.typescriptResolutionCache.set(normalizedImportExpr, resolvedModule ? resolvedModule : null);
+        }
+        // TODO: vsavkin temporary workaround. Remove it once we reworking handling of npm packages.
+        if (resolvedModule && resolvedModule.indexOf('node_modules/') === -1) {
+            const resolvedProject = this.findProjectOfResolvedModule(resolvedModule);
+            if (resolvedProject) {
+                return resolvedProject;
+            }
+        }
+        return;
+    }
+    resolveImportWithRequire(normalizedImportExpr, filePath) {
+        return path_1.posix.relative(workspace_root_1.workspaceRoot, require.resolve(normalizedImportExpr, {
+            paths: [(0, path_1.dirname)(filePath)],
+        }));
+    }
+    findNpmPackage(npmImport) {
+        if (this.npmResolutionCache.has(npmImport)) {
+            return this.npmResolutionCache.get(npmImport);
+        }
+        else {
+            const pkg = this.npmProjects.find((pkg) => npmImport === pkg.data.packageName ||
+                npmImport.startsWith(`${pkg.data.packageName}/`));
+            if (pkg) {
+                this.npmResolutionCache.set(npmImport, pkg.name);
+                return pkg.name;
+            }
+        }
+    }
+    findProjectOfResolvedModule(resolvedModule) {
+        if (resolvedModule.startsWith('node_modules/') ||
+            resolvedModule.includes('/node_modules/')) {
+            return undefined;
+        }
+        const normalizedResolvedModule = resolvedModule.startsWith('./')
+            ? resolvedModule.substring(2)
+            : resolvedModule;
+        const importedProject = this.findMatchingProjectFiles(normalizedResolvedModule);
+        return importedProject ? importedProject.name : void 0;
+    }
+    getAbsolutePath(path) {
+        return (0, path_1.join)(workspace_root_1.workspaceRoot, path);
+    }
+    getRootTsConfig() {
+        const path = (0, typescript_1.getRootTsConfigFileName)();
+        if (!path) {
+            return {
+                path: null,
+                absolutePath: null,
+                config: null,
+            };
+        }
+        const absolutePath = this.getAbsolutePath(path);
+        return {
+            absolutePath,
+            path,
+            config: (0, fileutils_1.readJsonFile)(absolutePath),
+        };
+    }
+    findMatchingProjectFiles(file) {
+        const project = (0, find_project_for_path_1.findProjectForPath)(file, this.projectRootMappings);
+        return this.nodes[project];
+    }
+}
+exports.TargetProjectLocator = TargetProjectLocator;
+// matches `npm:@scope/name`, `npm:name` but not `npm:@scope/name@version` and `npm:name@version`
+const ROOT_VERSION_PACKAGE_NAME_REGEX = /^npm:(?!.+@.+)/;
+function filterRootExternalDependencies(externalNodes) {
+    if (!externalNodes) {
+        return [];
+    }
+    const keys = Object.keys(externalNodes);
+    const nodes = [];
+    for (let i = 0; i < keys.length; i++) {
+        if (keys[i].match(ROOT_VERSION_PACKAGE_NAME_REGEX)) {
+            nodes.push(externalNodes[keys[i]]);
+        }
+    }
+    return nodes;
+}

package/src/plugins/js/project-graph/build-dependencies/typescript-import-locator.d.ts

@@ -0,0 +1,16 @@
+import { DependencyType } from '../../../../config/project-graph';
+/**
+ * @deprecated This is deprecated and will be removed in Nx 19.
+ * This was not intended to be exposed.
+ * Please talk to us if you need this.
+ */
+export declare class TypeScriptImportLocator {
+    private readonly scanner;
+    constructor();
+    fromFile(filePath: string, visitor: (importExpr: string, filePath: string, type: DependencyType) => void): void;
+    fromNode(filePath: string, node: any, visitor: (importExpr: string, filePath: string, type: DependencyType) => void): void;
+    private ignoreStatement;
+    private ignoreLoadChildrenDependency;
+    private getPropertyAssignmentName;
+    private getStringLiteralValue;
+}

package/src/plugins/js/project-graph/build-dependencies/typescript-import-locator.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeScriptImportLocator = void 0;
+const path = require("path");
+const project_graph_1 = require("../../../../config/project-graph");
+const file_utils_1 = require("../../../../project-graph/file-utils");
+const strip_source_code_1 = require("./strip-source-code");
+let tsModule;
+/**
+ * @deprecated This is deprecated and will be removed in Nx 19.
+ * This was not intended to be exposed.
+ * Please talk to us if you need this.
+ */
+class TypeScriptImportLocator {
+    constructor() {
+        tsModule = require('typescript');
+        this.scanner = tsModule.createScanner(tsModule.ScriptTarget.Latest, false);
+    }
+    fromFile(filePath, visitor) {
+        const extension = path.extname(filePath);
+        if (extension !== '.ts' &&
+            extension !== '.mts' &&
+            extension !== '.tsx' &&
+            extension !== '.js' &&
+            extension !== '.mjs' &&
+            extension !== '.jsx') {
+            return;
+        }
+        const content = (0, file_utils_1.defaultFileRead)(filePath);
+        const strippedContent = (0, strip_source_code_1.stripSourceCode)(this.scanner, content);
+        if (strippedContent !== '') {
+            const tsFile = tsModule.createSourceFile(filePath, strippedContent, tsModule.ScriptTarget.Latest, true);
+            this.fromNode(filePath, tsFile, visitor);
+        }
+    }
+    fromNode(filePath, node, visitor) {
+        if (tsModule.isImportDeclaration(node) ||
+            (tsModule.isExportDeclaration(node) && node.moduleSpecifier)) {
+            if (!this.ignoreStatement(node)) {
+                const imp = this.getStringLiteralValue(node.moduleSpecifier);
+                visitor(imp, filePath, project_graph_1.DependencyType.static);
+            }
+            return; // stop traversing downwards
+        }
+        if (tsModule.isCallExpression(node) &&
+            node.expression.kind === tsModule.SyntaxKind.ImportKeyword &&
+            node.arguments.length === 1 &&
+            tsModule.isStringLiteral(node.arguments[0])) {
+            if (!this.ignoreStatement(node)) {
+                const imp = this.getStringLiteralValue(node.arguments[0]);
+                visitor(imp, filePath, project_graph_1.DependencyType.dynamic);
+            }
+            return;
+        }
+        if (tsModule.isCallExpression(node) &&
+            node.expression.getText() === 'require' &&
+            node.arguments.length === 1 &&
+            tsModule.isStringLiteral(node.arguments[0])) {
+            if (!this.ignoreStatement(node)) {
+                const imp = this.getStringLiteralValue(node.arguments[0]);
+                visitor(imp, filePath, project_graph_1.DependencyType.static);
+            }
+            return;
+        }
+        if (node.kind === tsModule.SyntaxKind.PropertyAssignment) {
+            const name = this.getPropertyAssignmentName(node.name);
+            if (name === 'loadChildren') {
+                const init = node.initializer;
+                if (init.kind === tsModule.SyntaxKind.StringLiteral &&
+                    !this.ignoreLoadChildrenDependency(node.getFullText())) {
+                    const childrenExpr = this.getStringLiteralValue(init);
+                    visitor(childrenExpr, filePath, project_graph_1.DependencyType.dynamic);
+                    return; // stop traversing downwards
+                }
+            }
+        }
+        /**
+         * Continue traversing down the AST from the current node
+         */
+        tsModule.forEachChild(node, (child) => this.fromNode(filePath, child, visitor));
+    }
+    ignoreStatement(node) {
+        return (0, strip_source_code_1.stripSourceCode)(this.scanner, node.getFullText()) === '';
+    }
+    ignoreLoadChildrenDependency(contents) {
+        this.scanner.setText(contents);
+        let token = this.scanner.scan();
+        while (token !== tsModule.SyntaxKind.EndOfFileToken) {
+            if (token === tsModule.SyntaxKind.SingleLineCommentTrivia ||
+                token === tsModule.SyntaxKind.MultiLineCommentTrivia) {
+                const start = this.scanner.getStartPos() + 2;
+                token = this.scanner.scan();
+                const isMultiLineCommentTrivia = token === tsModule.SyntaxKind.MultiLineCommentTrivia;
+                const end = this.scanner.getStartPos() - (isMultiLineCommentTrivia ? 2 : 0);
+                const comment = contents.substring(start, end).trim();
+                if (comment === 'nx-ignore-next-line') {
+                    return true;
+                }
+            }
+            else {
+                token = this.scanner.scan();
+            }
+        }
+        return false;
+    }
+    getPropertyAssignmentName(nameNode) {
+        switch (nameNode.kind) {
+            case tsModule.SyntaxKind.Identifier:
+                return nameNode.getText();
+            case tsModule.SyntaxKind.StringLiteral:
+                return nameNode.text;
+            default:
+                return null;
+        }
+    }
+    getStringLiteralValue(node) {
+        return node.getText().slice(1, -1);
+    }
+}
+exports.TypeScriptImportLocator = TypeScriptImportLocator;

package/src/plugins/js/project-graph/build-nodes/build-npm-package-nodes.d.ts

@@ -0,0 +1,2 @@
+import { ProjectGraphBuilder } from '../../../../project-graph/project-graph-builder';
+export declare function buildNpmPackageNodes(builder: ProjectGraphBuilder): void;

package/src/plugins/js/project-graph/build-nodes/build-npm-package-nodes.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildNpmPackageNodes = void 0;
+const fs_1 = require("fs");
+const file_hasher_1 = require("../../../../hasher/file-hasher");
+const path_1 = require("path");
+const fileutils_1 = require("../../../../utils/fileutils");
+const workspace_root_1 = require("../../../../utils/workspace-root");
+function buildNpmPackageNodes(builder) {
+    const packageJsonPath = (0, path_1.join)(workspace_root_1.workspaceRoot, 'package.json');
+    const packageJson = (0, fs_1.existsSync)(packageJsonPath)
+        ? (0, fileutils_1.readJsonFile)(packageJsonPath)
+        : {};
+    const deps = {
+        ...packageJson.dependencies,
+        ...packageJson.devDependencies,
+    };
+    Object.keys(deps).forEach((d) => {
+        if (!builder.graph.externalNodes[`npm:${d}`]) {
+            builder.addExternalNode({
+                type: 'npm',
+                name: `npm:${d}`,
+                data: {
+                    version: deps[d],
+                    packageName: d,
+                    hash: (0, file_hasher_1.hashArray)([d, deps[d]]),
+                },
+            });
+        }
+    });
+}
+exports.buildNpmPackageNodes = buildNpmPackageNodes;

package/src/plugins/js/utils/config.d.ts

@@ -0,0 +1,2 @@
+import { NrwlJsPluginConfig, NxJsonConfiguration } from '../../../config/nx-json';
+export declare function jsPluginConfig(nxJson: NxJsonConfiguration): Required<NrwlJsPluginConfig>;

package/src/plugins/js/utils/config.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jsPluginConfig = void 0;
+const node_path_1 = require("node:path");
+const fileutils_1 = require("../../../utils/fileutils");
+const workspace_root_1 = require("../../../utils/workspace-root");
+const fs_1 = require("fs");
+function jsPluginConfig(nxJson) {
+    const nxJsonConfig = nxJson?.pluginsConfig?.['@nx/js'] ?? nxJson?.pluginsConfig?.['@nrwl/js'];
+    // using lerna _before_ installing deps is causing an issue when parsing lockfile.
+    // See: https://github.com/lerna/lerna/issues/3807
+    // Note that previous attempt to fix this caused issues with Nx itself, thus we're checking
+    // for Lerna explicitly.
+    // See: https://github.com/nrwl/nx/pull/18784/commits/5416138e1ddc1945d5b289672dfb468e8c544e14
+    const analyzeLockfile = !(0, fs_1.existsSync)((0, node_path_1.join)(workspace_root_1.workspaceRoot, 'lerna.json')) ||
+        (0, fs_1.existsSync)((0, node_path_1.join)(workspace_root_1.workspaceRoot, 'nx.json'));
+    if (nxJsonConfig) {
+        return {
+            analyzePackageJson: true,
+            analyzeSourceFiles: true,
+            analyzeLockfile,
+            ...nxJsonConfig,
+        };
+    }
+    if (!(0, fileutils_1.fileExists)((0, node_path_1.join)(workspace_root_1.workspaceRoot, 'package.json'))) {
+        return {
+            analyzeLockfile: false,
+            analyzePackageJson: false,
+            analyzeSourceFiles: false,
+        };
+    }
+    const packageJson = (0, fileutils_1.readJsonFile)((0, node_path_1.join)(workspace_root_1.workspaceRoot, 'package.json'));
+    const packageJsonDeps = {
+        ...packageJson.dependencies,
+        ...packageJson.devDependencies,
+    };
+    if (packageJsonDeps['@nx/workspace'] ||
+        packageJsonDeps['@nx/js'] ||
+        packageJsonDeps['@nx/node'] ||
+        packageJsonDeps['@nx/next'] ||
+        packageJsonDeps['@nx/react'] ||
+        packageJsonDeps['@nx/angular'] ||
+        packageJsonDeps['@nx/web'] ||
+        packageJsonDeps['@nrwl/workspace'] ||
+        packageJsonDeps['@nrwl/js'] ||
+        packageJsonDeps['@nrwl/node'] ||
+        packageJsonDeps['@nrwl/next'] ||
+        packageJsonDeps['@nrwl/react'] ||
+        packageJsonDeps['@nrwl/angular'] ||
+        packageJsonDeps['@nrwl/web']) {
+        return {
+            analyzePackageJson: true,
+            analyzeLockfile,
+            analyzeSourceFiles: true,
+        };
+    }
+    else {
+        return {
+            analyzePackageJson: true,
+            analyzeLockfile,
+            analyzeSourceFiles: false,
+        };
+    }
+}
+exports.jsPluginConfig = jsPluginConfig;

package/src/plugins/js/utils/register.d.ts

@@ -0,0 +1,151 @@
+import type { CompilerOptions } from 'typescript';
+/**
+ * Optionally, if swc-node and tsconfig-paths are available in the current workspace, apply the require
+ * register hooks so that .ts files can be used for writing custom workspace projects.
+ *
+ * If ts-node and tsconfig-paths are not available, the user can still provide an index.js file in
+ * the root of their project and the fundamentals will still work (but
+ * workspace path mapping will not, for example).
+ *
+ * @returns cleanup function
+ */
+export declare function registerTsProject(tsConfigPath: string): () => void;
+/**
+ * Optionally, if swc-node and tsconfig-paths are available in the current workspace, apply the require
+ * register hooks so that .ts files can be used for writing custom workspace projects.
+ *
+ * If ts-node and tsconfig-paths are not available, the user can still provide an index.js file in
+ * the root of their project and the fundamentals will still work (but
+ * workspace path mapping will not, for example).
+ *
+ * @returns cleanup function
+ * @deprecated This signature will be removed in Nx v19. You should pass the full path to the tsconfig in the first argument.
+ */
+export declare function registerTsProject(path: string, configFilename: string): any;
+export declare function getSwcTranspiler(compilerOptions: CompilerOptions): (...args: unknown[]) => unknown;
+export declare function getTsNodeTranspiler(compilerOptions: CompilerOptions): (...args: unknown[]) => unknown;
+export declare function getTranspiler(compilerOptions: CompilerOptions): () => (...args: unknown[]) => unknown;
+/**
+ * Register ts-node or swc-node given a set of compiler options.
+ *
+ * Note: Several options require enums from typescript. To avoid importing typescript,
+ * use import type + raw values
+ *
+ * @returns cleanup method
+ */
+export declare function registerTranspiler(compilerOptions: CompilerOptions): () => void;
+/**
+ * @param tsConfigPath Adds the paths from a tsconfig file into node resolutions
+ * @returns cleanup function
+ */
+export declare function registerTsConfigPaths(tsConfigPath: any): () => void;
+/**
+ * ts-node requires string values for enum based typescript options.
+ * `register`'s signature just types the field as `object`, so we
+ * unfortunately do not get any kind of type safety on this.
+ */
+export declare function getTsNodeCompilerOptions(compilerOptions: CompilerOptions): {
+    [x: string]: any;
+    allowImportingTsExtensions?: any;
+    allowJs?: any;
+    allowArbitraryExtensions?: any;
+    allowSyntheticDefaultImports?: any;
+    allowUmdGlobalAccess?: any;
+    allowUnreachableCode?: any;
+    allowUnusedLabels?: any;
+    alwaysStrict?: any;
+    baseUrl?: any;
+    charset?: any;
+    checkJs?: any;
+    customConditions?: any;
+    declaration?: any;
+    declarationMap?: any;
+    emitDeclarationOnly?: any;
+    declarationDir?: any;
+    disableSizeLimit?: any;
+    disableSourceOfProjectReferenceRedirect?: any;
+    disableSolutionSearching?: any;
+    disableReferencedProjectLoad?: any;
+    downlevelIteration?: any;
+    emitBOM?: any;
+    emitDecoratorMetadata?: any;
+    exactOptionalPropertyTypes?: any;
+    experimentalDecorators?: any;
+    forceConsistentCasingInFileNames?: any;
+    ignoreDeprecations?: any;
+    importHelpers?: any;
+    importsNotUsedAsValues?: any;
+    inlineSourceMap?: any;
+    inlineSources?: any;
+    isolatedModules?: any;
+    jsx?: any;
+    keyofStringsOnly?: any;
+    lib?: any;
+    locale?: any;
+    mapRoot?: any;
+    maxNodeModuleJsDepth?: any;
+    module?: any;
+    moduleResolution?: any;
+    moduleSuffixes?: any;
+    moduleDetection?: any;
+    newLine?: any;
+    noEmit?: any;
+    noEmitHelpers?: any;
+    noEmitOnError?: any;
+    noErrorTruncation?: any;
+    noFallthroughCasesInSwitch?: any;
+    noImplicitAny?: any;
+    noImplicitReturns?: any;
+    noImplicitThis?: any;
+    noStrictGenericChecks?: any;
+    noUnusedLocals?: any;
+    noUnusedParameters?: any;
+    noImplicitUseStrict?: any;
+    noPropertyAccessFromIndexSignature?: any;
+    assumeChangesOnlyAffectDirectDependencies?: any;
+    noLib?: any;
+    noResolve?: any;
+    noUncheckedIndexedAccess?: any;
+    out?: any;
+    outDir?: any;
+    outFile?: any;
+    paths?: any;
+    preserveConstEnums?: any;
+    noImplicitOverride?: any;
+    preserveSymlinks?: any;
+    preserveValueImports?: any;
+    project?: any;
+    reactNamespace?: any;
+    jsxFactory?: any;
+    jsxFragmentFactory?: any;
+    jsxImportSource?: any;
+    composite?: any;
+    incremental?: any;
+    tsBuildInfoFile?: any;
+    removeComments?: any;
+    resolvePackageJsonExports?: any;
+    resolvePackageJsonImports?: any;
+    rootDir?: any;
+    rootDirs?: any;
+    skipLibCheck?: any;
+    skipDefaultLibCheck?: any;
+    sourceMap?: any;
+    sourceRoot?: any;
+    strict?: any;
+    strictFunctionTypes?: any;
+    strictBindCallApply?: any;
+    strictNullChecks?: any;
+    strictPropertyInitialization?: any;
+    stripInternal?: any;
+    suppressExcessPropertyErrors?: any;
+    suppressImplicitAnyIndexErrors?: any;
+    target?: any;
+    traceResolution?: any;
+    useUnknownInCatchVariables?: any;
+    resolveJsonModule?: any;
+    types?: any;
+    typeRoots?: any;
+    verbatimModuleSyntax?: any;
+    esModuleInterop?: any;
+    useDefineForClassFields?: any;
+};