@bleedingdev/modern-js-app-tools-extensions 3.9.0-ultramodern.2 → 3.9.0-ultramodern.21

package/src/deploy-output/target.ts

@@ -0,0 +1,106 @@
+import { getArgv } from '@modern-js/utils';
+import { provider as detectedProvider } from 'std-env';
+
+export const DEPLOY_TARGETS = [
+  'node',
+  'vercel',
+  'netlify',
+  'ghPages',
+  'cloudflare',
+] as const;
+
+export type DeployTarget = (typeof DEPLOY_TARGETS)[number];
+
+export const DEPLOY_TARGET_FLAG = '--deploy-target';
+
+const providerDeployTargets: Partial<Record<string, DeployTarget>> = {
+  vercel: 'vercel',
+  netlify: 'netlify',
+  cloudflare: 'cloudflare',
+  cloudflare_pages: 'cloudflare',
+  cloudflare_workers: 'cloudflare',
+};
+
+export interface ResolvedDeployTarget {
+  target: DeployTarget;
+  /** The flag, `deploy.target` or `MODERNJS_DEPLOY` chose the target. */
+  explicit: boolean;
+}
+
+export interface ResolveDeployTargetOptions {
+  argv?: readonly string[];
+  configTarget?: string;
+  env?: string;
+  provider?: string;
+}
+
+const readDeployTargetFlag = (argv: readonly string[]) => {
+  for (const [index, arg] of argv.entries()) {
+    if (arg === DEPLOY_TARGET_FLAG) {
+      const value = argv[index + 1];
+      if (value === undefined || value.startsWith('-')) {
+        throw new Error(`${DEPLOY_TARGET_FLAG} needs a value.`);
+      }
+      return value;
+    }
+    if (arg.startsWith(`${DEPLOY_TARGET_FLAG}=`)) {
+      return arg.slice(DEPLOY_TARGET_FLAG.length + 1);
+    }
+  }
+  return undefined;
+};
+
+const assertDeployTarget = (target: string, source: string): DeployTarget => {
+  if (!(DEPLOY_TARGETS as readonly string[]).includes(target)) {
+    throw new Error(
+      `Unknown deploy target '${target}' from ${source}. Use one of: ${DEPLOY_TARGETS.join(', ')}.`,
+    );
+  }
+  return target as DeployTarget;
+};
+
+/**
+ * The one deploy-target resolver: `--deploy-target` > `deploy.target` >
+ * `MODERNJS_DEPLOY` > detected CI provider > `node`. app-tools stores the
+ * result in the app context once; config files that branch on the target call
+ * it without `configTarget`.
+ */
+export const resolveDeployTarget = ({
+  argv = getArgv(),
+  configTarget,
+  env = process.env.MODERNJS_DEPLOY,
+  provider = detectedProvider,
+}: ResolveDeployTargetOptions = {}): ResolvedDeployTarget => {
+  const explicit = (
+    [
+      [readDeployTargetFlag(argv), DEPLOY_TARGET_FLAG],
+      [configTarget, 'deploy.target'],
+      [env, 'MODERNJS_DEPLOY'],
+    ] as const
+  ).find(([target]) => target);
+  if (explicit?.[0]) {
+    return {
+      target: assertDeployTarget(explicit[0], explicit[1]),
+      explicit: true,
+    };
+  }
+  return {
+    target: (provider && providerDeployTargets[provider]) || 'node',
+    explicit: false,
+  };
+};
+
+/**
+ * The target `modern deploy` stages. Apps under another CLI meta name deploy
+ * only when a flag, config or env chose the target explicitly.
+ */
+export const getDeployingTarget = ({
+  deployTarget,
+  metaName,
+}: {
+  deployTarget?: ResolvedDeployTarget;
+  metaName: string;
+}): DeployTarget | undefined =>
+  deployTarget && (metaName === 'modern-js' || deployTarget.explicit)
+    ? deployTarget.target
+    : undefined;

package/src/deploy-output/trace-files.ts

@@ -0,0 +1,67 @@
+import os from 'node:os';
+import path from 'node:path';
+import { type NodeFileTraceResult, nodeFileTrace } from '@vercel/nft';
+
+// Directories owned by the build host rather than the app. nft statically
+// evaluates `os.homedir()`, `os.tmpdir()` and literal system paths, so code
+// like `fs.readFileSync(path.join(os.homedir(), name))` becomes a glob of the
+// whole home directory. With `base: '/'` that glob walks the machine.
+const SYSTEM_ROOTS =
+  process.platform === 'win32'
+    ? []
+    : ['/dev', '/etc', '/proc', '/run', '/sys', '/var/run'];
+
+const GLOB_SEGMENT = /[*?[{]/;
+
+const isInside = (parent: string, child: string) =>
+  child === parent || child.startsWith(`${parent}${path.sep}`);
+
+const globRoot = (absolutePattern: string) => {
+  const { root } = path.parse(absolutePattern);
+  const segments = absolutePattern.slice(root.length).split(path.sep);
+  const index = segments.findIndex(segment => GLOB_SEGMENT.test(segment));
+  return index === -1
+    ? undefined
+    : path.join(root, ...segments.slice(0, index));
+};
+
+/**
+ * Builds the nft `ignore` predicate for a trace rooted at `base`: skip every
+ * path under a system root, and skip globs that would enumerate the file
+ * system root, the home directory or the temp directory as a whole. Files
+ * inside home or temp are still traced, since package stores can live there.
+ */
+export const createBuildHostIgnore = (base: string) => {
+  const wholeDirectories = new Set([
+    path.parse(path.resolve(base)).root,
+    path.resolve(os.homedir()),
+    path.resolve(os.tmpdir()),
+  ]);
+  return (relativePath: string) => {
+    const absolutePath = path.resolve(base, relativePath);
+    if (SYSTEM_ROOTS.some(root => isInside(root, absolutePath))) {
+      return true;
+    }
+    const root = globRoot(absolutePath);
+    return root !== undefined && wholeDirectories.has(root);
+  };
+};
+
+/**
+ * `traceFiles` implementation for ndepe's `nodeDepEmit`, tracing with the
+ * `@vercel/nft` release app-tools-extensions depends on instead of the one ndepe pins.
+ */
+export const traceDeployFiles = ({
+  entryFiles,
+  sourceDir,
+  base = '/',
+}: {
+  entryFiles: string[];
+  sourceDir: string;
+  base?: string;
+}): Promise<NodeFileTraceResult> =>
+  nodeFileTrace(entryFiles, {
+    base,
+    processCwd: sourceDir,
+    ignore: createBuildHostIgnore(base),
+  });

package/src/native-type-checker.ts

@@ -0,0 +1,183 @@
+import { execFile } from 'node:child_process';
+import { existsSync, realpathSync } from 'node:fs';
+import path from 'node:path';
+import { promisify } from 'node:util';
+import { refreshTsgoCheckerConfig } from '@modern-js/builder';
+import type { Rspack, RspackChain } from '@rsbuild/core';
+
+const execute = promisify(execFile);
+const name = 'UltramodernNativeTypeChecker';
+
+// Windows file events expand 8.3 aliases; register the same native path spelling.
+// A path that does not exist yet (a project tsconfig mid-edit) cannot be
+// realpathed; it is registered as spelled so its return still triggers a build.
+const watchDependencyPath = (file: string): string => {
+  if (process.platform !== 'win32') return file;
+  try {
+    return realpathSync.native(file);
+  } catch {
+    return file;
+  }
+};
+
+export class UltramodernNativeTypeChecker {
+  constructor(
+    private readonly options: {
+      compiler: () => string;
+      configFile: string;
+      build: boolean;
+    },
+  ) {}
+
+  async check(): Promise<void> {
+    const { configFile, build } = this.options;
+    if (!build) {
+      const config = JSON.parse(
+        await this.run(['--showConfig', '--project', configFile]),
+      ) as { references?: { path: string }[] };
+      // Project mode consumes referenced declarations but never builds them.
+      // Prepare only the references using their own emit contracts, then keep
+      // the app itself in no-emit mode. This also refreshes stale declarations.
+      if (config.references?.length) {
+        await this.run([
+          '--build',
+          ...config.references.map(reference =>
+            path.resolve(path.dirname(configFile), reference.path),
+          ),
+          '--stopBuildOnErrors',
+          '--pretty',
+          'false',
+        ]);
+      }
+    }
+    const args = build
+      ? ['--build', configFile, '--stopBuildOnErrors']
+      : ['--project', configFile, '--noEmit'];
+    await this.run([...args, '--pretty', 'false']);
+  }
+
+  private async run(args: string[]): Promise<string> {
+    try {
+      const result = await execute(this.options.compiler(), args, {
+        cwd: path.dirname(this.options.configFile),
+        maxBuffer: 16 * 1024 * 1024,
+      });
+      return result.stdout;
+    } catch (cause) {
+      const output = cause as { stdout?: string; stderr?: string };
+      const diagnostics = `${output.stdout ?? ''}${output.stderr ?? ''}`;
+      throw new Error(
+        `${name} failed:\n${diagnostics || (cause instanceof Error ? cause.message : String(cause))}`,
+        { cause },
+      );
+    }
+  }
+
+  private async watchInputs(): Promise<{
+    inputs: Set<string>;
+    missing: Set<string>;
+  }> {
+    const inputs = new Set<string>();
+    const missing = new Set<string>();
+    const projects = [this.options.configFile];
+    const visited = new Set<string>();
+    for (const configFile of projects) {
+      if (visited.has(configFile)) continue;
+      visited.add(configFile);
+      // Registered before it is parsed: a referenced config that is absent or
+      // unparsable right now must still be watched, or creating or repairing
+      // it never re-triggers the compilation. `check()` reports the error.
+      inputs.add(configFile);
+      if (!existsSync(configFile)) {
+        missing.add(configFile);
+        continue;
+      }
+      let config: { files?: string[]; references?: { path: string }[] };
+      try {
+        config = JSON.parse(
+          await this.run(['--showConfig', '--project', configFile]),
+        );
+      } catch {
+        continue;
+      }
+      const directory = path.dirname(configFile);
+      for (const file of config.files ?? [])
+        inputs.add(path.resolve(directory, file));
+      for (const reference of config.references ?? []) {
+        const target = path.resolve(directory, reference.path);
+        projects.push(
+          path.extname(target) === '.json'
+            ? target
+            : path.join(target, 'tsconfig.json'),
+        );
+      }
+    }
+    return { inputs, missing };
+  }
+
+  apply(compiler: Rspack.Compiler): void {
+    compiler.hooks.thisCompilation.tap(name, compilation => {
+      compilation.hooks.processAssets.tapPromise(name, async () => {
+        try {
+          compilation.fileDependencies.add(
+            watchDependencyPath(this.options.configFile),
+          );
+          // A generated checker config restates values TypeScript does not
+          // inherit through `extends` (project references above all). Rebuild
+          // it from the project's own tsconfig before every check, and watch
+          // that tsconfig, so an edit during `modern dev` reaches the next
+          // compilation instead of the next restart.
+          const projectConfigFile = refreshTsgoCheckerConfig(
+            this.options.configFile,
+          );
+          if (projectConfigFile) {
+            const watched = watchDependencyPath(projectConfigFile);
+            compilation.fileDependencies.add(watched);
+            // Absent mid-edit: a missing dependency makes its (re)appearance
+            // a rebuild trigger, so the dev server recovers on its own.
+            if (!existsSync(projectConfigFile)) {
+              compilation.missingDependencies.add(watched);
+            }
+          }
+          const { inputs, missing } = await this.watchInputs();
+          for (const file of inputs)
+            compilation.fileDependencies.add(watchDependencyPath(file));
+          for (const file of missing)
+            compilation.missingDependencies.add(watchDependencyPath(file));
+          await this.check();
+        } catch (cause) {
+          compilation.errors.push(
+            new Error(cause instanceof Error ? cause.message : String(cause), {
+              cause,
+            }),
+          );
+        }
+      });
+    });
+  }
+}
+
+/** Preserve project-reference emit contracts in the native Effect compiler. */
+export function configureUltramodernTypeChecker(
+  chain: RspackChain,
+  pluginId: string,
+  resolveCompiler: (configFile: string) => string,
+): void {
+  if (!chain.plugins.has(pluginId)) return;
+  const options = chain.plugin(pluginId).get('args')?.[0] as
+    | { typescript?: { configFile?: string; build?: boolean; tsgo?: boolean } }
+    | undefined;
+  const typescript = options?.typescript;
+  if (typescript?.tsgo === false) return;
+  if (!typescript?.configFile) {
+    throw new Error(`${name} requires the configured TypeScript project.`);
+  }
+  const configFile = path.resolve(typescript.configFile);
+  chain.plugin(pluginId).use(UltramodernNativeTypeChecker, [
+    {
+      build: typescript.build === true,
+      compiler: () => resolveCompiler(configFile),
+      configFile,
+    },
+  ]);
+}

package/src/policy-defaults.ts

@@ -0,0 +1,127 @@
+import {
+  collectRuntimePackageModuleDirectories,
+  createRuntimePackageResolutionPlugin,
+} from './runtime-package-resolution';
+
+/**
+ * The fork's renderer policy (head rendering, HTML template assembly and asset
+ * ordering) and server policy (localised loaders, error responses, telemetry,
+ * module-federation CSS and asset cache headers, static serving) are the
+ * default behaviour of an UltraModern.js app.
+ *
+ * They live in their own packages so they can also be composed explicitly, but
+ * a plain `appTools()` app gets them without opting in — that is what this fork
+ * has always done. Pass `appTools({ rendererExtensions: false })` or
+ * `appTools({ serverExtensions: false })` to run without them.
+ */
+export const RENDERER_EXTENSIONS_PACKAGE =
+  '@modern-js/runtime-renderer-extensions';
+
+export const RENDERER_EXTENSIONS_PLUGIN_NAME = 'rendererHead';
+
+export const SERVER_EXTENSIONS_PLUGIN_NAME =
+  '@modern-js/app-tools/server-plugin';
+
+export interface PolicyDefaultsOptions {
+  /** Default `true`. Set to `false` to drop the fork's renderer policy. */
+  rendererExtensions?: boolean;
+  /** Default `true`. Set to `false` to drop the fork's server policy. */
+  serverExtensions?: boolean;
+}
+
+type RuntimePluginDescriptor = {
+  name?: string;
+  path: string;
+  config?: unknown;
+};
+
+type ServerPluginDescriptor = { name: string };
+
+/**
+ * The subset of the CLI plugin API these defaults use. Typed structurally, and
+ * loosely at the hook boundary, so this package stays free of a dependency on
+ * the solution that consumes it — which depends on this one.
+ */
+export interface PolicyDefaultsPluginApi {
+  _internalRuntimePlugins(fn: (input: any) => any): void;
+  _internalServerPlugins(fn: (input: any) => any): void;
+  modifyResolvedConfig(fn: (config: any) => any): void;
+}
+
+type RuntimePluginsInput = {
+  entrypoint: unknown;
+  plugins: RuntimePluginDescriptor[];
+};
+
+type ServerPluginsInput = { plugins: ServerPluginDescriptor[] };
+
+export const POLICY_DEFAULTS_PLUGIN_NAME =
+  '@modern-js/ultramodern-policy-defaults';
+
+/** Registers the fork's default renderer and server policy. */
+export const applyPolicyDefaults = (
+  api: PolicyDefaultsPluginApi,
+  options: PolicyDefaultsOptions = {},
+): void => {
+  if (options.rendererExtensions !== false) {
+    api._internalRuntimePlugins(
+      ({ entrypoint, plugins }: RuntimePluginsInput) => {
+        // An explicit composition (`ultramodernAppTools()`) may already have
+        // registered it; the descriptor list must stay free of duplicates.
+        if (
+          !plugins.some(plugin => plugin.path === RENDERER_EXTENSIONS_PACKAGE)
+        ) {
+          plugins.push({
+            name: RENDERER_EXTENSIONS_PLUGIN_NAME,
+            path: RENDERER_EXTENSIONS_PACKAGE,
+            config: {},
+          });
+        }
+        return { entrypoint, plugins };
+      },
+    );
+
+    const moduleDirectories = collectRuntimePackageModuleDirectories(
+      [RENDERER_EXTENSIONS_PACKAGE],
+      import.meta.url,
+    );
+    if (moduleDirectories.length > 0) {
+      api.modifyResolvedConfig(config => ({
+        ...config,
+        builderPlugins: [
+          ...(config.builderPlugins ?? []),
+          createRuntimePackageResolutionPlugin(moduleDirectories),
+        ],
+      }));
+    }
+  }
+
+  if (options.serverExtensions !== false) {
+    api._internalServerPlugins(({ plugins }: ServerPluginsInput) => {
+      if (
+        !plugins.some(plugin => plugin.name === SERVER_EXTENSIONS_PLUGIN_NAME)
+      ) {
+        plugins.push({ name: SERVER_EXTENSIONS_PLUGIN_NAME });
+      }
+      return { plugins };
+    });
+  }
+};
+
+/**
+ * The fork defaults as a CLI plugin.
+ *
+ * The descriptor this registers may land before the ones it wraps — CLI
+ * ordering cannot be constrained here without a cycle, because the plugins
+ * that emit those descriptors are themselves ordered after `appTools()`.
+ * Ordering is settled on the runtime side instead: `rendererHeadPlugin`
+ * declares the runtime plugins that run before it.
+ */
+export const createPolicyDefaultsPlugin = (
+  options: PolicyDefaultsOptions = {},
+) => ({
+  name: POLICY_DEFAULTS_PLUGIN_NAME,
+  setup(api: PolicyDefaultsPluginApi) {
+    applyPolicyDefaults(api, options);
+  },
+});