fix(js): do not depend on nx for typescript utils (#16642)

packages/devkit/src/utils/module-federation/share.ts

@@ -6,13 +6,11 @@ import type {
 import { AdditionalSharedConfig, SharedFunction } from './models';
 import { dirname, join, normalize } from 'path';
 import { readRootPackageJson } from './package-json';
-import { readTsPathMappings } from './typescript';
+import { readTsPathMappings, getRootTsConfigPath } from './typescript';
 import {
  collectPackageSecondaryEntryPoints,
  collectWorkspaceLibrarySecondaryEntryPoints,
 } from './secondary-entry-points';
-// eslint-disable-next-line @typescript-eslint/no-restricted-imports
-import { getRootTsConfigPath } from 'nx/src/plugins/js/utils/typescript';
 import type { ProjectGraph } from 'nx/src/config/project-graph';
 import { requireNx } from '../../../nx';
 

packages/devkit/src/utils/module-federation/typescript.ts

@@ -1,8 +1,9 @@
 import { existsSync } from 'fs';
 import { ParsedCommandLine } from 'typescript';
-// eslint-disable-next-line @typescript-eslint/no-restricted-imports
-import { getRootTsConfigPath } from 'nx/src/plugins/js/utils/typescript';
-import { dirname } from 'path';
+import { dirname, join } from 'path';
+import { requireNx } from '../../../nx';
+
+const { workspaceRoot } = requireNx();
 
 let tsConfig: ParsedCommandLine;
 let tsPathMappings: ParsedCommandLine['options']['paths'];
@@ -48,3 +49,20 @@ export function readTsConfig(tsConfigPath: string): ParsedCommandLine {
  dirname(tsConfigPath)
  );
 }
+
+export function getRootTsConfigPath(): string | null {
+ const tsConfigFileName = getRootTsConfigFileName();
+
+ return tsConfigFileName ? join(workspaceRoot, tsConfigFileName) : null;
+}
+
+function getRootTsConfigFileName(): string | null {
+ for (const tsConfigName of ['tsconfig.base.json', 'tsconfig.json']) {
+ const tsConfigPath = join(workspaceRoot, tsConfigName);
+ if (existsSync(tsConfigPath)) {
+ return tsConfigName;
+ }
+ }
+
+ return null;
+}

packages/js/src/index.ts

@@ -19,8 +19,3 @@ export {
 } from 'nx/src/plugins/js/lock-file/lock-file';
 // eslint-disable-next-line @typescript-eslint/no-restricted-imports
 export { createPackageJson } from 'nx/src/plugins/js/package-json/create-package-json';
-// eslint-disable-next-line @typescript-eslint/no-restricted-imports
-export {
- findNodes,
- getRootTsConfigPath,
-} from 'nx/src/plugins/js/utils/typescript';

packages/js/src/internal.ts

@@ -1,5 +1,4 @@
-// eslint-disable-next-line @typescript-eslint/no-restricted-imports
-export { resolveModuleByImport } from 'nx/src/plugins/js/utils/typescript';
+export { resolveModuleByImport } from './utils/typescript/ast-utils';
 // eslint-disable-next-line @typescript-eslint/no-restricted-imports
 export {
  registerTsProject,

packages/js/src/utils/typescript/ast-utils.ts

@@ -2,12 +2,85 @@ import type { Tree } from '@nx/devkit';
 import type * as ts from 'typescript';
 // TODO(colum): replace when https:/nrwl/nx/pull/15497 is merged
 import { getSourceNodes } from '@nx/workspace/src/utilities/typescript';
-// eslint-disable-next-line @typescript-eslint/no-restricted-imports
-import { findNodes } from 'nx/src/plugins/js/utils/typescript';
 import { ensureTypescript } from './ensure-typescript';
+import { Node, SyntaxKind } from 'typescript';
+import { workspaceRoot } from '@nx/devkit';
+import { dirname } from 'path';
+
+const normalizedAppRoot = workspaceRoot.replace(/\\/g, '/');
 
 let tsModule: typeof import('typescript');
 
+let compilerHost: {
+ host: ts.CompilerHost;
+ options: ts.CompilerOptions;
+ moduleResolutionCache: ts.ModuleResolutionCache;
+};
+
+/**
+ * Find a module based on its import
+ *
+ * @param importExpr Import used to resolve to a module
+ * @param filePath
+ * @param tsConfigPath
+ */
+export function resolveModuleByImport(
+ importExpr: string,
+ filePath: string,
+ tsConfigPath: string
+) {
+ compilerHost = compilerHost || getCompilerHost(tsConfigPath);
+ const { options, host, moduleResolutionCache } = compilerHost;
+
+ const { resolvedModule } = tsModule.resolveModuleName(
+ importExpr,
+ filePath,
+ options,
+ host,
+ moduleResolutionCache
+ );
+
+ if (!resolvedModule) {
+ return;
+ } else {
+ return resolvedModule.resolvedFileName.replace(`${normalizedAppRoot}/`, '');
+ }
+}
+
+function getCompilerHost(tsConfigPath: string) {
+ const options = readTsConfigOptions(tsConfigPath);
+ const host = tsModule.createCompilerHost(options, true);
+ const moduleResolutionCache = tsModule.createModuleResolutionCache(
+ workspaceRoot,
+ host.getCanonicalFileName
+ );
+ return { options, host, moduleResolutionCache };
+}
+
+function readTsConfigOptions(tsConfigPath: string) {
+ if (!tsModule) {
+ tsModule = require('typescript');
+ }
+
+ const readResult = tsModule.readConfigFile(
+ tsConfigPath,
+ tsModule.sys.readFile
+ );
+
+ // we don't need to scan the files, we only care about options
+ const host: Partial<ts.ParseConfigHost> = {
+ readDirectory: () => [],
+ readFile: () => '',
+ fileExists: tsModule.sys.fileExists,
+ };
+
+ return tsModule.parseJsonConfigFileContent(
+ readResult.config,
+ host as ts.ParseConfigHost,
+ dirname(tsConfigPath)
+ ).options;
+}
+
 function nodesByPosition(first: ts.Node, second: ts.Node): number {
  return first.getStart() - second.getStart();
 }
@@ -345,3 +418,38 @@ export function findClass(
 
  return clazz;
 }
+
+export function findNodes(
+ node: Node,
+ kind: SyntaxKind | SyntaxKind[],
+ max = Infinity
+): Node[] {
+ if (!node || max == 0) {
+ return [];
+ }
+
+ const arr: Node[] = [];
+ const hasMatch = Array.isArray(kind)
+ ? kind.includes(node.kind)
+ : node.kind === kind;
+ if (hasMatch) {
+ arr.push(node);
+ max--;
+ }
+ if (max > 0) {
+ for (const child of node.getChildren()) {
+ findNodes(child, kind, max).forEach((node) => {
+ if (max > 0) {
+ arr.push(node);
+ }
+ max--;
+ });
+
+ if (max <= 0) {
+ break;
+ }
+ }
+ }
+
+ return arr;
+}

packages/js/src/utils/typescript/ts-config.ts

@@ -1,10 +1,4 @@
-import {
- joinPathFragments,
- offsetFromRoot,
- Tree,
- updateJson,
- workspaceRoot,
-} from '@nx/devkit';
+import { offsetFromRoot, Tree, updateJson, workspaceRoot } from '@nx/devkit';
 import { existsSync } from 'fs';
 import { dirname, join } from 'path';
 
@@ -42,6 +36,12 @@ export function getRelativePathToRootTsConfig(
  return offsetFromRoot(targetPath) + getRootTsConfigPathInTree(tree);
 }
 
+export function getRootTsConfigPath(): string | null {
+ const tsConfigFileName = getRootTsConfigFileName();
+
+ return tsConfigFileName ? join(workspaceRoot, tsConfigFileName) : null;
+}
+
 export function getRootTsConfigFileName(tree?: Tree): string | null {
  for (const tsConfigName of ['tsconfig.base.json', 'tsconfig.json']) {
  const pathExists = tree