@bleedingdev/modern-js-ultramodern-app-tools 0.0.0 → 3.9.0-ultramodern.6

package/src/native-composition/rsc-disabled-plugin.ts

@@ -0,0 +1,117 @@
+import type { RsbuildPlugin, Rspack } from '@rsbuild/core';
+
+const disabledRuntimeModules = {
+  'react-server-dom-rspack/client.browser': './rscDisabledClientBrowserRuntime',
+  'react-server-dom-rspack/client.edge': './rscDisabledClientEdgeRuntime',
+  'react-server-dom-rspack/client.node': './rscDisabledClientNodeRuntime',
+  'react-server-dom-rspack/server.edge': './rscDisabledServerEdgeRuntime',
+  'react-server-dom-rspack/server.node': './rscDisabledServerNodeRuntime',
+} as const;
+
+const disabledRuntimeRequests = Object.keys(disabledRuntimeModules);
+
+function aliasMatchesRequest(aliasName: string, request: string) {
+  const exact = aliasName.endsWith('$');
+  const normalizedName = exact ? aliasName.slice(0, -1) : aliasName;
+  return exact
+    ? normalizedName === request
+    : request === normalizedName || request.startsWith(`${normalizedName}/`);
+}
+
+function objectAliasMatchesDisabledRuntime(aliasName: string) {
+  return disabledRuntimeRequests.some(request =>
+    aliasMatchesRequest(aliasName, request),
+  );
+}
+
+function arrayAliasMatchesDisabledRuntime(alias: {
+  name: string;
+  onlyModule?: boolean;
+}) {
+  const aliasName = `${alias.name}${alias.onlyModule ? '$' : ''}`;
+  return objectAliasMatchesDisabledRuntime(aliasName);
+}
+
+function normalizeArrayAliases(
+  aliases: Array<{
+    alias: string | false | Array<string | false>;
+    name: string;
+    onlyModule?: boolean;
+  }>,
+) {
+  const normalized: Record<string, string | false | Array<string | false>> = {};
+  for (const alias of aliases) {
+    if (arrayAliasMatchesDisabledRuntime(alias)) {
+      continue;
+    }
+    const aliasName = `${alias.name}${alias.onlyModule ? '$' : ''}`;
+    const existing = normalized[aliasName];
+    if (existing === undefined) {
+      normalized[aliasName] = alias.alias;
+      continue;
+    }
+    normalized[aliasName] = [
+      ...(Array.isArray(existing) ? existing : [existing]),
+      ...(Array.isArray(alias.alias) ? alias.alias : [alias.alias]),
+    ];
+  }
+  return normalized;
+}
+
+function resolveDisabledRuntimeModules() {
+  return Object.fromEntries(
+    Object.entries(disabledRuntimeModules).map(([request, moduleRequest]) => [
+      `${request}$`,
+      require.resolve(
+        `@modern-js/runtime-extensions/rsc-disabled/${moduleRequest.slice(2)}`,
+      ),
+    ]),
+  );
+}
+
+function applyDisabledRuntimeAliases(
+  config: Rspack.Configuration,
+  disabledAliases: Record<string, string>,
+) {
+  config.resolve ??= {};
+  if (Array.isArray(config.resolve.alias)) {
+    config.resolve.alias = {
+      ...disabledAliases,
+      ...normalizeArrayAliases(config.resolve.alias),
+    };
+  } else {
+    config.resolve.alias = {
+      ...disabledAliases,
+      ...Object.fromEntries(
+        Object.entries(config.resolve.alias ?? {}).filter(
+          ([aliasName]) => !objectAliasMatchesDisabledRuntime(aliasName),
+        ),
+      ),
+    };
+  }
+}
+
+export function rscDisabledRuntimePlugin(): RsbuildPlugin {
+  return {
+    name: 'builder:rsc-disabled-runtime',
+
+    setup(api) {
+      const disabledAliases = resolveDisabledRuntimeModules();
+
+      api.modifyRspackConfig({
+        order: 'post',
+        handler(config) {
+          applyDisabledRuntimeAliases(config, disabledAliases);
+        },
+      });
+      api.onBeforeCreateCompiler({
+        order: 'post',
+        handler({ bundlerConfigs }) {
+          for (const config of bundlerConfigs) {
+            applyDisabledRuntimeAliases(config, disabledAliases);
+          }
+        },
+      });
+    },
+  };
+}

package/src/native-composition/server-plugin.ts

@@ -0,0 +1 @@
+export { default } from '@modern-js/server-runtime-extensions/server-plugin';

package/src/native-composition/ssr-integration-plugin.ts

@@ -0,0 +1,244 @@
+// @effect-diagnostics globalConsole:off processEnv:off strictBooleanExpressions:off
+import type {
+  AppTools,
+  AppToolsNormalizedConfig,
+  CliPlugin,
+  ServerUserConfig,
+} from '@modern-js/app-tools';
+import type { CLIPluginAPI } from '@modern-js/plugin';
+import type { MergedEnvironmentConfig, RsbuildPlugin } from '@rsbuild/core';
+
+type RsbuildRspackPluginLike =
+  | string
+  | ((...args: any[]) => any)
+  | {
+      name?: string;
+      constructor?: {
+        name?: string;
+      };
+    }
+  | [unknown, ...unknown[]];
+
+type EnvironmentConfigLike = Partial<
+  Pick<MergedEnvironmentConfig, 'output' | 'source' | 'tools'>
+>;
+
+const getRspackPlugins = (rspackConfig: unknown): RsbuildRspackPluginLike[] => {
+  if (!rspackConfig) {
+    return [];
+  }
+
+  const rspackEntries = Array.isArray(rspackConfig)
+    ? rspackConfig
+    : [rspackConfig];
+  const plugins: RsbuildRspackPluginLike[] = [];
+
+  for (const entry of rspackEntries) {
+    if (!entry || typeof entry === 'function' || typeof entry !== 'object') {
+      continue;
+    }
+
+    const maybePlugins = (entry as { plugins?: unknown }).plugins;
+
+    if (!Array.isArray(maybePlugins)) {
+      continue;
+    }
+
+    for (const plugin of maybePlugins) {
+      if (plugin) {
+        plugins.push(plugin as RsbuildRspackPluginLike);
+      }
+    }
+  }
+
+  return plugins;
+};
+
+const getRspackPluginName = (
+  plugin: RsbuildRspackPluginLike,
+): string | undefined => {
+  if (typeof plugin === 'string') {
+    return plugin;
+  }
+
+  if (typeof plugin === 'function') {
+    return plugin.name;
+  }
+
+  if (Array.isArray(plugin)) {
+    const [first] = plugin;
+
+    if (!first) {
+      return undefined;
+    }
+
+    if (typeof first === 'string') {
+      return first;
+    }
+
+    if (typeof first === 'function') {
+      return first.name;
+    }
+
+    if (typeof first === 'object') {
+      return (
+        (first as { name?: string }).name ||
+        (first as { constructor?: { name?: string } }).constructor?.name
+      );
+    }
+
+    return undefined;
+  }
+
+  return plugin.name || plugin.constructor?.name;
+};
+
+const hasServerRenderingConfig = (
+  userConfig: AppToolsNormalizedConfig,
+): boolean => {
+  const { output, server } = userConfig;
+
+  if (output?.ssg) {
+    return true;
+  }
+
+  if (output?.ssgByEntries && Object.keys(output.ssgByEntries).length > 0) {
+    return true;
+  }
+
+  if (server?.ssr) {
+    return true;
+  }
+
+  if (server?.ssrByEntries && Object.keys(server.ssrByEntries).length > 0) {
+    return true;
+  }
+
+  return false;
+};
+
+const isModuleFederationAppSSREnabledInConfig = (
+  ssr: ServerUserConfig['ssr'],
+): boolean => {
+  if (!ssr || typeof ssr !== 'object') {
+    return false;
+  }
+
+  return ssr.moduleFederationAppSSR === true;
+};
+
+const isModuleFederationAppSSREnabled = (
+  userConfig: AppToolsNormalizedConfig,
+): boolean => {
+  if (isModuleFederationAppSSREnabledInConfig(userConfig.server?.ssr)) {
+    return true;
+  }
+
+  if (
+    userConfig.server?.ssrByEntries &&
+    typeof userConfig.server.ssrByEntries === 'object'
+  ) {
+    return Object.values(userConfig.server.ssrByEntries).some(
+      isModuleFederationAppSSREnabledInConfig,
+    );
+  }
+
+  return false;
+};
+
+const isModuleFederationRspackPlugin = (
+  plugin: RsbuildRspackPluginLike,
+): boolean => {
+  const candidate = getRspackPluginName(plugin);
+
+  return typeof candidate === 'string' && /modulefederation/i.test(candidate);
+};
+
+const hasModuleFederationMarker = (config: EnvironmentConfigLike): boolean => {
+  if (process.env.MF_SSR_PRJ === 'true') {
+    return true;
+  }
+
+  const define = config.source?.define || {};
+
+  if ('REMOTE_IP_STRATEGY' in define || 'FEDERATION_IPV4' in define) {
+    return true;
+  }
+
+  const plugins = getRspackPlugins(config.tools?.rspack);
+
+  return plugins.some(isModuleFederationRspackPlugin);
+};
+
+const isNodeEnvironmentTarget = (target: unknown): boolean =>
+  typeof target === 'string' &&
+  (target === 'node' || target === 'async-node' || target.startsWith('node'));
+
+export const shouldUseModuleFederationNodeOutput = (
+  config: EnvironmentConfigLike,
+): boolean =>
+  isNodeEnvironmentTarget(config.output?.target) &&
+  hasModuleFederationMarker(config);
+
+const ssrIntegrationBuilderPlugin = (
+  modernAPI: CLIPluginAPI<AppTools>,
+): RsbuildPlugin => ({
+  name: '@modern-js/ultramodern-builder-plugin-ssr',
+  pre: ['@modern-js/builder-plugin-ssr'],
+  setup(api) {
+    api.modifyEnvironmentConfig((config, { name, mergeEnvironmentConfig }) => {
+      const isServerEnvironment =
+        isNodeEnvironmentTarget(config.output.target) || name === 'workerSSR';
+      const userConfig = modernAPI.getNormalizedConfig();
+      const hasServerRendering = hasServerRenderingConfig(userConfig);
+      const hasModuleFederationRuntimeMarker =
+        hasServerRendering && shouldUseModuleFederationNodeOutput(config);
+      const hasExplicitMfSsrFlag = isModuleFederationAppSSREnabled(userConfig);
+      const requireExplicitMfSsrFlag =
+        process.env.MODERN_MF_APP_SSR_REQUIRE_EXPLICIT === 'true';
+
+      if (
+        hasServerRendering &&
+        hasModuleFederationRuntimeMarker &&
+        !hasExplicitMfSsrFlag
+      ) {
+        const warningMessage =
+          '[modernjs][mf-ssr] Module Federation SSR was auto-detected from runtime markers. Set server.ssr.moduleFederationAppSSR=true explicitly in host and remotes to avoid heuristic drift.';
+        if (requireExplicitMfSsrFlag) {
+          throw new Error(
+            `${warningMessage} (enforced by MODERN_MF_APP_SSR_REQUIRE_EXPLICIT=true)`,
+          );
+        }
+        // eslint-disable-next-line no-console
+        console.warn(warningMessage);
+      }
+      const isModuleFederationAppSSR =
+        hasServerRendering && hasExplicitMfSsrFlag;
+      return mergeEnvironmentConfig(config, {
+        source: {
+          define: {
+            'process.env.MODERN_MF_APP_SSR': JSON.stringify(
+              String(isModuleFederationAppSSR),
+            ),
+          },
+        },
+        ...(name === 'workerSSR' && userConfig.deploy?.target === 'cloudflare'
+          ? { output: { module: true } }
+          : {}),
+        splitChunks:
+          isServerEnvironment &&
+          (hasModuleFederationRuntimeMarker || hasExplicitMfSsrFlag)
+            ? false
+            : undefined,
+      });
+    });
+  },
+});
+
+/** Apply fork SSR policy after native SSR defaults through Rsbuild hooks. */
+export const ultramodernSSRIntegrationPlugin = (): CliPlugin<AppTools> => ({
+  name: '@modern-js/ultramodern-ssr-integration',
+  setup(api) {
+    api.config(() => ({ builderPlugins: [ssrIntegrationBuilderPlugin(api)] }));
+  },
+});

package/src/native-composition/types.ts

@@ -0,0 +1,32 @@
+import type { AppUserConfig as NativeAppUserConfig } from '@modern-js/app-tools';
+import type { PrecompressConfig } from '@modern-js/app-tools-extensions/build-config/precompress/plugin';
+import type { CloudflareDeployConfig } from '@modern-js/app-tools-extensions/config';
+import type {
+  BffRuntimeUserConfig,
+  ServerTelemetryUserConfig,
+} from '@modern-js/runtime-extensions/server-config';
+
+type NativeServerConfig = NonNullable<NativeAppUserConfig['server']>;
+type NativeSSRConfig = Exclude<NativeServerConfig['ssr'], boolean | undefined>;
+
+/** Native Modern.js configuration with the fork's explicitly owned options. */
+export type UltramodernAppUserConfig = Omit<
+  NativeAppUserConfig,
+  'output' | 'server' | 'bff' | 'deploy'
+> & {
+  output?: Omit<NonNullable<NativeAppUserConfig['output']>, 'precompress'> & {
+    precompress?: boolean | PrecompressConfig;
+  };
+  server?: Omit<NativeServerConfig, 'ssr' | 'telemetry'> & {
+    ssr?: boolean | (NativeSSRConfig & { moduleFederationAppSSR?: boolean });
+    telemetry?: ServerTelemetryUserConfig;
+  };
+  bff?: Omit<
+    NonNullable<NativeAppUserConfig['bff']>,
+    keyof BffRuntimeUserConfig
+  > &
+    BffRuntimeUserConfig & { requestId?: string };
+  deploy?: NonNullable<NativeAppUserConfig['deploy']> & CloudflareDeployConfig;
+};
+
+export type AppUserConfig = UltramodernAppUserConfig;

package/README.md

@@ -1,3 +0,0 @@
-# @bleedingdev/modern-js-ultramodern-app-tools
-
-This 0.0.0 version only registers the package name so npm trusted publishing can be configured. It contains no runtime implementation. Use the subsequent UltraModern.js release, published from the repository workflow with provenance.