@nx/react 23.0.0-pr.35413.460eeef → 23.0.0-rc.0

package/dist/src/migrations/update-23-0-0/rewrite-internal-subpath-imports.js

@@ -0,0 +1,215 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = rewriteInternalSubpathImports;
+exports.rewriteSubpathImports = rewriteSubpathImports;
+const devkit_1 = require("@nx/devkit");
+const TS_EXTENSIONS = ['.ts', '.tsx', '.cts', '.mts'];
+const FROM_PREFIX = '@nx/react/src/';
+const TO_PUBLIC = '@nx/react';
+const TO_INTERNAL = '@nx/react/internal';
+// Symbols exported from `@nx/react`'s public entry (packages/react/index.ts).
+// A named import/export of one of these from `@nx/react/src/*` is routed to
+// the public `@nx/react` entry; everything else goes to `@nx/react/internal`.
+const PUBLIC_SYMBOLS = new Set([
+    'SupportedStyles',
+    'WithReactOptions',
+    'applicationGenerator',
+    'assertValidStyle',
+    'componentGenerator',
+    'componentStoryGenerator',
+    'componentTestGenerator',
+    'cypressComponentConfigGenerator',
+    'extendReactEslintJson',
+    'extraEslintDependencies',
+    'hookGenerator',
+    'hostGenerator',
+    'libraryGenerator',
+    'reactDomVersion',
+    'reactInitGenerator',
+    'reactVersion',
+    'reduxGenerator',
+    'remoteGenerator',
+    'storiesGenerator',
+    'storybookConfigurationGenerator',
+    'withReact',
+]);
+// Methods on `jest` and `vi` that take a module specifier as their first arg.
+const MOCK_HELPER_METHODS = new Set([
+    'mock',
+    'unmock',
+    'doMock',
+    'dontMock',
+    'requireActual',
+    'requireMock',
+    'importActual',
+    'importMock',
+]);
+let ts;
+async function rewriteInternalSubpathImports(tree) {
+    let touchedCount = 0;
+    (0, devkit_1.visitNotIgnoredFiles)(tree, '.', (filePath) => {
+        if (!TS_EXTENSIONS.some((ext) => filePath.endsWith(ext))) {
+            return;
+        }
+        const original = tree.read(filePath, 'utf-8');
+        if (!original || !original.includes(FROM_PREFIX)) {
+            return;
+        }
+        const updated = rewriteSubpathImports(original);
+        if (updated !== original) {
+            tree.write(filePath, updated);
+            touchedCount += 1;
+        }
+    });
+    if (touchedCount > 0) {
+        devkit_1.logger.info(`Rewrote @nx/react/src/* imports in ${touchedCount} file(s) ` +
+            `(public symbols to @nx/react, internals to @nx/react/internal).`);
+    }
+    await (0, devkit_1.formatFiles)(tree);
+}
+function rewriteSubpathImports(source) {
+    ts ??= (0, devkit_1.ensurePackage)('typescript', '*');
+    const sourceFile = ts.createSourceFile('tmp.ts', source, ts.ScriptTarget.Latest, 
+    /* setParentNodes */ true, ts.ScriptKind.TSX);
+    const changes = [];
+    for (const stmt of sourceFile.statements) {
+        if (ts.isImportDeclaration(stmt)) {
+            collectImportRewrite(sourceFile, stmt, changes);
+        }
+        else if (ts.isExportDeclaration(stmt)) {
+            collectExportRewrite(sourceFile, stmt, changes);
+        }
+    }
+    collectCallExpressionRewrites(sourceFile, changes);
+    return changes.length > 0 ? (0, devkit_1.applyChangesToString)(source, changes) : source;
+}
+function isSubpathSpecifier(node) {
+    return ts.isStringLiteral(node) && node.text.startsWith(FROM_PREFIX);
+}
+function collectImportRewrite(sourceFile, stmt, changes) {
+    if (!isSubpathSpecifier(stmt.moduleSpecifier)) {
+        return;
+    }
+    const clause = stmt.importClause;
+    // Pure named imports (`import { a, b } from '...'`) can be split by symbol.
+    // A default or namespace import grabs the whole module, so it can't be
+    // split — route it wholesale to the internal entry.
+    if (clause &&
+        !clause.name &&
+        clause.namedBindings &&
+        ts.isNamedImports(clause.namedBindings)) {
+        rewriteNamedDeclaration(sourceFile, stmt, stmt.moduleSpecifier, clause.isTypeOnly, clause.namedBindings.elements, 'import', changes);
+        return;
+    }
+    replaceSpecifier(sourceFile, stmt.moduleSpecifier, TO_INTERNAL, changes);
+}
+function collectExportRewrite(sourceFile, stmt, changes) {
+    if (!stmt.moduleSpecifier || !isSubpathSpecifier(stmt.moduleSpecifier)) {
+        return;
+    }
+    // `export { a, b } from '...'` can be split; `export * from '...'` cannot.
+    if (stmt.exportClause && ts.isNamedExports(stmt.exportClause)) {
+        rewriteNamedDeclaration(sourceFile, stmt, stmt.moduleSpecifier, stmt.isTypeOnly, stmt.exportClause.elements, 'export', changes);
+        return;
+    }
+    replaceSpecifier(sourceFile, stmt.moduleSpecifier, TO_INTERNAL, changes);
+}
+/**
+ * Partition the named bindings of an import/export declaration into the ones
+ * that resolve to `@nx/react`'s public entry and the ones that don't. If both
+ * groups are non-empty, the single declaration is split into two.
+ */
+function rewriteNamedDeclaration(sourceFile, decl, specifier, isTypeOnly, elements, keyword, changes) {
+    const publicEls = [];
+    const internalEls = [];
+    for (const el of elements) {
+        // `propertyName` is the original name in `orig as alias`; fall back to
+        // `name` for the plain `orig` form.
+        const importedName = (el.propertyName ?? el.name).text;
+        (PUBLIC_SYMBOLS.has(importedName) ? publicEls : internalEls).push(el);
+    }
+    if (publicEls.length === 0) {
+        replaceSpecifier(sourceFile, specifier, TO_INTERNAL, changes);
+        return;
+    }
+    if (internalEls.length === 0) {
+        replaceSpecifier(sourceFile, specifier, TO_PUBLIC, changes);
+        return;
+    }
+    // Mixed — replace the whole declaration with one statement per target.
+    const quote = sourceFile.text.charAt(specifier.getStart(sourceFile));
+    const start = decl.getStart(sourceFile);
+    const end = decl.getEnd();
+    const semicolon = sourceFile.text.charAt(end - 1) === ';' ? ';' : '';
+    const prefix = isTypeOnly ? `${keyword} type` : keyword;
+    const render = (els, target) => `${prefix} { ${els
+        .map((el) => el.getText(sourceFile))
+        .join(', ')} } from ${quote}${target}${quote}${semicolon}`;
+    changes.push({ type: devkit_1.ChangeType.Delete, start, length: end - start }, {
+        type: devkit_1.ChangeType.Insert,
+        index: start,
+        text: `${render(publicEls, TO_PUBLIC)}\n${render(internalEls, TO_INTERNAL)}`,
+    });
+}
+function collectCallExpressionRewrites(sourceFile, changes) {
+    const visit = (node) => {
+        if (ts.isCallExpression(node) &&
+            shouldRewriteCallExpression(node) &&
+            node.arguments.length >= 1 &&
+            isSubpathSpecifier(node.arguments[0])) {
+            // `require(...)`, dynamic `import(...)` and `jest.mock(...)` reference
+            // the module as a whole and can't be symbol-split, so they go to the
+            // internal entry.
+            replaceSpecifier(sourceFile, node.arguments[0], TO_INTERNAL, changes);
+        }
+        else if (ts.isImportTypeNode(node)) {
+            // `typeof import('...')` parses as an `ImportTypeNode`, not a
+            // CallExpression — its argument is `LiteralTypeNode<StringLiteral>`.
+            // The whole module is referenced, so it can't be symbol-split.
+            const literal = getImportTypeStringLiteral(node);
+            if (literal && literal.text.startsWith(FROM_PREFIX)) {
+                replaceSpecifier(sourceFile, literal, TO_INTERNAL, changes);
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+}
+function getImportTypeStringLiteral(node) {
+    const arg = node.argument;
+    if (arg && ts.isLiteralTypeNode(arg) && ts.isStringLiteral(arg.literal)) {
+        return arg.literal;
+    }
+    return undefined;
+}
+function shouldRewriteCallExpression(call) {
+    const callee = call.expression;
+    // `require('...')`
+    if (ts.isIdentifier(callee) && callee.text === 'require')
+        return true;
+    // dynamic `import('...')` (runtime form parses as a CallExpression whose
+    // callee is the `import` keyword). The `typeof import('...')` type-position
+    // form is an `ImportTypeNode` (handled in `collectCallExpressionRewrites`).
+    if (callee.kind === ts.SyntaxKind.ImportKeyword)
+        return true;
+    // `jest.mock(...)` / `vi.mock(...)` and friends.
+    if (ts.isPropertyAccessExpression(callee)) {
+        const obj = callee.expression;
+        if (ts.isIdentifier(obj) &&
+            (obj.text === 'jest' || obj.text === 'vi') &&
+            MOCK_HELPER_METHODS.has(callee.name.text)) {
+            return true;
+        }
+    }
+    return false;
+}
+function replaceSpecifier(sourceFile, literal, target, changes) {
+    const start = literal.getStart(sourceFile);
+    const end = literal.getEnd();
+    const quote = sourceFile.text.charAt(start);
+    changes.push({ type: devkit_1.ChangeType.Delete, start, length: end - start }, {
+        type: devkit_1.ChangeType.Insert,
+        index: start,
+        text: `${quote}${target}${quote}`,
+    });
+}

package/{src → dist/src}/module-federation/ast-utils.d.ts

@@ -6,4 +6,3 @@ export declare function addRemoteRoute(source: ts.SourceFile, names: {
     fileName: string;
     className: string;
 }): StringChange[];
-//# sourceMappingURL=ast-utils.d.ts.map

package/{src → dist/src}/module-federation/ast-utils.js

@@ -6,11 +6,11 @@ exports.addRemoteRoute = addRemoteRoute;
 const devkit_1 = require("@nx/devkit");
 const js_1 = require("@nx/js");
 const ast_utils_1 = require("../utils/ast-utils");
-const ensure_typescript_1 = require("@nx/js/src/utils/typescript/ensure-typescript");
+const internal_1 = require("@nx/js/internal");
 let tsModule;
 function addRemoteToConfig(source, app) {
     if (!tsModule) {
-        tsModule = (0, ensure_typescript_1.ensureTypescript)();
+        tsModule = (0, internal_1.ensureTypescript)();
     }
     const assignments = (0, js_1.findNodes)(source, tsModule.SyntaxKind.PropertyAssignment);
     const remotesAssignment = assignments.find((s) => s.name.getText() === 'remotes');

package/dist/src/plugins/router-plugin.d.ts

@@ -0,0 +1,14 @@
+import { type CreateNodes } from '@nx/devkit';
+export interface ReactRouterPluginOptions {
+    buildTargetName?: string;
+    devTargetName?: string;
+    startTargetName?: string;
+    typecheckTargetName?: string;
+    buildDepsTargetName?: string;
+    watchDepsTargetName?: string;
+}
+export declare const createNodes: CreateNodes<ReactRouterPluginOptions>;
+/**
+ * @deprecated Use {@link createNodes} instead. This will be removed in Nx 24.
+ */
+export declare const createNodesV2: CreateNodes<ReactRouterPluginOptions>;

package/{src → dist/src}/plugins/router-plugin.js

@@ -1,35 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createNodesV2 = void 0;
+exports.createNodesV2 = exports.createNodes = void 0;
+const internal_1 = require("@nx/devkit/internal");
 const devkit_1 = require("@nx/devkit");
 const path_1 = require("path");
 const fs_1 = require("fs");
-const get_named_inputs_1 = require("@nx/devkit/src/utils/get-named-inputs");
 const cache_directory_1 = require("nx/src/utils/cache-directory");
-const calculate_hash_for_create_nodes_1 = require("@nx/devkit/src/utils/calculate-hash-for-create-nodes");
 const js_1 = require("@nx/js");
 const devkit_internals_1 = require("nx/src/devkit-internals");
-const util_1 = require("@nx/js/src/plugins/typescript/util");
-const ts_solution_setup_1 = require("@nx/js/src/utils/typescript/ts-solution-setup");
-const config_utils_1 = require("@nx/devkit/src/utils/config-utils");
+const internal_2 = require("@nx/js/internal");
 const pmCommand = (0, devkit_1.getPackageManagerCommand)();
 const reactRouterConfigBlob = '**/react-router.config.{ts,js,cjs,cts,mjs,mts}';
-function readTargetsCache(cachePath) {
-    return process.env.NX_CACHE_PROJECT_GRAPH !== 'false' && (0, fs_1.existsSync)(cachePath)
-        ? (0, devkit_1.readJsonFile)(cachePath)
-        : {};
-}
-function writeTargetsToCache(cachePath, results) {
-    (0, devkit_1.writeJsonFile)(cachePath, results);
-}
-exports.createNodesV2 = [
+exports.createNodes = [
     reactRouterConfigBlob,
     async (configFiles, options, context) => {
         const optionsHash = (0, devkit_internals_1.hashObject)(options);
         const normalizedOptions = normalizeOptions(options);
         const cachePath = (0, path_1.join)(cache_directory_1.workspaceDataDirectory, `react-router-${optionsHash}.hash`);
-        const targetsCache = readTargetsCache(cachePath);
-        const isUsingTsSolutionSetup = (0, ts_solution_setup_1.isUsingTsSolutionSetup)();
+        const targetsCache = new internal_1.PluginCache(cachePath);
+        const isUsingTsSolutionSetup = (0, internal_2.isUsingTsSolutionSetup)();
         const { roots: projectRoots, configFiles: validConfigFiles } = configFiles.reduce((acc, configFile) => {
             const potentialRoot = (0, path_1.dirname)(configFile);
             if (checkIfConfigFileShouldBeProject(potentialRoot, context)) {
@@ -42,14 +31,16 @@ exports.createNodesV2 = [
             configFiles: [],
         });
         const lockfile = (0, js_1.getLockFileName)((0, devkit_1.detectPackageManager)(context.workspaceRoot));
-        const hashes = await (0, calculate_hash_for_create_nodes_1.calculateHashesForCreateNodes)(projectRoots, { ...normalizedOptions, isUsingTsSolutionSetup }, context, projectRoots.map((_) => [lockfile]));
+        const hashes = await (0, internal_1.calculateHashesForCreateNodes)(projectRoots, { ...normalizedOptions, isUsingTsSolutionSetup }, context, projectRoots.map((_) => [lockfile]));
         try {
             return await (0, devkit_1.createNodesFromFiles)(async (configFile, _, context, idx) => {
                 const projectRoot = (0, path_1.dirname)(configFile);
                 const siblingFiles = (0, fs_1.readdirSync)((0, devkit_1.joinPathFragments)(context.workspaceRoot, projectRoot));
                 const hash = hashes[idx] + configFile;
-                const { projectType, metadata, targets } = (targetsCache[hash] ??=
-                    await buildReactRouterTargets(configFile, projectRoot, normalizedOptions, context, siblingFiles, isUsingTsSolutionSetup));
+                if (!targetsCache.has(hash)) {
+                    targetsCache.set(hash, await buildReactRouterTargets(configFile, projectRoot, normalizedOptions, context, siblingFiles, isUsingTsSolutionSetup));
+                }
+                const { projectType, metadata, targets } = targetsCache.get(hash);
                 const project = {
                     root: projectRoot,
                     targets,
@@ -66,16 +57,20 @@ exports.createNodesV2 = [
             }, validConfigFiles, options, context);
         }
         finally {
-            writeTargetsToCache(cachePath, targetsCache);
+            targetsCache.writeToDisk();
         }
     },
 ];
+/**
+ * @deprecated Use {@link createNodes} instead. This will be removed in Nx 24.
+ */
+exports.createNodesV2 = exports.createNodes;
 async function buildReactRouterTargets(configFilePath, projectRoot, options, context, siblingFiles, isUsingTsSolutionSetup) {
-    const namedInputs = (0, get_named_inputs_1.getNamedInputs)(projectRoot, context);
+    const namedInputs = (0, internal_1.getNamedInputs)(projectRoot, context);
     const configPath = (0, path_1.join)(context.workspaceRoot, configFilePath);
     if (require.cache[configPath])
-        (0, config_utils_1.clearRequireCache)();
-    const reactRouterConfig = await (0, config_utils_1.loadConfigFile)(configPath);
+        (0, internal_1.clearRequireCache)();
+    const reactRouterConfig = await (0, internal_1.loadConfigFile)(configPath);
     const isLibMode = reactRouterConfig?.ssr !== undefined && reactRouterConfig.ssr === false;
     const { buildDirectory, serverBuildPath } = await getBuildPaths(reactRouterConfig, isLibMode);
     const targets = {};
@@ -85,7 +80,7 @@ async function buildReactRouterTargets(configFilePath, projectRoot, options, con
         targets[options.startTargetName] = await startTarget(projectRoot, serverBuildPath, options.buildTargetName, isUsingTsSolutionSetup);
     }
     targets[options.typecheckTargetName] = await typecheckTarget(projectRoot, options.typecheckTargetName, namedInputs, siblingFiles, isUsingTsSolutionSetup);
-    (0, util_1.addBuildAndWatchDepsTargets)(context.workspaceRoot, projectRoot, targets, options, pmCommand);
+    (0, internal_2.addBuildAndWatchDepsTargets)(context.workspaceRoot, projectRoot, targets, options, pmCommand);
     const metadata = {};
     return {
         targets,

package/{src → dist/src}/rules/update-module-federation-project.d.ts

@@ -9,4 +9,3 @@ export declare function updateModuleFederationProject(host: Tree, options: {
     bundler?: 'rspack' | 'webpack';
     ssr?: boolean;
 }, isHost?: boolean): void;
-//# sourceMappingURL=update-module-federation-project.d.ts.map

package/{src → dist/src}/rules/update-module-federation-project.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.updateModuleFederationProject = updateModuleFederationProject;
 const devkit_1 = require("@nx/devkit");
 const maybe_js_1 = require("../utils/maybe-js");
-const ts_solution_setup_1 = require("@nx/js/src/utils/typescript/ts-solution-setup");
+const internal_1 = require("@nx/js/internal");
 function updateModuleFederationProject(host, options, isHost = false) {
     const projectConfig = (0, devkit_1.readProjectConfiguration)(host, options.projectName);
     projectConfig.targets ??= {};
@@ -14,7 +14,7 @@ function updateModuleFederationProject(host, options, isHost = false) {
             webpackConfig: `${options.appProjectRoot}/webpack.config.${options.typescriptConfiguration && !options.js ? 'ts' : 'js'}`,
         };
         projectConfig.targets.build.configurations ??= {};
-        if (!(0, ts_solution_setup_1.isUsingTsSolutionSetup)(host)) {
+        if (!(0, internal_1.isUsingTsSolutionSetup)(host)) {
             projectConfig.targets.build.configurations.production = {
                 ...(projectConfig.targets.build.configurations?.production ?? {}),
                 webpackConfig: `${options.appProjectRoot}/webpack.config.prod.${options.typescriptConfiguration && !options.js ? 'ts' : 'js'}`,
@@ -62,7 +62,7 @@ function updateModuleFederationProject(host, options, isHost = false) {
         };
     }
     // Typechecks must be performed first before build and serve to generate remote d.ts files.
-    if ((0, ts_solution_setup_1.isUsingTsSolutionSetup)(host)) {
+    if ((0, internal_1.isUsingTsSolutionSetup)(host)) {
         projectConfig.targets.build ??= {};
         projectConfig.targets.serve ??= {};
         projectConfig.targets.build.dependsOn = ['^build', 'typecheck'];

package/{src → dist/src}/utils/add-mf-env-to-inputs.d.ts

@@ -1,3 +1,2 @@
 import { type Tree } from '@nx/devkit';
 export declare function addMfEnvToTargetDefaultInputs(tree: Tree, bundler: 'rspack' | 'webpack'): void;
-//# sourceMappingURL=add-mf-env-to-inputs.d.ts.map

package/dist/src/utils/add-mf-env-to-inputs.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addMfEnvToTargetDefaultInputs = addMfEnvToTargetDefaultInputs;
+const devkit_1 = require("@nx/devkit");
+const internal_1 = require("@nx/devkit/internal");
+function addMfEnvToTargetDefaultInputs(tree, bundler) {
+    const nxJson = (0, devkit_1.readNxJson)(tree) ?? {};
+    const executor = bundler === 'rspack' ? '@nx/rspack:rspack' : '@nx/webpack:webpack';
+    const mfEnvVar = 'NX_MF_DEV_REMOTES';
+    const existing = (0, internal_1.normalizeTargetDefaults)(nxJson.targetDefaults).find((e) => e.executor === executor &&
+        e.target === undefined &&
+        e.projects === undefined &&
+        e.plugin === undefined);
+    const inputs = [...(existing?.inputs ?? ['production', '^production'])];
+    let mfEnvVarExists = false;
+    for (const input of inputs) {
+        if (typeof input === 'object' && input['env'] === mfEnvVar) {
+            mfEnvVarExists = true;
+            break;
+        }
+    }
+    if (!mfEnvVarExists) {
+        inputs.push({ env: mfEnvVar });
+    }
+    (0, internal_1.upsertTargetDefault)(tree, nxJson, {
+        executor,
+        cache: true,
+        inputs,
+        dependsOn: existing?.dependsOn ?? ['^build'],
+    });
+    (0, devkit_1.updateNxJson)(tree, nxJson);
+}

package/dist/src/utils/assert-supported-react-version.d.ts

@@ -0,0 +1,2 @@
+import { type Tree } from '@nx/devkit';
+export declare function assertSupportedReactVersion(tree: Tree): void;

package/dist/src/utils/assert-supported-react-version.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertSupportedReactVersion = assertSupportedReactVersion;
+const internal_1 = require("@nx/devkit/internal");
+const versions_1 = require("./versions");
+function assertSupportedReactVersion(tree) {
+    (0, internal_1.assertSupportedPackageVersion)(tree, 'react', versions_1.minSupportedReactVersion);
+}

package/{src → dist/src}/utils/assertion.d.ts

@@ -1,4 +1,3 @@
 import { type Schema } from '../generators/application/schema';
 export declare function assertValidStyle(style: string): void;
 export declare function assertValidReactRouter(reactRouter: boolean, bundler: Schema['bundler']): void;
-//# sourceMappingURL=assertion.d.ts.map

package/{src → dist/src}/utils/assertion.js

@@ -2,16 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.assertValidStyle = assertValidStyle;
 exports.assertValidReactRouter = assertValidReactRouter;
-const VALID_STYLES = [
-    'css',
-    'scss',
-    'less',
-    'tailwind',
-    'styled-components',
-    '@emotion/styled',
-    'styled-jsx',
-    'none',
-];
+const VALID_STYLES = ['css', 'scss', 'none'];
 function assertValidStyle(style) {
     if (VALID_STYLES.indexOf(style) === -1) {
         throw new Error(`Unsupported style option found: ${style}. Valid values are: "${VALID_STYLES.join('", "')}"`);

package/{src → dist/src}/utils/ast-utils.d.ts

@@ -31,4 +31,3 @@ export declare function parseComponentPropsInfo(sourceFile: ts.SourceFile, cmpDe
     propsTypeName: string | null;
     inlineTypeString: string | null;
 } | null;
-//# sourceMappingURL=ast-utils.d.ts.map

package/{src → dist/src}/utils/ast-utils.js

@@ -21,11 +21,11 @@ exports.getComponentNode = getComponentNode;
 exports.parseComponentPropsInfo = parseComponentPropsInfo;
 const js_1 = require("@nx/js");
 const devkit_1 = require("@nx/devkit");
-const ensure_typescript_1 = require("@nx/js/src/utils/typescript/ensure-typescript");
+const internal_1 = require("@nx/js/internal");
 let tsModule;
 function addImport(source, statement) {
     if (!tsModule) {
-        tsModule = (0, ensure_typescript_1.ensureTypescript)();
+        tsModule = (0, internal_1.ensureTypescript)();
     }
     const allImports = (0, js_1.findNodes)(source, tsModule.SyntaxKind.ImportDeclaration);
     if (allImports.length > 0) {
@@ -50,7 +50,7 @@ function addImport(source, statement) {
 }
 function findMainRenderStatement(source) {
     if (!tsModule) {
-        tsModule = (0, ensure_typescript_1.ensureTypescript)();
+        tsModule = (0, internal_1.ensureTypescript)();
     }
     // 1. Try to find ReactDOM.render.
     const calls = (0, js_1.findNodes)(source, tsModule.SyntaxKind.CallExpression);
@@ -88,7 +88,7 @@ function findDefaultExport(source) {
 }
 function findDefaultExportDeclaration(source) {
     if (!tsModule) {
-        tsModule = (0, ensure_typescript_1.ensureTypescript)();
+        tsModule = (0, internal_1.ensureTypescript)();
     }
     const identifier = findDefaultExportIdentifier(source);
     if (identifier) {
@@ -107,7 +107,7 @@ function findDefaultExportDeclaration(source) {
 }
 function findExportDeclarationsForJsx(source) {
     if (!tsModule) {
-        tsModule = (0, ensure_typescript_1.ensureTypescript)();
+        tsModule = (0, internal_1.ensureTypescript)();
     }
     const variables = (0, js_1.findNodes)(source, tsModule.SyntaxKind.VariableDeclaration);
     const variableStatements = (0, js_1.findNodes)(source, tsModule.SyntaxKind.VariableStatement);
@@ -157,7 +157,7 @@ function findExportDeclarationsForJsx(source) {
 }
 function findDefaultExportIdentifier(source) {
     if (!tsModule) {
-        tsModule = (0, ensure_typescript_1.ensureTypescript)();
+        tsModule = (0, internal_1.ensureTypescript)();
     }
     const exports = (0, js_1.findNodes)(source, tsModule.SyntaxKind.ExportAssignment);
     const identifier = exports
@@ -167,7 +167,7 @@ function findDefaultExportIdentifier(source) {
 }
 function findDefaultClassOrFunction(source) {
     if (!tsModule) {
-        tsModule = (0, ensure_typescript_1.ensureTypescript)();
+        tsModule = (0, internal_1.ensureTypescript)();
     }
     const fns = (0, js_1.findNodes)(source, tsModule.SyntaxKind.FunctionDeclaration);
     const cls = (0, js_1.findNodes)(source, tsModule.SyntaxKind.ClassDeclaration);
@@ -177,7 +177,7 @@ function findDefaultClassOrFunction(source) {
 }
 function hasDefaultExportModifier(x) {
     if (!tsModule) {
-        tsModule = (0, ensure_typescript_1.ensureTypescript)();
+        tsModule = (0, internal_1.ensureTypescript)();
     }
     return (x.modifiers &&
         x.modifiers.some((m) => m.kind === tsModule.SyntaxKind.ExportKeyword) &&
@@ -185,7 +185,7 @@ function hasDefaultExportModifier(x) {
 }
 function findComponentImportPath(componentName, source) {
     if (!tsModule) {
-        tsModule = (0, ensure_typescript_1.ensureTypescript)();
+        tsModule = (0, internal_1.ensureTypescript)();
     }
     const allImports = (0, js_1.findNodes)(source, tsModule.SyntaxKind.ImportDeclaration);
     const matching = allImports.filter((i) => {
@@ -201,7 +201,7 @@ function findComponentImportPath(componentName, source) {
 }
 function findElements(source, tagName) {
     if (!tsModule) {
-        tsModule = (0, ensure_typescript_1.ensureTypescript)();
+        tsModule = (0, internal_1.ensureTypescript)();
     }
     const nodes = (0, js_1.findNodes)(source, [
         tsModule.SyntaxKind.JsxSelfClosingElement,
@@ -222,7 +222,7 @@ function findClosestOpening(tagName, node) {
 }
 function isTag(tagName, node) {
     if (!tsModule) {
-        tsModule = (0, ensure_typescript_1.ensureTypescript)();
+        tsModule = (0, internal_1.ensureTypescript)();
     }
     if (tsModule.isJsxOpeningLikeElement(node)) {
         return (node.tagName.kind === tsModule.SyntaxKind.Identifier &&
@@ -236,7 +236,7 @@ function isTag(tagName, node) {
 }
 function addInitialRoutes(sourcePath, source, addBrowserRouter) {
     if (!tsModule) {
-        tsModule = (0, ensure_typescript_1.ensureTypescript)();
+        tsModule = (0, internal_1.ensureTypescript)();
     }
     const jsxClosingElements = (0, js_1.findNodes)(source, [
         tsModule.SyntaxKind.JsxClosingElement,
@@ -405,7 +405,7 @@ const store = configureStore({
 }
 function updateReduxStore(sourcePath, source, feature) {
     if (!tsModule) {
-        tsModule = (0, ensure_typescript_1.ensureTypescript)();
+        tsModule = (0, internal_1.ensureTypescript)();
     }
     const calls = (0, js_1.findNodes)(source, tsModule.SyntaxKind.CallExpression);
     let reducerDescriptor;
@@ -459,7 +459,7 @@ function updateReduxStore(sourcePath, source, feature) {
 }
 function getComponentNode(sourceFile) {
     if (!tsModule) {
-        tsModule = (0, ensure_typescript_1.ensureTypescript)();
+        tsModule = (0, internal_1.ensureTypescript)();
     }
     const defaultExport = findDefaultExport(sourceFile);
     if (!(defaultExport &&
@@ -472,7 +472,7 @@ function getComponentNode(sourceFile) {
 }
 function parseComponentPropsInfo(sourceFile, cmpDeclaration) {
     if (!tsModule) {
-        tsModule = (0, ensure_typescript_1.ensureTypescript)();
+        tsModule = (0, internal_1.ensureTypescript)();
     }
     let propsTypeName = null;
     let inlineTypeString = null;

package/{src → dist/src}/utils/component-props.d.ts

@@ -14,4 +14,3 @@ export declare function getComponentPropDefaults(sourceFile: ts.SourceFile, cmpD
     }[];
 };
 export declare function getImportForType(sourceFile: ts.SourceFile, typeName: string): ts.Statement;
-//# sourceMappingURL=component-props.d.ts.map

package/{src → dist/src}/utils/component-props.js

@@ -3,13 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getArgsDefaultValue = getArgsDefaultValue;
 exports.getComponentPropDefaults = getComponentPropDefaults;
 exports.getImportForType = getImportForType;
-const ensure_typescript_1 = require("@nx/js/src/utils/typescript/ensure-typescript");
+const internal_1 = require("@nx/js/internal");
 const ast_utils_1 = require("./ast-utils");
 let tsModule;
 // TODO: candidate to refactor with the angular component story
 function getArgsDefaultValue(property) {
     if (!tsModule) {
-        tsModule = (0, ensure_typescript_1.ensureTypescript)();
+        tsModule = (0, internal_1.ensureTypescript)();
     }
     const typeNameToDefault = {
         [tsModule.SyntaxKind.StringKeyword]: "''",
@@ -26,7 +26,7 @@ function getArgsDefaultValue(property) {
 }
 function getComponentPropDefaults(sourceFile, cmpDeclaration) {
     if (!tsModule) {
-        tsModule = (0, ensure_typescript_1.ensureTypescript)();
+        tsModule = (0, internal_1.ensureTypescript)();
     }
     const info = (0, ast_utils_1.parseComponentPropsInfo)(sourceFile, cmpDeclaration);
     let propsTypeName = null;

package/{src → dist/src}/utils/create-ts-config.d.ts

@@ -7,4 +7,3 @@ export declare function createTsConfig(host: Tree, projectRoot: string, type: 'a
     unitTestRunner?: string;
 }, relativePathToRootTsConfig: string): void;
 export declare function extractTsConfigBase(host: Tree): void;
-//# sourceMappingURL=create-ts-config.d.ts.map