@bleedingdev/modern-js-app-tools 3.2.0-ultramodern.0

package/dist/cjs/utils/register.js

@@ -0,0 +1,128 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module1)=>{
+        var getter = module1 && module1.__esModule ? ()=>module1['default'] : ()=>module1;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    resolveTsRuntimeRegisterMode: ()=>resolveTsRuntimeRegisterMode,
+    setupTsRuntime: ()=>setupTsRuntime
+});
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const utils_namespaceObject = require("@modern-js/utils");
+const normalizePathValue = ({ key, value, absoluteBaseUrl })=>{
+    let normalizedValue = value;
+    if (key.startsWith('@') && normalizedValue.startsWith('@')) try {
+        normalizedValue = require.resolve(normalizedValue, {
+            paths: [
+                process.cwd(),
+                ...module.paths
+            ]
+        });
+    } catch  {}
+    return external_node_path_default().isAbsolute(normalizedValue) ? external_node_path_default().relative(absoluteBaseUrl, normalizedValue) : normalizedValue;
+};
+const normalizePathValues = ({ key, value, absoluteBaseUrl })=>{
+    const values = Array.isArray(value) ? value : [
+        value
+    ];
+    return values.map((item)=>normalizePathValue({
+            key,
+            value: item,
+            absoluteBaseUrl
+        }));
+};
+const addResolvedAlias = (paths, key, values)=>{
+    if (!key || paths[key]) return;
+    paths[key] = values;
+};
+const createRuntimePaths = ({ alias, paths, absoluteBaseUrl })=>{
+    const mergedAlias = (0, utils_namespaceObject.mergeAlias)(alias);
+    const normalizedPaths = Object.keys(paths).reduce((result, key)=>{
+        addResolvedAlias(result, key.endsWith('$') ? key.slice(0, -1) : key, normalizePathValues({
+            key,
+            value: paths[key],
+            absoluteBaseUrl
+        }));
+        return result;
+    }, {});
+    Object.keys(mergedAlias).forEach((key)=>{
+        if (key.includes('*') || key.endsWith('$')) return;
+        addResolvedAlias(normalizedPaths, `${key}/*`, normalizePathValues({
+            key,
+            value: mergedAlias[key],
+            absoluteBaseUrl
+        }).map((value)=>`${value}/*`));
+    });
+    return normalizedPaths;
+};
+const resolveTsRuntimeRegisterMode = ()=>{
+    const hasNativeTypeScriptSupport = process.features?.typescript;
+    const nodeMajorVersion = Number(process.versions.node.split('.')[0]);
+    const supportsNativeTypeScript = void 0 === hasNativeTypeScriptSupport ? nodeMajorVersion >= 22 : false !== hasNativeTypeScriptSupport;
+    if (supportsNativeTypeScript) return 'node-loader';
+    return 'unsupported';
+};
+const setupTsRuntime = async (appDir, distDir, alias, options = {})=>{
+    const tsconfigPath = (0, utils_namespaceObject.resolveServerTsconfig)(appDir, options.tsconfigPath);
+    const isTsProject = await utils_namespaceObject.fs.pathExists(tsconfigPath);
+    if (!isTsProject) return;
+    const registerMode = resolveTsRuntimeRegisterMode();
+    const aliasConfig = (0, utils_namespaceObject.getAliasConfig)(alias, {
+        appDirectory: appDir,
+        tsconfigPath
+    });
+    const { paths = {}, absoluteBaseUrl = './' } = aliasConfig;
+    const runtimePaths = createRuntimePaths({
+        alias,
+        paths,
+        absoluteBaseUrl
+    });
+    if ('unsupported' === registerMode) return;
+    if ('node-loader' === registerMode) {
+        const { registerPathsLoader } = await import("../esm/register-esm.js");
+        await registerPathsLoader({
+            appDir,
+            baseUrl: absoluteBaseUrl || './',
+            paths: runtimePaths
+        });
+    }
+};
+exports.resolveTsRuntimeRegisterMode = __webpack_exports__.resolveTsRuntimeRegisterMode;
+exports.setupTsRuntime = __webpack_exports__.setupTsRuntime;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "resolveTsRuntimeRegisterMode",
+    "setupTsRuntime"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/utils/restart.js

@@ -0,0 +1,52 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    restart: ()=>restart
+});
+const cli_namespaceObject = require("@modern-js/plugin/cli");
+const utils_namespaceObject = require("@modern-js/utils");
+const commander_namespaceObject = require("@modern-js/utils/commander");
+async function restart(hooks, filename) {
+    (0, utils_namespaceObject.clearConsole)();
+    utils_namespaceObject.logger.info(`Restart because ${utils_namespaceObject.chalk.yellow(filename)} is changed...\n`);
+    let hasGetError = false;
+    await hooks.onBeforeRestart.call();
+    try {
+        await cli_namespaceObject.cli.init(cli_namespaceObject.cli.getPrevInitOptions());
+    } catch (err) {
+        console.error(err);
+        hasGetError = true;
+    } finally{
+        if (!hasGetError) commander_namespaceObject.program.parse((0, utils_namespaceObject.getFullArgv)());
+    }
+}
+exports.restart = __webpack_exports__.restart;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "restart"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/utils/routes.js

@@ -0,0 +1,65 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    generateRoutes: ()=>generateRoutes,
+    getPathWithoutExt: ()=>getPathWithoutExt,
+    isMainEntry: ()=>isMainEntry
+});
+const utils_namespaceObject = require("@modern-js/utils");
+const external_path_namespaceObject = require("path");
+var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
+const generateRoutes = async (appContext)=>{
+    const { serverRoutes, distDirectory } = appContext;
+    const output = JSON.stringify({
+        routes: serverRoutes
+    }, null, 2);
+    await utils_namespaceObject.fs.outputFile(external_path_default().join(distDirectory, utils_namespaceObject.ROUTE_SPEC_FILE), output);
+};
+const getPathWithoutExt = (filename)=>{
+    const extname = external_path_default().extname(filename);
+    return filename.slice(0, -extname.length);
+};
+const isMainEntry = (entryName, mainEntryName)=>entryName === (mainEntryName || utils_namespaceObject.MAIN_ENTRY_NAME);
+exports.generateRoutes = __webpack_exports__.generateRoutes;
+exports.getPathWithoutExt = __webpack_exports__.getPathWithoutExt;
+exports.isMainEntry = __webpack_exports__.isMainEntry;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "generateRoutes",
+    "getPathWithoutExt",
+    "isMainEntry"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/utils/types.js

@@ -0,0 +1,18 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/esm/baseline.mjs

@@ -0,0 +1,46 @@
+import { mergeConfig } from "@modern-js/plugin/cli";
+const createAppBaselineConfig = (options = {})=>{
+    const { appId = 'app', enableBffRequestId = true, enableTelemetry = true, enableTelemetryExporters = true, otlpEndpoint = process.env.MODERN_TELEMETRY_OTLP_ENDPOINT || 'http://127.0.0.1:4318/v1/logs', victoriaMetricsEndpoint = process.env.MODERN_TELEMETRY_VICTORIA_ENDPOINT || 'http://127.0.0.1:8428/api/v1/import/prometheus', telemetryFailLoudStartup = true, enableModuleFederationSSR = true } = options;
+    const server = {};
+    if (enableTelemetry) {
+        server.telemetry = {
+            enabled: true,
+            failLoudStartup: telemetryFailLoudStartup
+        };
+        if (enableTelemetryExporters) server.telemetry.exporters = {
+            otlp: {
+                enabled: true,
+                endpoint: otlpEndpoint
+            },
+            victoriaMetrics: {
+                enabled: true,
+                endpoint: victoriaMetricsEndpoint
+            }
+        };
+    }
+    if (enableModuleFederationSSR) server.ssr = {
+        mode: 'stream',
+        moduleFederationAppSSR: true
+    };
+    const baselineConfig = {
+        output: {
+            precompress: true
+        },
+        performance: {
+            rsdoctor: {
+                enabled: 'production' === process.env.NODE_ENV,
+                disableClientServer: true
+            }
+        },
+        server
+    };
+    if (enableBffRequestId) baselineConfig.bff = {
+        requestId: appId
+    };
+    return baselineConfig;
+};
+const withAppBaseline = (config, options = {})=>mergeConfig([
+        createAppBaselineConfig(options),
+        config
+    ]);
+export { createAppBaselineConfig, withAppBaseline };

package/dist/esm/builder/builder-rspack/index.mjs

@@ -0,0 +1,6 @@
+import { generateBuilder } from "../generator/index.mjs";
+async function createRspackBuilderForModern(options) {
+    const builder = await generateBuilder(options, 'rspack');
+    return builder;
+}
+export { createRspackBuilderForModern };

package/dist/esm/builder/generator/adapterCopy.mjs

@@ -0,0 +1,35 @@
+import path from "path";
+import { createCopyInfo } from "../shared/index.mjs";
+import { createPublicPattern } from "./createCopyPattern.mjs";
+const builderPluginAdapterCopy = (options)=>({
+        name: 'builder-plugin-adapter-copy',
+        setup (api) {
+            const { normalizedConfig: modernConfig, appContext } = options;
+            api.modifyBundlerChain((chain, { CHAIN_ID })=>{
+                if (chain.plugins.has(CHAIN_ID.PLUGIN.COPY)) {
+                    const defaultCopyPattern = createPublicPattern(appContext, modernConfig, chain);
+                    const { customPublicDirs } = createCopyInfo(appContext, modernConfig);
+                    const customCopyPatterns = customPublicDirs.map((customPublicDir)=>{
+                        const relativePath = path.relative(appContext.appDirectory, customPublicDir);
+                        const outputDir = relativePath || path.basename(customPublicDir);
+                        return {
+                            from: '**/*',
+                            to: outputDir,
+                            context: customPublicDir,
+                            noErrorOnMissing: true
+                        };
+                    });
+                    chain.plugin(CHAIN_ID.PLUGIN.COPY).tap((args)=>[
+                            {
+                                patterns: [
+                                    ...args[0]?.patterns || [],
+                                    defaultCopyPattern,
+                                    ...customCopyPatterns
+                                ]
+                            }
+                        ]);
+                }
+            });
+        }
+    });
+export { builderPluginAdapterCopy };

package/dist/esm/builder/generator/createBuilderProviderConfig.mjs

@@ -0,0 +1,66 @@
+import { DEFAULT_API_PREFIX } from "@modern-js/utils";
+import { createUploadPattern } from "./createCopyPattern.mjs";
+function modifyOutputConfig(config, appContext) {
+    const defaultCopyPattern = createUploadPattern(appContext, config);
+    const { copy } = config.output;
+    const copyOptions = Array.isArray(copy) ? copy : copy?.patterns;
+    const builderCopy = [
+        ...copyOptions || [],
+        defaultCopyPattern
+    ];
+    config.output = {
+        ...config.output,
+        copy: builderCopy
+    };
+}
+function createBuilderProviderConfig(resolveConfig, appContext) {
+    const htmlConfig = {
+        ...resolveConfig.html
+    };
+    if (!htmlConfig.template) htmlConfig.template = ({ entryName })=>appContext.htmlTemplates[entryName];
+    const serverConfig = {
+        ...resolveConfig.server
+    };
+    if (resolveConfig.dev?.server?.cors !== void 0) serverConfig.cors = resolveConfig.dev?.server?.cors;
+    const config = {
+        ...resolveConfig,
+        plugins: [],
+        resolve: {
+            ...resolveConfig.resolve
+        },
+        source: {
+            ...resolveConfig.source
+        },
+        dev: {
+            ...resolveConfig.dev,
+            port: appContext.port
+        },
+        server: serverConfig,
+        html: htmlConfig,
+        output: {
+            ...resolveConfig.output,
+            cleanDistPath: false
+        },
+        tools: {
+            ...resolveConfig.tools,
+            devServer: {
+                ...resolveConfig.tools?.devServer,
+                compress: {
+                    filter: (req)=>{
+                        const bffPrefix = resolveConfig.bff?.prefix || DEFAULT_API_PREFIX;
+                        const bffPrefixes = Array.isArray(bffPrefix) ? bffPrefix : [
+                            bffPrefix
+                        ];
+                        const url = req.url;
+                        if (bffPrefixes.some((prefix)=>url?.startsWith(prefix))) return false;
+                        return true;
+                    }
+                }
+            }
+        }
+    };
+    if (config.source?.enableAsyncEntry && config.source?.enableAsyncPreEntry) delete config.source.preEntry;
+    modifyOutputConfig(config, appContext);
+    return config;
+}
+export { createBuilderProviderConfig };

package/dist/esm/builder/generator/createCopyPattern.mjs

@@ -0,0 +1,30 @@
+import { removeTailSlash } from "@modern-js/utils";
+import { createCopyInfo } from "../shared/index.mjs";
+const minifiedJsRexExp = /\.min\.js/;
+const info = (file)=>({
+        minimized: minifiedJsRexExp.test(file.sourceFilename)
+    });
+function createPublicPattern(appContext, config, chain) {
+    const { publicDir } = createCopyInfo(appContext, config);
+    return {
+        info: info,
+        from: '**/*',
+        to: 'public',
+        context: publicDir,
+        noErrorOnMissing: true,
+        transform: (content, absoluteFrom)=>{
+            if (!/\.html?$/.test(absoluteFrom)) return content;
+            return content.toString('utf8').replace(/<%=\s*assetPrefix\s*%>/g, removeTailSlash(chain.output.get('publicPath')));
+        }
+    };
+}
+function createUploadPattern(appContext, config) {
+    const { uploadDir } = createCopyInfo(appContext, config);
+    return {
+        from: '**/*',
+        to: 'upload',
+        context: uploadDir,
+        noErrorOnMissing: true
+    };
+}
+export { createPublicPattern, createUploadPattern };

package/dist/esm/builder/generator/getBuilderEnvironments.mjs

@@ -0,0 +1,56 @@
+import { SERVICE_WORKER_ENVIRONMENT_NAME } from "@modern-js/builder";
+import { isProd, isSSR, isServiceWorker, isUseRsc, isUseSSRBundle } from "@modern-js/utils";
+function getBuilderEnvironments(normalizedConfig, appContext, tempBuilderConfig) {
+    const entries = {};
+    const { entrypoints = [], checkedEntries } = appContext;
+    for (const { entryName, internalEntry, entry } of entrypoints){
+        if (checkedEntries && !checkedEntries.includes(entryName)) continue;
+        const finalEntry = internalEntry || entry;
+        if (entryName in entries) entries[entryName].push(finalEntry);
+        else entries[entryName] = [
+            finalEntry
+        ];
+    }
+    const serverEntries = {};
+    for(const entry in entries){
+        const v = entries[entry];
+        serverEntries[entry] = v.map((entry)=>entry.replace('index.jsx', 'index.server.jsx')).map((entry)=>entry.replace('bootstrap.jsx', 'bootstrap.server.jsx'));
+    }
+    const environments = {
+        client: {
+            output: {
+                target: 'web'
+            },
+            source: {
+                entry: entries
+            }
+        }
+    };
+    if (tempBuilderConfig.output?.copy) {
+        environments.client.output.copy = tempBuilderConfig.output.copy;
+        delete tempBuilderConfig.output.copy;
+    }
+    const useNodeTarget = isUseRsc(normalizedConfig) || (isProd() ? isUseSSRBundle(normalizedConfig) : isSSR(normalizedConfig));
+    if (useNodeTarget) environments.server = {
+        output: {
+            target: 'node'
+        },
+        source: {
+            entry: serverEntries
+        }
+    };
+    const useWorkerTarget = isServiceWorker(normalizedConfig);
+    if (useWorkerTarget) environments[SERVICE_WORKER_ENVIRONMENT_NAME] = {
+        output: {
+            target: 'web-worker'
+        },
+        source: {
+            entry: serverEntries
+        }
+    };
+    return {
+        environments,
+        builderConfig: tempBuilderConfig
+    };
+}
+export { getBuilderEnvironments };

package/dist/esm/builder/generator/index.mjs

@@ -0,0 +1,46 @@
+import { createBuilder } from "@modern-js/builder";
+import { mergeRsbuildConfig } from "@rsbuild/core";
+import { builderPluginAdapterBasic, builderPluginAdapterHooks, builderPluginAdapterHtml, builderPluginAdapterPrecompress, builderPluginAdapterSSR } from "../shared/builderPlugins/index.mjs";
+import { builderPluginAdapterCopy } from "./adapterCopy.mjs";
+import { createBuilderProviderConfig } from "./createBuilderProviderConfig.mjs";
+import { getBuilderEnvironments } from "./getBuilderEnvironments.mjs";
+async function generateBuilder(options, bundlerType) {
+    const { normalizedConfig, appContext } = options;
+    const tempBuilderConfig = createBuilderProviderConfig(normalizedConfig, appContext);
+    const { environments, builderConfig } = getBuilderEnvironments(normalizedConfig, appContext, tempBuilderConfig);
+    if (builderConfig.environments) {
+        const mergedEnvironments = {
+            ...environments
+        };
+        for(const name in builderConfig.environments)if (environments[name]) mergedEnvironments[name] = mergeRsbuildConfig(environments[name], builderConfig.environments[name]);
+        else mergedEnvironments[name] = builderConfig.environments[name];
+        builderConfig.environments = mergedEnvironments;
+    } else builderConfig.environments = environments;
+    const builder = await createBuilder({
+        cwd: appContext.appDirectory,
+        rscClientRuntimePath: `@${appContext.metaName}/runtime/rsc/client`,
+        rscServerRuntimePath: `@${appContext.metaName}/runtime/rsc/server`,
+        internalDirectory: appContext.internalDirectory,
+        frameworkConfigPath: appContext.configFile || void 0,
+        bundlerType,
+        config: builderConfig
+    });
+    await applyBuilderPlugins(builder, options);
+    return builder;
+}
+async function applyBuilderPlugins(builder, options) {
+    builder.addPlugins([
+        builderPluginAdapterBasic(options),
+        builderPluginAdapterSSR(options),
+        builderPluginAdapterHtml(options),
+        builderPluginAdapterPrecompress(options),
+        builderPluginAdapterHooks(options)
+    ]);
+    builder.addPlugins([
+        builderPluginAdapterCopy(options)
+    ], {
+        environment: 'client'
+    });
+    const { normalizedConfig } = options;
+}
+export { generateBuilder };

package/dist/esm/builder/index.mjs

@@ -0,0 +1,7 @@
+async function createBuilderGenerator() {
+    const { createRspackBuilderForModern } = await import("./builder-rspack/index.mjs");
+    return createRspackBuilderForModern;
+}
+export { parseRspackConfig } from "@modern-js/builder";
+export { builderPluginAdapterBasic, builderPluginAdapterHooks } from "./shared/builderPlugins/index.mjs";
+export { createBuilderGenerator };

package/dist/esm/builder/shared/builderPlugins/adapterBasic.mjs

@@ -0,0 +1,89 @@
+import node_path from "node:path";
+import { SERVICE_WORKER_ENVIRONMENT_NAME } from "@modern-js/builder";
+const builderPluginAdapterBasic = (options)=>({
+        name: 'builder-plugin-adapter-modern-basic',
+        setup (api) {
+            api.modifyBundlerChain((chain, { target, CHAIN_ID, environment })=>{
+                const isServiceWorker = environment.name === SERVICE_WORKER_ENVIRONMENT_NAME;
+                if ('node' === target || isServiceWorker) applyNodeCompat(isServiceWorker, chain);
+                if ('web' === target) {
+                    const bareServerModuleReg = /\.(server|node)\.[tj]sx?$/;
+                    const depExt = 'mjs';
+                    chain.module.rule(CHAIN_ID.RULE.JS).exclude.add(bareServerModuleReg);
+                    chain.module.rule('bare-server-module').test(bareServerModuleReg).use('server-module-loader').loader(node_path.join(__dirname, `../loaders/serverModuleLoader.${depExt}`));
+                }
+                const { appContext } = options;
+                const { metaName } = appContext;
+                chain.watchOptions({
+                    ignored: [
+                        `[\\\\/](?:node_modules(?![\\\\/]\\.${metaName})|.git)[\\\\/]`
+                    ]
+                });
+            });
+            api.modifyRspackConfig((config, { target, environment })=>{
+                const isServiceWorker = environment.name === SERVICE_WORKER_ENVIRONMENT_NAME;
+                if ('node' === target || isServiceWorker) {
+                    const extensionAlias = {
+                        '.js': [
+                            '.node.js',
+                            '.server.js',
+                            '.js'
+                        ],
+                        '.jsx': [
+                            '.node.jsx',
+                            '.server.jsx',
+                            '.jsx'
+                        ],
+                        '.ts': [
+                            '.node.ts',
+                            '.server.ts',
+                            '.ts'
+                        ],
+                        '.tsx': [
+                            '.node.tsx',
+                            '.server.tsx',
+                            '.tsx'
+                        ],
+                        '.mjs': [
+                            '.node.mjs',
+                            '.server.mjs',
+                            '.mjs'
+                        ],
+                        '.json': [
+                            '.node.json',
+                            '.server.json',
+                            '.json'
+                        ]
+                    };
+                    config.resolve ??= {};
+                    config.resolve.extensionAlias = {
+                        ...config.resolve.extensionAlias,
+                        ...extensionAlias
+                    };
+                }
+            });
+        }
+    });
+function applyNodeCompat(isServiceWorker, chain) {
+    const nodeExts = [
+        '.node.js',
+        '.node.jsx',
+        '.node.ts',
+        '.node.tsx',
+        '.node.mjs',
+        '.server.js',
+        '.server.jsx',
+        '.server.ts',
+        '.server.tsx',
+        '.server.mjs'
+    ];
+    const webWorkerExts = [
+        '.worker.js',
+        '.worker.jsx',
+        '.worker.ts',
+        '.worker.tsx'
+    ];
+    for (const ext of nodeExts)chain.resolve.extensions.prepend(ext);
+    if (isServiceWorker) for (const ext of webWorkerExts)chain.resolve.extensions.prepend(ext);
+}
+export { builderPluginAdapterBasic };