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

package/src/rules/add-styled-dependencies.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addStyledModuleDependencies = void 0;
+const devkit_1 = require("@nx/devkit");
+const styled_1 = require("../utils/styled");
+function addStyledModuleDependencies(host, options) {
+    const extraDependencies = options.compiler === 'swc'
+        ? styled_1.cssInJsDependenciesSwc[options.styledModule]
+        : styled_1.cssInJsDependenciesBabel[options.styledModule];
+    if (extraDependencies) {
+        return (0, devkit_1.addDependenciesToPackageJson)(host, extraDependencies.dependencies, extraDependencies.devDependencies);
+    }
+    else {
+        return () => { };
+    }
+}
+exports.addStyledModuleDependencies = addStyledModuleDependencies;

package/src/rules/update-module-federation-project.d.ts

@@ -0,0 +1,9 @@
+import { GeneratorCallback, Tree } from '@nx/devkit';
+export declare function updateModuleFederationProject(host: Tree, options: {
+    js?: boolean;
+    projectName: string;
+    appProjectRoot: string;
+    devServerPort?: number;
+    typescriptConfiguration?: boolean;
+    dynamic?: boolean;
+}): GeneratorCallback;

package/src/rules/update-module-federation-project.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateModuleFederationProject = void 0;
+const devkit_1 = require("@nx/devkit");
+const versions_1 = require("../utils/versions");
+const maybe_js_1 = require("../utils/maybe-js");
+function updateModuleFederationProject(host, options) {
+    const projectConfig = (0, devkit_1.readProjectConfiguration)(host, options.projectName);
+    projectConfig.targets.build.options = {
+        ...projectConfig.targets.build.options,
+        main: (0, maybe_js_1.maybeJs)(options, `${options.appProjectRoot}/src/main.ts`),
+        webpackConfig: `${options.appProjectRoot}/webpack.config.${options.typescriptConfiguration && !options.js ? 'ts' : 'js'}`,
+    };
+    projectConfig.targets.build.configurations.production = {
+        ...projectConfig.targets.build.configurations.production,
+        webpackConfig: `${options.appProjectRoot}/webpack.config.prod.${options.typescriptConfiguration && !options.js ? 'ts' : 'js'}`,
+    };
+    // If host should be configured to use dynamic federation
+    if (options.dynamic) {
+        const pathToProdWebpackConfig = (0, devkit_1.joinPathFragments)(projectConfig.root, `webpack.prod.config.${options.typescriptConfiguration && !options.js ? 'ts' : 'js'}`);
+        if (host.exists(pathToProdWebpackConfig)) {
+            host.delete(pathToProdWebpackConfig);
+        }
+        delete projectConfig.targets.build.configurations.production?.webpackConfig;
+    }
+    projectConfig.targets.serve.executor =
+        '@nx/react:module-federation-dev-server';
+    projectConfig.targets.serve.options.port = options.devServerPort;
+    // `serve-static` for remotes that don't need to be in development mode
+    projectConfig.targets['serve-static'] = {
+        executor: '@nx/web:file-server',
+        defaultConfiguration: 'production',
+        options: {
+            buildTarget: `${options.projectName}:build`,
+            watch: false,
+            port: options.devServerPort,
+        },
+        configurations: {
+            development: {
+                buildTarget: `${options.projectName}:build:development`,
+            },
+            production: {
+                buildTarget: `${options.projectName}:build:production`,
+            },
+        },
+    };
+    (0, devkit_1.updateProjectConfiguration)(host, options.projectName, projectConfig);
+    return (0, devkit_1.addDependenciesToPackageJson)(host, {}, { '@nx/web': versions_1.nxVersion });
+}
+exports.updateModuleFederationProject = updateModuleFederationProject;

package/src/utils/add-mf-env-to-inputs.d.ts

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

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

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addMfEnvToTargetDefaultInputs = void 0;
+const devkit_1 = require("@nx/devkit");
+function addMfEnvToTargetDefaultInputs(tree) {
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    const webpackExecutor = '@nx/webpack:webpack';
+    const mfEnvVar = 'NX_MF_DEV_SERVER_STATIC_REMOTES';
+    nxJson.targetDefaults ??= {};
+    nxJson.targetDefaults[webpackExecutor] ??= {};
+    nxJson.targetDefaults[webpackExecutor].inputs ??= [];
+    let mfEnvVarExists = false;
+    for (const input of nxJson.targetDefaults[webpackExecutor].inputs) {
+        if (typeof input === 'object' && input['env'] === mfEnvVar) {
+            mfEnvVarExists = true;
+            break;
+        }
+    }
+    if (!mfEnvVarExists) {
+        nxJson.targetDefaults[webpackExecutor].inputs.push({ env: mfEnvVar });
+        (0, devkit_1.updateNxJson)(tree, nxJson);
+    }
+}
+exports.addMfEnvToTargetDefaultInputs = addMfEnvToTargetDefaultInputs;

package/src/utils/assertion.d.ts

@@ -0,0 +1 @@
+export declare function assertValidStyle(style: string): void;

package/src/utils/assertion.js

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

package/src/utils/ast-utils.d.ts

@@ -0,0 +1,29 @@
+import type * as ts from 'typescript';
+import { StringChange } from '@nx/devkit';
+export declare function addImport(source: ts.SourceFile, statement: string): StringChange[];
+export declare function findMainRenderStatement(source: ts.SourceFile): ts.CallExpression | null;
+export declare function findDefaultExport(source: ts.SourceFile): ts.VariableDeclaration | ts.FunctionDeclaration | ts.ClassDeclaration | null;
+export declare function findDefaultExportDeclaration(source: ts.SourceFile): ts.VariableDeclaration | ts.FunctionDeclaration | ts.ClassDeclaration | null;
+export declare function findExportDeclarationsForJsx(source: ts.SourceFile): Array<ts.VariableDeclaration | ts.FunctionDeclaration | ts.ClassDeclaration> | null;
+export declare function findDefaultExportIdentifier(source: ts.SourceFile): ts.Identifier | null;
+export declare function findDefaultClassOrFunction(source: ts.SourceFile | null): ts.FunctionDeclaration | ts.ClassDeclaration | null;
+export declare function findComponentImportPath(componentName: string, source: ts.SourceFile): string;
+export declare function findElements(source: ts.SourceFile, tagName: string): ts.Node[];
+export declare function findClosestOpening(tagName: string, node: ts.Node): ts.Node;
+export declare function isTag(tagName: string, node: ts.Node): boolean;
+export declare function addInitialRoutes(sourcePath: string, source: ts.SourceFile): StringChange[];
+export declare function addRoute(sourcePath: string, source: ts.SourceFile, options: {
+    routePath: string;
+    componentName: string;
+    moduleName: string;
+}): StringChange[];
+export declare function addBrowserRouter(sourcePath: string, source: ts.SourceFile): StringChange[];
+export declare function addStaticRouter(sourcePath: string, source: ts.SourceFile): StringChange[];
+export declare function addReduxStoreToMain(sourcePath: string, source: ts.SourceFile): StringChange[];
+export declare function updateReduxStore(sourcePath: string, source: ts.SourceFile, feature: {
+    keyName: string;
+    reducerName: string;
+    modulePath: string;
+}): StringChange[];
+export declare function getComponentNode(sourceFile: ts.SourceFile): ts.Node | null;
+export declare function getComponentPropsInterface(sourceFile: ts.SourceFile, cmpDeclaration: ts.Node): ts.InterfaceDeclaration | null;

package/src/utils/ast-utils.js

@@ -0,0 +1,522 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getComponentPropsInterface = exports.getComponentNode = exports.updateReduxStore = exports.addReduxStoreToMain = exports.addStaticRouter = exports.addBrowserRouter = exports.addRoute = exports.addInitialRoutes = exports.isTag = exports.findClosestOpening = exports.findElements = exports.findComponentImportPath = exports.findDefaultClassOrFunction = exports.findDefaultExportIdentifier = exports.findExportDeclarationsForJsx = exports.findDefaultExportDeclaration = exports.findDefaultExport = exports.findMainRenderStatement = exports.addImport = void 0;
+const js_1 = require("@nx/js");
+const devkit_1 = require("@nx/devkit");
+const ensure_typescript_1 = require("@nx/js/src/utils/typescript/ensure-typescript");
+let tsModule;
+function addImport(source, statement) {
+    if (!tsModule) {
+        tsModule = (0, ensure_typescript_1.ensureTypescript)();
+    }
+    const allImports = (0, js_1.findNodes)(source, tsModule.SyntaxKind.ImportDeclaration);
+    if (allImports.length > 0) {
+        const lastImport = allImports[allImports.length - 1];
+        return [
+            {
+                type: devkit_1.ChangeType.Insert,
+                index: lastImport.end + 1,
+                text: `\n${statement}\n`,
+            },
+        ];
+    }
+    else {
+        return [
+            {
+                type: devkit_1.ChangeType.Insert,
+                index: 0,
+                text: `\n${statement}\n`,
+            },
+        ];
+    }
+}
+exports.addImport = addImport;
+function findMainRenderStatement(source) {
+    if (!tsModule) {
+        tsModule = (0, ensure_typescript_1.ensureTypescript)();
+    }
+    // 1. Try to find ReactDOM.render.
+    const calls = (0, js_1.findNodes)(source, tsModule.SyntaxKind.CallExpression);
+    for (const expr of calls) {
+        const inner = expr.expression;
+        // React 17 and below
+        if (tsModule.isPropertyAccessExpression(inner) &&
+            /ReactDOM/i.test(inner.expression.getText()) &&
+            inner.name.getText() === 'render') {
+            return expr;
+        }
+        // React 18
+        if (tsModule.isPropertyAccessExpression(inner) &&
+            /root/.test(inner.expression.getText()) &&
+            inner.name.getText() === 'render') {
+            return expr;
+        }
+    }
+    // 2. Try to find render from 'react-dom'.
+    const imports = (0, js_1.findNodes)(source, tsModule.SyntaxKind.ImportDeclaration);
+    const hasRenderImport = imports.some((i) => i.moduleSpecifier.getText().includes('react-dom') &&
+        /\brender\b/.test(i.importClause.namedBindings.getText()));
+    if (hasRenderImport) {
+        const calls = (0, js_1.findNodes)(source, tsModule.SyntaxKind.CallExpression);
+        for (const expr of calls) {
+            if (expr.expression.getText() === 'render') {
+                return expr;
+            }
+        }
+    }
+    return null;
+}
+exports.findMainRenderStatement = findMainRenderStatement;
+function findDefaultExport(source) {
+    return (findDefaultExportDeclaration(source) || findDefaultClassOrFunction(source));
+}
+exports.findDefaultExport = findDefaultExport;
+function findDefaultExportDeclaration(source) {
+    if (!tsModule) {
+        tsModule = (0, ensure_typescript_1.ensureTypescript)();
+    }
+    const identifier = findDefaultExportIdentifier(source);
+    if (identifier) {
+        const variables = (0, js_1.findNodes)(source, tsModule.SyntaxKind.VariableDeclaration);
+        const fns = (0, js_1.findNodes)(source, tsModule.SyntaxKind.FunctionDeclaration);
+        const cls = (0, js_1.findNodes)(source, tsModule.SyntaxKind.ClassDeclaration);
+        const all = [...variables, ...fns, ...cls];
+        const exported = all
+            .filter((x) => x.name.kind === tsModule.SyntaxKind.Identifier)
+            .find((x) => x.name.text === identifier.text);
+        return exported || null;
+    }
+    else {
+        return null;
+    }
+}
+exports.findDefaultExportDeclaration = findDefaultExportDeclaration;
+function findExportDeclarationsForJsx(source) {
+    if (!tsModule) {
+        tsModule = (0, ensure_typescript_1.ensureTypescript)();
+    }
+    const variables = (0, js_1.findNodes)(source, tsModule.SyntaxKind.VariableDeclaration);
+    const variableStatements = (0, js_1.findNodes)(source, tsModule.SyntaxKind.VariableStatement);
+    const fns = (0, js_1.findNodes)(source, tsModule.SyntaxKind.FunctionDeclaration);
+    const cls = (0, js_1.findNodes)(source, tsModule.SyntaxKind.ClassDeclaration);
+    const exportDeclarations = (0, js_1.findNodes)(source, tsModule.SyntaxKind.ExportDeclaration);
+    let componentNamesNodes = [];
+    exportDeclarations.forEach((node) => {
+        componentNamesNodes = [
+            ...componentNamesNodes,
+            ...(0, js_1.findNodes)(node, tsModule.SyntaxKind.ExportSpecifier),
+        ];
+    });
+    const componentNames = componentNamesNodes?.map((node) => node.getText());
+    const all = [...variables, ...variableStatements, ...fns, ...cls];
+    let foundExport;
+    let foundJSX;
+    const nodesContainingJSX = all.filter((x) => {
+        foundJSX = (0, js_1.findNodes)(x, [
+            tsModule.SyntaxKind.JsxSelfClosingElement,
+            tsModule.SyntaxKind.JsxOpeningElement,
+        ]);
+        return foundJSX?.length;
+    });
+    const exported = nodesContainingJSX.filter((x) => {
+        foundExport = (0, js_1.findNodes)(x, tsModule.SyntaxKind.ExportKeyword);
+        if (x.kind === tsModule.SyntaxKind.VariableStatement) {
+            const nameNode = (0, js_1.findNodes)(x, tsModule.SyntaxKind.VariableDeclaration)?.[0];
+            return (nameNode?.name?.kind === tsModule.SyntaxKind.Identifier ||
+                foundExport?.length ||
+                componentNames?.includes(nameNode?.name?.getText()));
+        }
+        else {
+            return ((x.name.kind === tsModule.SyntaxKind.Identifier &&
+                foundExport?.length) ||
+                componentNames?.includes(x.name.getText()));
+        }
+    });
+    const exportedDeclarations = exported.map((x) => {
+        if (x.kind === tsModule.SyntaxKind.VariableStatement) {
+            const nameNode = (0, js_1.findNodes)(x, tsModule.SyntaxKind.VariableDeclaration)?.[0];
+            return nameNode;
+        }
+        return x;
+    });
+    return exportedDeclarations || null;
+}
+exports.findExportDeclarationsForJsx = findExportDeclarationsForJsx;
+function findDefaultExportIdentifier(source) {
+    if (!tsModule) {
+        tsModule = (0, ensure_typescript_1.ensureTypescript)();
+    }
+    const exports = (0, js_1.findNodes)(source, tsModule.SyntaxKind.ExportAssignment);
+    const identifier = exports
+        .map((x) => x.expression)
+        .find((x) => x.kind === tsModule.SyntaxKind.Identifier);
+    return identifier || null;
+}
+exports.findDefaultExportIdentifier = findDefaultExportIdentifier;
+function findDefaultClassOrFunction(source) {
+    if (!tsModule) {
+        tsModule = (0, ensure_typescript_1.ensureTypescript)();
+    }
+    const fns = (0, js_1.findNodes)(source, tsModule.SyntaxKind.FunctionDeclaration);
+    const cls = (0, js_1.findNodes)(source, tsModule.SyntaxKind.ClassDeclaration);
+    return (fns.find(hasDefaultExportModifier) ||
+        cls.find(hasDefaultExportModifier) ||
+        null);
+}
+exports.findDefaultClassOrFunction = findDefaultClassOrFunction;
+function hasDefaultExportModifier(x) {
+    if (!tsModule) {
+        tsModule = (0, ensure_typescript_1.ensureTypescript)();
+    }
+    return (x.modifiers &&
+        x.modifiers.some((m) => m.kind === tsModule.SyntaxKind.ExportKeyword) &&
+        x.modifiers.some((m) => m.kind === tsModule.SyntaxKind.DefaultKeyword));
+}
+function findComponentImportPath(componentName, source) {
+    if (!tsModule) {
+        tsModule = (0, ensure_typescript_1.ensureTypescript)();
+    }
+    const allImports = (0, js_1.findNodes)(source, tsModule.SyntaxKind.ImportDeclaration);
+    const matching = allImports.filter((i) => {
+        return (i.importClause &&
+            i.importClause.name &&
+            i.importClause.name.getText() === componentName);
+    });
+    if (matching.length === 0) {
+        return null;
+    }
+    const appImport = matching[0];
+    return appImport.moduleSpecifier.getText().replace(/['"]/g, '');
+}
+exports.findComponentImportPath = findComponentImportPath;
+function findElements(source, tagName) {
+    if (!tsModule) {
+        tsModule = (0, ensure_typescript_1.ensureTypescript)();
+    }
+    const nodes = (0, js_1.findNodes)(source, [
+        tsModule.SyntaxKind.JsxSelfClosingElement,
+        tsModule.SyntaxKind.JsxOpeningElement,
+    ]);
+    return nodes.filter((node) => isTag(tagName, node));
+}
+exports.findElements = findElements;
+function findClosestOpening(tagName, node) {
+    if (!node) {
+        return null;
+    }
+    if (isTag(tagName, node)) {
+        return node;
+    }
+    else {
+        return findClosestOpening(tagName, node.parent);
+    }
+}
+exports.findClosestOpening = findClosestOpening;
+function isTag(tagName, node) {
+    if (!tsModule) {
+        tsModule = (0, ensure_typescript_1.ensureTypescript)();
+    }
+    if (tsModule.isJsxOpeningLikeElement(node)) {
+        return (node.tagName.kind === tsModule.SyntaxKind.Identifier &&
+            node.tagName.text === tagName);
+    }
+    if (tsModule.isJsxElement(node) && node.openingElement) {
+        return (node.openingElement.tagName.kind === tsModule.SyntaxKind.Identifier &&
+            node.openingElement.tagName.getText() === tagName);
+    }
+    return false;
+}
+exports.isTag = isTag;
+function addInitialRoutes(sourcePath, source) {
+    if (!tsModule) {
+        tsModule = (0, ensure_typescript_1.ensureTypescript)();
+    }
+    const jsxClosingElements = (0, js_1.findNodes)(source, [
+        tsModule.SyntaxKind.JsxClosingElement,
+        tsModule.SyntaxKind.JsxClosingFragment,
+    ]);
+    const outerMostJsxClosing = jsxClosingElements[jsxClosingElements.length - 1];
+    if (!outerMostJsxClosing) {
+        devkit_1.logger.warn(`Could not find JSX elements in ${sourcePath}; Skipping insert routes`);
+        return [];
+    }
+    const insertRoutes = {
+        type: devkit_1.ChangeType.Insert,
+        index: outerMostJsxClosing.getStart(),
+        text: `
+    {/* START: routes */}
+    {/* These routes and navigation have been generated for you */}
+    {/* Feel free to move and update them to fit your needs */}
+    <br/>
+    <hr/>
+    <br/>
+    <div role="navigation">
+      <ul>
+        <li><Link to="/">Home</Link></li>
+        <li><Link to="/page-2">Page 2</Link></li>
+      </ul>
+    </div>
+    <Routes>
+      <Route
+        path="/"
+        element={
+          <div>This is the generated root route. <Link to="/page-2">Click here for page 2.</Link></div>
+        }
+      />
+      <Route
+        path="/page-2"
+        element={
+          <div><Link to="/">Click here to go back to root page.</Link></div>
+        }
+      />
+    </Routes>
+    {/* END: routes */}
+    `,
+    };
+    return [
+        ...addImport(source, `import { Route, Routes, Link } from 'react-router-dom';`),
+        insertRoutes,
+    ];
+}
+exports.addInitialRoutes = addInitialRoutes;
+function addRoute(sourcePath, source, options) {
+    const routes = findElements(source, 'Route');
+    const links = findElements(source, 'Link');
+    if (routes.length === 0) {
+        devkit_1.logger.warn(`Could not find <Route/> components in ${sourcePath}; Skipping add route`);
+        return [];
+    }
+    else {
+        const changes = [];
+        const firstRoute = routes[0];
+        const firstLink = links[0];
+        changes.push(...addImport(source, `import { ${options.componentName} } from '${options.moduleName}';`));
+        changes.push({
+            type: devkit_1.ChangeType.Insert,
+            index: firstRoute.getEnd(),
+            text: `<Route path="${options.routePath}" element={<${options.componentName}/>} />`,
+        });
+        if (firstLink) {
+            const parentLi = findClosestOpening('li', firstLink);
+            if (parentLi) {
+                changes.push({
+                    type: devkit_1.ChangeType.Insert,
+                    index: parentLi.getEnd(),
+                    text: `<li><Link to="${options.routePath}">${options.componentName}</Link></li>`,
+                });
+            }
+            else {
+                changes.push({
+                    type: devkit_1.ChangeType.Insert,
+                    index: firstLink.parent.getEnd(),
+                    text: `<Link to="${options.routePath}">${options.componentName}</Link>`,
+                });
+            }
+        }
+        return changes;
+    }
+}
+exports.addRoute = addRoute;
+function addBrowserRouter(sourcePath, source) {
+    const app = findElements(source, 'App')[0];
+    if (app) {
+        return [
+            ...addImport(source, `import { BrowserRouter } from 'react-router-dom';`),
+            {
+                type: devkit_1.ChangeType.Insert,
+                index: app.getStart(),
+                text: `<BrowserRouter>`,
+            },
+            {
+                type: devkit_1.ChangeType.Insert,
+                index: app.getEnd(),
+                text: `</BrowserRouter>`,
+            },
+        ];
+    }
+    else {
+        devkit_1.logger.warn(`Could not find App component in ${sourcePath}; Skipping add <BrowserRouter>`);
+        return [];
+    }
+}
+exports.addBrowserRouter = addBrowserRouter;
+function addStaticRouter(sourcePath, source) {
+    const app = findElements(source, 'App')[0];
+    if (app) {
+        return [
+            ...addImport(source, `import { StaticRouter } from 'react-router-dom/server';`),
+            {
+                type: devkit_1.ChangeType.Insert,
+                index: app.getStart(),
+                text: `<StaticRouter location={req.originalUrl}>`,
+            },
+            {
+                type: devkit_1.ChangeType.Insert,
+                index: app.getEnd(),
+                text: `</StaticRouter>`,
+            },
+        ];
+    }
+    else {
+        devkit_1.logger.warn(`Could not find App component in ${sourcePath}; Skipping add <StaticRouter>`);
+        return [];
+    }
+}
+exports.addStaticRouter = addStaticRouter;
+function addReduxStoreToMain(sourcePath, source) {
+    const renderStmt = findMainRenderStatement(source);
+    if (!renderStmt) {
+        devkit_1.logger.warn(`Could not find render(...) in ${sourcePath}`);
+        return [];
+    }
+    const jsx = renderStmt.arguments[0];
+    return [
+        ...addImport(source, `import { configureStore } from '@reduxjs/toolkit';
+import { Provider } from 'react-redux';`),
+        {
+            type: devkit_1.ChangeType.Insert,
+            index: renderStmt.getStart(),
+            text: `
+const store = configureStore({
+  reducer: {},
+  // Additional middleware can be passed to this array
+  middleware: getDefaultMiddleware => getDefaultMiddleware(),
+  devTools: process.env.NODE_ENV !== 'production',
+  // Optional Redux store enhancers
+  enhancers: [],
+});
+
+`,
+        },
+        {
+            type: devkit_1.ChangeType.Insert,
+            index: jsx.getStart(),
+            text: `<Provider store={store}>`,
+        },
+        {
+            type: devkit_1.ChangeType.Insert,
+            index: jsx.getEnd(),
+            text: `</Provider>`,
+        },
+    ];
+}
+exports.addReduxStoreToMain = addReduxStoreToMain;
+function updateReduxStore(sourcePath, source, feature) {
+    if (!tsModule) {
+        tsModule = (0, ensure_typescript_1.ensureTypescript)();
+    }
+    const calls = (0, js_1.findNodes)(source, tsModule.SyntaxKind.CallExpression);
+    let reducerDescriptor;
+    // Look for configureStore call
+    for (const expr of calls) {
+        if (!expr.expression.getText().includes('configureStore')) {
+            continue;
+        }
+        const arg = expr.arguments[0];
+        if (tsModule.isObjectLiteralExpression(arg)) {
+            let found;
+            for (const prop of arg.properties) {
+                if (tsModule.isPropertyAssignment(prop) &&
+                    prop.name.getText() === 'reducer' &&
+                    tsModule.isObjectLiteralExpression(prop.initializer)) {
+                    found = prop.initializer;
+                    break;
+                }
+            }
+            if (found) {
+                reducerDescriptor = found;
+                break;
+            }
+        }
+    }
+    // Look for combineReducer call
+    if (!reducerDescriptor) {
+        for (const expr of calls) {
+            if (!expr.expression.getText().includes('combineReducer')) {
+                continue;
+            }
+            const arg = expr.arguments[0];
+            if (tsModule.isObjectLiteralExpression(arg)) {
+                reducerDescriptor = arg;
+                break;
+            }
+        }
+    }
+    if (!reducerDescriptor) {
+        devkit_1.logger.warn(`Could not find configureStore/combineReducer call in ${sourcePath}`);
+        return [];
+    }
+    return [
+        ...addImport(source, `import { ${feature.keyName}, ${feature.reducerName} } from '${feature.modulePath}';`),
+        {
+            type: devkit_1.ChangeType.Insert,
+            index: reducerDescriptor.getStart() + 1,
+            text: `[${feature.keyName}]: ${feature.reducerName}${reducerDescriptor.properties.length > 0 ? ',' : ''}`,
+        },
+    ];
+}
+exports.updateReduxStore = updateReduxStore;
+function getComponentNode(sourceFile) {
+    if (!tsModule) {
+        tsModule = (0, ensure_typescript_1.ensureTypescript)();
+    }
+    const defaultExport = findDefaultExport(sourceFile);
+    if (!(defaultExport &&
+        ((0, js_1.findNodes)(defaultExport, tsModule.SyntaxKind.JsxElement).length > 0 ||
+            (0, js_1.findNodes)(defaultExport, tsModule.SyntaxKind.JsxSelfClosingElement)
+                .length > 0))) {
+        return null;
+    }
+    return defaultExport;
+}
+exports.getComponentNode = getComponentNode;
+function getComponentPropsInterface(sourceFile, cmpDeclaration) {
+    if (!tsModule) {
+        tsModule = (0, ensure_typescript_1.ensureTypescript)();
+    }
+    let propsTypeName = null;
+    if (tsModule.isFunctionDeclaration(cmpDeclaration)) {
+        const propsParam = cmpDeclaration.parameters.find((x) => tsModule.isParameter(x) && x.name.text === 'props');
+        if (propsParam?.type?.['typeName']) {
+            propsTypeName = propsParam.type.typeName.text;
+        }
+    }
+    else if (cmpDeclaration.initializer &&
+        tsModule.isArrowFunction(cmpDeclaration.initializer)) {
+        const arrowFn = cmpDeclaration
+            .initializer;
+        const propsParam = arrowFn.parameters.find((x) => tsModule.isParameter(x) && x.name.text === 'props');
+        if (propsParam?.type?.['typeName']) {
+            propsTypeName = propsParam.type.typeName.text;
+        }
+    }
+    else if (
+    // do we have a class component extending from React.Component
+    tsModule.isClassDeclaration(cmpDeclaration) &&
+        cmpDeclaration.heritageClauses &&
+        cmpDeclaration.heritageClauses.length > 0) {
+        const heritageClause = cmpDeclaration.heritageClauses[0];
+        if (heritageClause) {
+            const propsTypeExpression = heritageClause.types.find((x) => {
+                const name = x.expression.escapedText ||
+                    x.expression.name.text;
+                return name === 'Component' || name === 'PureComponent';
+            });
+            if (propsTypeExpression?.typeArguments?.[0]?.['typeName']) {
+                propsTypeName = propsTypeExpression.typeArguments[0].typeName.getText();
+            }
+        }
+    }
+    else {
+        return null;
+    }
+    if (propsTypeName) {
+        return (0, js_1.findNodes)(sourceFile, tsModule.SyntaxKind.InterfaceDeclaration).find((x) => {
+            return x.name.getText() === propsTypeName;
+        });
+    }
+    else {
+        return null;
+    }
+}
+exports.getComponentPropsInterface = getComponentPropsInterface;