@nx/webpack 17.0.4 → 17.0.6

package/src/generators/init/schema.json

@@ -1,31 +1,26 @@
 {
-  "$schema": "https://json-schema.org/schema",
+  "$schema": "http://json-schema.org/schema",
   "$id": "NxWebpackInit",
   "cli": "nx",
   "title": "Init Webpack Plugin",
   "description": "Initialize the Webpack Plugin.",
   "type": "object",
   "properties": {
-    "skipFormat": {
-      "description": "Skip formatting files.",
-      "type": "boolean",
-      "default": false
+    "uiFramework": {
+      "type": "string",
+      "description": "UI Framework to use for Webpack.",
+      "enum": ["react", "none"],
+      "x-prompt": "What UI framework plugin should Webpack use?"
     },
-    "skipPackageJson": {
-      "description": "Do not add dependencies to `package.json`.",
-      "type": "boolean",
-      "default": false
+    "compiler": {
+      "type": "string",
+      "enum": ["babel", "swc", "tsc"],
+      "description": "The compiler to initialize for.",
+      "default": "babel"
     },
-    "keepExistingVersions": {
-      "type": "boolean",
-      "x-priority": "internal",
-      "description": "Keep existing dependencies versions",
-      "default": false
-    },
-    "updatePackageScripts": {
+    "skipFormat": {
+      "description": "Skip formatting files.",
       "type": "boolean",
-      "x-priority": "internal",
-      "description": "Update `package.json` scripts with inferred targets",
       "default": false
     }
   },

package/src/plugins/generate-package-json-plugin.d.ts

@@ -1,14 +1,12 @@
 import { type Compiler, type WebpackPluginInstance } from 'webpack';
-import { type ProjectGraph } from '@nx/devkit';
+import { ExecutorContext } from '@nx/devkit';
 export declare class GeneratePackageJsonPlugin implements WebpackPluginInstance {
     private readonly options;
+    private readonly context;
+    private readonly projectGraph;
     constructor(options: {
         tsConfig: string;
         outputFileName: string;
-        root: string;
-        projectName: string;
-        targetName: string;
-        projectGraph: ProjectGraph;
-    });
+    }, context: ExecutorContext);
     apply(compiler: Compiler): void;
 }

package/src/plugins/generate-package-json-plugin.js

@@ -4,10 +4,13 @@ exports.GeneratePackageJsonPlugin = void 0;
 const webpack_1 = require("webpack");
 const js_1 = require("@nx/js");
 const devkit_1 = require("@nx/devkit");
+const js_2 = require("@nx/js");
 const pluginName = 'GeneratePackageJsonPlugin';
 class GeneratePackageJsonPlugin {
-    constructor(options) {
+    constructor(options, context) {
         this.options = options;
+        this.context = context;
+        this.projectGraph = context.projectGraph;
     }
     apply(compiler) {
         compiler.hooks.thisCompilation.tap(pluginName, (compilation) => {
@@ -15,28 +18,28 @@ class GeneratePackageJsonPlugin {
                 name: pluginName,
                 stage: compiler.webpack.Compilation.PROCESS_ASSETS_STAGE_ADDITIONAL,
             }, () => {
-                const helperDependencies = (0, js_1.getHelperDependenciesFromProjectGraph)(this.options.root, this.options.projectName, this.options.projectGraph);
-                const importHelpers = !!(0, js_1.readTsConfig)(this.options.tsConfig).options
+                const helperDependencies = (0, js_2.getHelperDependenciesFromProjectGraph)(this.context.root, this.context.projectName, this.projectGraph);
+                const importHelpers = !!(0, js_2.readTsConfig)(this.options.tsConfig).options
                     .importHelpers;
                 const shouldAddHelperDependency = importHelpers &&
-                    helperDependencies.every((dep) => dep.target !== js_1.HelperDependency.tsc);
+                    helperDependencies.every((dep) => dep.target !== js_2.HelperDependency.tsc);
                 if (shouldAddHelperDependency) {
                     helperDependencies.push({
                         type: 'static',
-                        source: this.options.projectName,
-                        target: js_1.HelperDependency.tsc,
+                        source: this.context.projectName,
+                        target: js_2.HelperDependency.tsc,
                     });
                 }
-                const packageJson = (0, js_1.createPackageJson)(this.options.projectName, this.options.projectGraph, {
-                    target: this.options.targetName,
-                    root: this.options.root,
+                const packageJson = (0, js_1.createPackageJson)(this.context.projectName, this.projectGraph, {
+                    target: this.context.targetName,
+                    root: this.context.root,
                     isProduction: true,
                     helperDependencies: helperDependencies.map((dep) => dep.target),
                 });
                 packageJson.main = packageJson.main ?? this.options.outputFileName;
                 compilation.emitAsset('package.json', new webpack_1.sources.RawSource((0, devkit_1.serializeJson)(packageJson)));
-                const packageManager = (0, devkit_1.detectPackageManager)(this.options.root);
-                compilation.emitAsset((0, js_1.getLockFileName)(packageManager), new webpack_1.sources.RawSource((0, js_1.createLockFile)(packageJson, this.options.projectGraph, packageManager)));
+                const packageManager = (0, devkit_1.detectPackageManager)(this.context.root);
+                compilation.emitAsset((0, js_2.getLockFileName)(packageManager), new webpack_1.sources.RawSource((0, js_1.createLockFile)(packageJson, this.projectGraph, packageManager)));
             });
         });
     }

package/src/utils/config.d.ts

@@ -1,22 +1,17 @@
 import { ExecutorContext } from '@nx/devkit';
 import { Configuration } from 'webpack';
 import { NormalizedWebpackExecutorOptions } from '../executors/webpack/schema';
-export declare const nxWebpackComposablePlugin = "nxWebpackComposablePlugin";
-export declare function isNxWebpackComposablePlugin(a: unknown): a is AsyncNxComposableWebpackPlugin;
+/** @deprecated use withNx and withWeb plugins directly */
+export declare function getBaseWebpackPartial(options: NormalizedWebpackExecutorOptions, context?: ExecutorContext): Configuration;
 export interface NxWebpackExecutionContext {
     options: NormalizedWebpackExecutorOptions;
     context: ExecutorContext;
-    configuration?: string;
 }
-export interface NxComposableWebpackPlugin {
+export interface NxWebpackPlugin {
     (config: Configuration, ctx: NxWebpackExecutionContext): Configuration;
 }
-export interface AsyncNxComposableWebpackPlugin {
+export interface AsyncNxWebpackPlugin {
     (config: Configuration, ctx: NxWebpackExecutionContext): Configuration | Promise<Configuration>;
 }
-export declare function composePlugins(...plugins: (NxComposableWebpackPlugin | AsyncNxComposableWebpackPlugin | Promise<NxComposableWebpackPlugin | AsyncNxComposableWebpackPlugin>)[]): ((config: Configuration, ctx: NxWebpackExecutionContext) => Promise<Configuration>) & {
-    nxWebpackComposablePlugin: boolean;
-};
-export declare function composePluginsSync(...plugins: NxComposableWebpackPlugin[]): ((config: Configuration, ctx: NxWebpackExecutionContext) => Configuration) & {
-    nxWebpackComposablePlugin: boolean;
-};
+export declare function composePlugins(...plugins: (NxWebpackPlugin | AsyncNxWebpackPlugin | Promise<NxWebpackPlugin | AsyncNxWebpackPlugin>)[]): (config: Configuration, ctx: NxWebpackExecutionContext) => Promise<Configuration>;
+export declare function composePluginsSync(...plugins: NxWebpackPlugin[]): (config: Configuration, ctx: NxWebpackExecutionContext) => Configuration;

package/src/utils/config.js

@@ -1,66 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.composePluginsSync = exports.composePlugins = exports.isNxWebpackComposablePlugin = exports.nxWebpackComposablePlugin = void 0;
-const devkit_1 = require("@nx/devkit");
-exports.nxWebpackComposablePlugin = 'nxWebpackComposablePlugin';
-function isNxWebpackComposablePlugin(a) {
-    return a?.[exports.nxWebpackComposablePlugin] === true;
+exports.composePluginsSync = exports.composePlugins = exports.getBaseWebpackPartial = void 0;
+const with_nx_1 = require("./with-nx");
+const with_web_1 = require("./with-web");
+/** @deprecated use withNx and withWeb plugins directly */
+function getBaseWebpackPartial(options, context) {
+    const config = {};
+    const configure = composePluginsSync((0, with_nx_1.withNx)(), (0, with_web_1.withWeb)());
+    return configure(config, { options, context });
 }
-exports.isNxWebpackComposablePlugin = isNxWebpackComposablePlugin;
+exports.getBaseWebpackPartial = getBaseWebpackPartial;
 function composePlugins(...plugins) {
-    return Object.assign(async function combined(config, ctx) {
-        // Webpack may be calling us as a standard config function.
-        // Build up Nx context from environment variables.
-        // This is to enable `@nx/webpack/plugin` to work with existing projects.
-        if (ctx['env']) {
-            ensureNxWebpackExecutionContext(ctx);
-            // Build this from scratch since what webpack passes us is the env, not config,
-            // and `withNX()` creates a new config object anyway.
-            config = {};
-        }
+    return async function combined(config, ctx) {
         for (const plugin of plugins) {
             const fn = await plugin;
             config = await fn(config, ctx);
         }
         return config;
-    }, {
-        [exports.nxWebpackComposablePlugin]: true,
-    });
+    };
 }
 exports.composePlugins = composePlugins;
 function composePluginsSync(...plugins) {
-    return Object.assign(function combined(config, ctx) {
+    return function combined(config, ctx) {
         for (const plugin of plugins) {
             config = plugin(config, ctx);
         }
         return config;
-    }, {
-        [exports.nxWebpackComposablePlugin]: true,
-    });
-}
-exports.composePluginsSync = composePluginsSync;
-function ensureNxWebpackExecutionContext(ctx) {
-    const projectName = process.env.NX_TASK_TARGET_PROJECT;
-    const targetName = process.env.NX_TASK_TARGET_TARGET;
-    const configurationName = process.env.NX_TASK_TARGET_CONFIGURATION;
-    const projectGraph = (0, devkit_1.readCachedProjectGraph)();
-    const projectNode = projectGraph.nodes[projectName];
-    ctx.options ??= {
-        root: devkit_1.workspaceRoot,
-        projectRoot: projectNode.data.root,
-        sourceRoot: projectNode.data.sourceRoot ?? projectNode.data.root,
-        // These aren't actually needed since NxWebpackPlugin and withNx both support them being undefined.
-        assets: undefined,
-        outputPath: undefined,
-        tsConfig: undefined,
-        outputFileName: undefined,
-    };
-    ctx.context ??= {
-        projectName,
-        targetName,
-        configurationName,
-        cwd: process.cwd(),
-        root: devkit_1.workspaceRoot,
-        isVerbose: process.env['NX_VERBOSE_LOGGING'] === 'true',
     };
 }
+exports.composePluginsSync = composePluginsSync;

package/src/utils/get-client-environment.js

@@ -1,15 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getClientEnvironment = void 0;
-// Prevent sensitive keys from being bundled when source code uses entire `process.env` object rather than individual keys (e.g. `process.env.NX_FOO`).
-// TODO(v19): Only env vars prefixed with NX_PUBLIC should be bundled. This is a breaking change so we won't do it in v18.
-const excludedKeys = ['NX_CLOUD_ACCESS_TOKEN', 'NX_CLOUD_ENCRYPTION_KEY'];
 function getClientEnvironment(mode) {
     // Grab NODE_ENV and NX_* environment variables and prepare them to be
     // injected into the application via DefinePlugin in webpack configuration.
     const NX_APP = /^NX_/i;
     const raw = Object.keys(process.env)
-        .filter((key) => !excludedKeys.includes(key) && NX_APP.test(key))
+        .filter((key) => NX_APP.test(key))
         .reduce((env, key) => {
         env[key] = process.env[key];
         return env;

package/src/utils/module-federation/dependencies.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getDependentPackagesForProject = void 0;
 const typescript_1 = require("./typescript");
-const devkit_1 = require("@nx/devkit");
 function getDependentPackagesForProject(projectGraph, name) {
     const { npmPackages, workspaceLibraries } = collectDependencies(projectGraph, name);
     return {
@@ -35,22 +34,11 @@ function collectDependencies(projectGraph, name, dependencies = {
     return dependencies;
 }
 function getLibraryImportPath(library, projectGraph) {
-    let buildLibsFromSource = true;
-    if (process.env.NX_BUILD_LIBS_FROM_SOURCE) {
-        buildLibsFromSource = process.env.NX_BUILD_LIBS_FROM_SOURCE === 'true';
-    }
-    const libraryNode = projectGraph.nodes[library];
-    let sourceRoots = [libraryNode.data.sourceRoot];
-    if (!buildLibsFromSource && process.env.NX_BUILD_TARGET) {
-        const buildTarget = (0, devkit_1.parseTargetString)(process.env.NX_BUILD_TARGET, projectGraph);
-        sourceRoots = (0, devkit_1.getOutputsForTargetAndConfiguration)(buildTarget, {}, libraryNode);
-    }
     const tsConfigPathMappings = (0, typescript_1.readTsPathMappings)();
+    const sourceRoot = projectGraph.nodes[library].data.sourceRoot;
     for (const [key, value] of Object.entries(tsConfigPathMappings)) {
-        for (const src of sourceRoots) {
-            if (value.find((path) => path.startsWith(src))) {
-                return key;
-            }
+        if (value.find((path) => path.startsWith(sourceRoot))) {
+            return key;
         }
     }
     return undefined;

package/src/utils/module-federation/get-remotes-for-host.js

@@ -55,7 +55,7 @@ function getRemotes(devRemotes, skipRemotes, config, context, pathToManifestFile
             : (0, find_matching_projects_1.findMatchingProjects)([devRemotes], context.projectGraph.nodes));
     const staticRemotes = knownRemotes.filter((r) => !devServeApps.has(r));
     const devServeRemotes = knownRemotes.filter((r) => devServeApps.has(r));
-    const remotePorts = devServeRemotes.map((r) => context.projectGraph.nodes[r].data.targets['serve'].options.port);
+    const remotePorts = knownRemotes.map((r) => context.projectGraph.nodes[r].data.targets['serve'].options.port);
     return {
         staticRemotes,
         devRemotes: devServeRemotes,

package/src/utils/module-federation/remotes.js

@@ -39,7 +39,7 @@ function handleArrayRemote(remote, remoteEntryExt, isRemoteGlobal) {
         : '';
     // if the remote is defined with anything other than http then we assume it's a promise based remote
     // In that case we should use what the user provides as the remote location
-    if (!remoteLocation.startsWith('promise new Promise')) {
+    if (remoteLocation.startsWith('http')) {
         return `${globalPrefix}${baseRemote}/remoteEntry.${remoteEntryExt}`;
     }
     else {

package/src/utils/module-federation/secondary-entry-points.js

@@ -6,7 +6,7 @@ const fs_1 = require("fs");
 const devkit_1 = require("@nx/devkit");
 const nx_1 = require("@nx/devkit/nx");
 let { readModulePackageJson } = (0, nx_1.requireNx)();
-// TODO: Remove this in Nx 19 when Nx 16.7.0 is no longer supported
+// TODO: Remove this in Nx 18 when Nx 16.7.0 is no longer supported
 readModulePackageJson =
     readModulePackageJson ??
         require('nx/src/utils/package-json').readModulePackageJson;

package/src/utils/module-federation/typescript.js

@@ -4,23 +4,18 @@ exports.getRootTsConfigPath = exports.readTsConfig = exports.readTsPathMappings
 const fs_1 = require("fs");
 const path_1 = require("path");
 const devkit_1 = require("@nx/devkit");
-let tsConfig = new Map();
-let tsPathMappings = new Map();
+let tsConfig;
+let tsPathMappings;
 function readTsPathMappings(tsConfigPath = process.env.NX_TSCONFIG_PATH ?? getRootTsConfigPath()) {
-    if (tsPathMappings.has(tsConfigPath)) {
-        return tsPathMappings.get(tsConfigPath);
+    if (tsPathMappings) {
+        return tsPathMappings;
     }
-    if (!tsConfig.has(tsConfigPath)) {
-        tsConfig.set(tsConfigPath, readTsConfiguration(tsConfigPath));
-    }
-    tsPathMappings.set(tsConfigPath, {});
-    Object.entries(tsConfig.get(tsConfigPath).options?.paths ?? {}).forEach(([alias, paths]) => {
-        tsPathMappings.set(tsConfigPath, {
-            ...tsPathMappings.get(tsConfigPath),
-            [alias]: paths.map((path) => path.replace(/^\.\//, '')),
-        });
+    tsConfig ??= readTsConfiguration(tsConfigPath);
+    tsPathMappings = {};
+    Object.entries(tsConfig.options?.paths ?? {}).forEach(([alias, paths]) => {
+        tsPathMappings[alias] = paths.map((path) => path.replace(/^\.\//, ''));
     });
-    return tsPathMappings.get(tsConfigPath);
+    return tsPathMappings;
 }
 exports.readTsPathMappings = readTsPathMappings;
 function readTsConfiguration(tsConfigPath) {

package/src/utils/versions.d.ts

@@ -1,7 +1,6 @@
 export declare const nxVersion: any;
 export declare const swcLoaderVersion = "0.1.15";
 export declare const tsLibVersion = "^2.3.0";
-export declare const webpackCliVersion = "^5.1.4";
 export declare const reactRefreshWebpackPluginVersion = "^0.5.7";
 export declare const svgrWebpackVersion = "^8.0.1";
 export declare const reactRefreshVersion = "^0.10.0";

package/src/utils/versions.js

@@ -1,10 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.urlLoaderVersion = exports.reactRefreshVersion = exports.svgrWebpackVersion = exports.reactRefreshWebpackPluginVersion = exports.webpackCliVersion = exports.tsLibVersion = exports.swcLoaderVersion = exports.nxVersion = void 0;
+exports.urlLoaderVersion = exports.reactRefreshVersion = exports.svgrWebpackVersion = exports.reactRefreshWebpackPluginVersion = exports.tsLibVersion = exports.swcLoaderVersion = exports.nxVersion = void 0;
 exports.nxVersion = require('../../package.json').version;
 exports.swcLoaderVersion = '0.1.15';
 exports.tsLibVersion = '^2.3.0';
-exports.webpackCliVersion = '^5.1.4';
 // React apps
 exports.reactRefreshWebpackPluginVersion = '^0.5.7';
 exports.svgrWebpackVersion = '^8.0.1';

package/src/utils/webpack/custom-webpack.d.ts

@@ -0,0 +1,2 @@
+export declare function resolveCustomWebpackConfig(path: string, tsConfig: string): any;
+export declare function isRegistered(): boolean;

package/src/utils/webpack/{resolve-user-defined-webpack-config.js → custom-webpack.js}

@@ -1,19 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveUserDefinedWebpackConfig = void 0;
+exports.isRegistered = exports.resolveCustomWebpackConfig = void 0;
 const internal_1 = require("@nx/js/src/internal");
-function resolveUserDefinedWebpackConfig(path, tsConfig, 
-/** Skip require cache and return latest content */
-reload = false) {
-    if (reload) {
-        // Clear cache if the path is in the cache
-        if (require.cache[path]) {
-            // Clear all entries because config may import other modules
-            for (const k of Object.keys(require.cache)) {
-                delete require.cache[k];
-            }
-        }
-    }
+function resolveCustomWebpackConfig(path, tsConfig) {
     // Don't transpile non-TS files. This prevents workspaces libs from being registered via tsconfig-paths.
     // There's an issue here with Nx workspace where loading plugins from source (via tsconfig-paths) can lead to errors.
     if (!/\.(ts|mts|cts)$/.test(path)) {
@@ -36,4 +25,9 @@ reload = false) {
         : maybeCustomWebpackConfig;
     return customWebpackConfig;
 }
-exports.resolveUserDefinedWebpackConfig = resolveUserDefinedWebpackConfig;
+exports.resolveCustomWebpackConfig = resolveCustomWebpackConfig;
+function isRegistered() {
+    return (require.extensions['.ts'] != undefined ||
+        require.extensions['.tsx'] != undefined);
+}
+exports.isRegistered = isRegistered;

package/src/utils/webpack/deprecated-stylus-loader.js

@@ -3,9 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const devkit_1 = require("@nx/devkit");
 // @ts-ignore
 const stylusLoader = require("stylus-loader");
-// TOOD(v19): Remove this file and stylus support.
+// TOOD(v18): Remove this file and stylus support.
 function default_1(source) {
-    devkit_1.logger.warn(`Stylus is support is deprecated and will be removed in Nx 19. We recommend that you migrate to Sass by renaming \`.styl\` files to \`.scss\` and ensuring that the content is valid Sass.`);
+    devkit_1.logger.warn(`Stylus is support is deprecated and will be removed in Nx 18. We recommend that you migrate to Sass by renaming \`.styl\` files to \`.scss\` and ensuring that the content is valid Sass.`);
     return stylusLoader.call(this, source);
 }
 exports.default = default_1;

package/src/utils/webpack/interpolate-env-variables-to-index.js

@@ -7,11 +7,8 @@ function interpolateEnvironmentVariablesToIndex(contents, deployUrl) {
 }
 exports.interpolateEnvironmentVariablesToIndex = interpolateEnvironmentVariablesToIndex;
 const NX_PREFIX = /^NX_/i;
-// Prevent sensitive keys from being bundled when source code uses entire `process.env` object rather than individual keys (e.g. `process.env.NX_FOO`).
-// TODO(v19): Only env vars prefixed with NX_PUBLIC should be bundled. This is a breaking change so we won't do it in v18.
-const excludedKeys = ['NX_CLOUD_ACCESS_TOKEN', 'NX_CLOUD_ENCRYPTION_KEY'];
 function isNxEnvironmentKey(x) {
-    return !excludedKeys.includes(x) && NX_PREFIX.test(x);
+    return NX_PREFIX.test(x);
 }
 function getClientEnvironment(deployUrl) {
     return Object.keys(process.env)

package/src/utils/webpack/plugins/postcss-cli-resources.js

@@ -122,7 +122,7 @@ function PostcssCliResources(options) {
             const resourceCache = new Map();
             return Promise.all(urlDeclarations.map(async (decl) => {
                 const value = decl.value;
-                const urlRegex = /url(?:\(\s*(['"]?))(.*?)(?:\1\s*\))/g;
+                const urlRegex = /url\(\s*(?:"([^"]+)"|'([^']+)'|(.+?))\s*\)/g;
                 const segments = [];
                 let match;
                 let lastIndex = 0;
@@ -131,7 +131,7 @@ function PostcssCliResources(options) {
                 const inputFile = decl.source && decl.source.input.file;
                 const context = (inputFile && path.dirname(inputFile)) || loader.context;
                 while ((match = urlRegex.exec(value))) {
-                    const originalUrl = match[2];
+                    const originalUrl = match[1] || match[2] || match[3];
                     let processedUrl;
                     try {
                         processedUrl = await process(originalUrl, context, resourceCache);

package/src/utils/with-nx.d.ts

@@ -1,8 +1,62 @@
-import { NxComposableWebpackPlugin } from './config';
-import { NxWebpackPluginOptions } from '../plugins/nx-webpack-plugin/nx-webpack-plugin-options';
-export type WithNxOptions = Partial<NxWebpackPluginOptions>;
+import { NormalizedWebpackExecutorOptions } from '../executors/webpack/schema';
+import { NxWebpackPlugin } from './config';
+export interface WithNxOptions {
+    skipTypeChecking?: boolean;
+}
 /**
  * @param {WithNxOptions} pluginOptions
  * @returns {NxWebpackPlugin}
  */
-export declare function withNx(pluginOptions?: WithNxOptions): NxComposableWebpackPlugin;
+export declare function withNx(pluginOptions?: WithNxOptions): NxWebpackPlugin;
+export declare function createLoaderFromCompiler(options: NormalizedWebpackExecutorOptions): {
+    test: RegExp;
+    loader: string;
+    exclude: RegExp;
+    options: {
+        cwd: string;
+        emitDecoratorMetadata: boolean;
+        isModern: boolean;
+        isTest: boolean;
+        envName: string;
+        cacheDirectory: boolean;
+        cacheCompression: boolean;
+    };
+} | {
+    test: RegExp;
+    loader: string;
+    exclude: RegExp;
+    options: {
+        jsc: {
+            parser: {
+                syntax: string;
+                decorators: boolean;
+                tsx: boolean;
+            };
+            transform: {
+                react: {
+                    runtime: string;
+                };
+            };
+            loose: boolean;
+        };
+        configFile?: undefined;
+        transpileOnly?: undefined;
+        experimentalWatchApi?: undefined;
+        getCustomTransformers?: undefined;
+    };
+} | {
+    test: RegExp;
+    loader: string;
+    exclude: RegExp;
+    options: {
+        configFile: string;
+        transpileOnly: boolean;
+        experimentalWatchApi: boolean;
+        getCustomTransformers: (program: any) => {
+            before: any;
+            after: any;
+            afterDeclarations: any;
+        };
+        jsc?: undefined;
+    };
+};