ember.nvp 1.6.0 → 1.7.1

package/packages/rolldown/src/babel.test.ts

@@ -15,8 +15,9 @@ afterEach(() => {
 });
 
 /**
- * A babel config whose only plugin rewrites the string `"MARKER"` to `name`, so
- * the emitted code says which config file babel actually loaded.
+ * A babel config whose only plugin rewrites the string `"MARKER"` to `name`.
+ *
+ * So the emitted code says which config file babel loaded.
  */
 function markerConfig(name: string): string {
   return [
@@ -37,9 +38,13 @@ function markerConfig(name: string): string {
 }
 
 /**
- * Builds a `.gts` entry (so babel actually runs -- `maybeBabel` skips files that
- * need no transform) in a temp dir that becomes the cwd, the way config
- * detection sees it under the tsdown CLI. Returns the emitted code.
+ * Builds a `.gts` entry in a temp dir that becomes the cwd,
+ * the way config detection sees it under the tsdown CLI.
+ *
+ * A `.gts` entry so babel runs at all:
+ * `maybeBabel` skips files that need no transform.
+ *
+ * Returns the emitted code.
  */
 async function bundleWithBabel(
   files: Record<string, string>,

package/packages/rolldown/src/babel.ts

@@ -10,18 +10,33 @@ import type { Transform } from "babel-plugin-ember-template-compilation";
 import type { Plugin } from "rolldown";
 
 export interface BabelOptions {
+  /**
+   * Compile templates to the wire format instead of `precompileTemplate`.
+   *
+   * For a build that bundles its own ember-source.
+   * The wire format is private between one template compiler and one
+   * glimmer runtime of the same version, so this is only safe when both
+   * ship together.
+   *
+   * The compiler is ember-source's own, resolved from the package.
+   *
+   * Set by `ember({ bundle: true })`.
+   * Only applies without a babel config file.
+   */
+  bundle?: boolean;
   babelHelpers?: "bundled" | "runtime" | "inline" | "external";
   /**
    * The babel config file to use.
    *
-   * - `undefined`: auto-detect. A `babel.publish.config.*` (in the package root
-   *   or `config/`) wins, because this is a publish build; otherwise babel's own
-   *   config resolution applies (see `detectConfigFile`).
+   * - `undefined`: auto-detect.
+   *   A `babel.publish.config.*` (in the package root or `config/`) wins,
+   *   because this is a publish build.
+   *   Otherwise babel's own config resolution applies (see `detectConfigFile`).
    * - a string: use that config file.
    * - `false`: ignore config files entirely.
    *
-   * Without a config file, templates, decorators, and TypeScript are still
-   * handled (see `defaultPlugins`).
+   * Without a config file, templates, decorators, and TypeScript are still handled
+   * (see `defaultPlugins`).
    */
   configFile?: string | false;
   /**
@@ -29,17 +44,20 @@ export interface BabelOptions {
    */
   plugins?: PluginItem[];
   /**
-   * Template AST transforms (e.g. ember-scoped-css's `scopedCSS.template()`)
-   * passed to the default `babel-plugin-ember-template-compilation` entry.
+   * Template AST transforms passed to the default
+   * `babel-plugin-ember-template-compilation` entry.
+   *   e.g. ember-scoped-css's `scopedCSS.template()`
    *
-   * Only valid without a babel config file: with your own config, you list
-   * `babel-plugin-ember-template-compilation` yourself, so its `transforms`
-   * belong there.
+   * Only valid without a babel config file.
+   * With your own config, you list `babel-plugin-ember-template-compilation` yourself,
+   * so its `transforms` belong there.
    */
   templateTransforms?: Transform[];
   /**
-   * Opt additional files into babel (see maybeBabel's `filter`). Use this to
-   * cover addons that ship code needing babel (e.g. `ember-concurrency`).
+   * Opt additional files into babel (see maybeBabel's `filter`).
+   *
+   * Use this to cover addons that ship code needing babel
+   * (e.g. `ember-concurrency`).
    */
   filter?: {
     include: {
@@ -49,27 +67,34 @@ export interface BabelOptions {
   };
 }
 
-/** Tried in order, so an ESM config wins over a JSON one of the same name. */
+/**
+ * Tried in order, so an ESM config wins over a JSON one of the same name.
+ */
 const PUBLISH_CONFIG_EXTENSIONS = ["mjs", "cjs", "js", "mts", "cts", "ts", "json"];
 
 /**
- * Tried in order: next to package.json first, then `config/` for libraries that
- * keep their build configuration out of the package root.
+ * Tried in order:
+ * - next to package.json first
+ * - then `config/`, for libraries that keep their build configuration
+ *   out of the package root
  */
 const PUBLISH_CONFIG_DIRECTORIES = [".", "config"];
 
 /**
- * A `babel.publish.config.*` (in the package root or `config/`), if there is
- * one.
- *
- * A library's plain `babel.config.*` is its *development* config: it typically
- * compiles `@embroider/macros` away, targets the wire format, and wires up
- * whatever the in-package demo app or test suite needs. None of that belongs in
- * a published artifact -- macros must stay for the consuming app to evaluate,
- * and the wire format is private between one template compiler and one glimmer
- * runtime. Babel's own resolution can't tell the two apart (it finds whatever
- * `babel.config.*` exists), so a publish build has to prefer the config named
- * for publishing.
+ * A `babel.publish.config.*` (in the package root or `config/`), if there is one.
+ *
+ * A library's plain `babel.config.*` is its *development* config.
+ * It typically:
+ * - compiles `@embroider/macros` away
+ * - targets the wire format
+ * - wires up whatever the in-package demo app or test suite needs
+ *
+ * None of that belongs in a published artifact:
+ * - macros must stay, for the consuming app to evaluate
+ * - the wire format is private between one template compiler and one glimmer runtime
+ *
+ * Babel's own resolution can't tell the two apart (it finds whatever `babel.config.*` exists),
+ * so a publish build has to prefer the config named for publishing.
  */
 function detectPublishConfigFile(): string | undefined {
   for (const directory of PUBLISH_CONFIG_DIRECTORIES) {
@@ -84,14 +109,16 @@ function detectPublishConfigFile(): string | undefined {
 }
 
 /**
- * The config this publish build should use: a `babel.publish.config.*` when the
- * library has one, else the project's root babel config resolved the way babel
- * itself does (`babel.config.{js,cjs,mjs,cts,json}`, honoring `rootMode`
- * semantics) -- which for a library whose only config *is* its publish config
- * is the same file either way.
- *
- * The sync API evaluates the config file; on node 24+ that works for native
- * ESM configs too (require(esm)).
+ * The config this publish build must use:
+ * - a `babel.publish.config.*`, when the library has one
+ * - else the project's root babel config, resolved the way babel itself does
+ *   (`babel.config.{js,cjs,mjs,cts,json}`, honoring `rootMode` semantics)
+ *
+ * For a library whose only config *is* its publish config,
+ * that is the same file either way.
+ *
+ * The sync API evaluates the config file.
+ * On node 24+ that works for native ESM configs too (require(esm)).
  */
 function detectConfigFile(): string | undefined {
   const publishConfig = detectPublishConfigFile();
@@ -107,17 +134,25 @@ function detectConfigFile(): string | undefined {
  * Everything a library without its own babel config needs:
  *
  * - TypeScript stripping
+ *
  * - template compilation to `precompileTemplate` (`targetFormat: "hbs"`).
- *   Published libraries must NOT ship wire format: the wire format is
- *   private between the template compiler and the glimmer runtime of the
- *   same version, so baking it in ties the published artifact to the
- *   consuming app's exact ember-source. The consuming app performs final
- *   compilation.
- * - decorator-transforms, with its runtime left as a bare specifier so the
- *   consuming app resolves it (the library keeps `decorator-transforms` as
- *   a real dependency).
+ *   Published libraries must NOT ship wire format.
+ *   The wire format is private between the template compiler and the glimmer runtime
+ *   of the same version, so baking it in ties the published artifact
+ *   to the consuming app's exact ember-source.
+ *   The consuming app performs final compilation.
+ *
+ *   A bundle-mode build ships that exact ember-source,
+ *   so it compiles to the wire format with ember-source's own compiler,
+ *   and needs no compiler at runtime.
+ *
+ * - decorator-transforms, with its runtime left as a bare specifier
+ *   so the consuming app resolves it.
+ *   (the library keeps `decorator-transforms` as a real dependency)
+ *
+ *   A bundle-mode build resolves it itself.
  */
-function defaultPlugins(templateTransforms?: Transform[]): PluginItem[] {
+function defaultPlugins(templateTransforms?: Transform[], bundle = false): PluginItem[] {
   return [
     [
       transformTypeScript,
@@ -127,12 +162,15 @@ function defaultPlugins(templateTransforms?: Transform[]): PluginItem[] {
         allowDeclareFields: true,
       },
     ],
-    [templateCompilation, { targetFormat: "hbs", transforms: templateTransforms ?? [] }],
+    [
+      templateCompilation,
+      { targetFormat: bundle ? "wire" : "hbs", transforms: templateTransforms ?? [] },
+    ],
     [
       decoratorTransforms,
       {
-        // Emit `import ... from "decorator-transforms/runtime-esm"` as a bare
-        // specifier so it stays external and the consuming app resolves it.
+        // Emit `import ... from "decorator-transforms/runtime-esm"` as a bare specifier,
+        // so it stays external and the consuming app resolves it.
         runtime: { import: "decorator-transforms/runtime-esm" },
       },
     ],
@@ -140,29 +178,34 @@ function defaultPlugins(templateTransforms?: Transform[]): PluginItem[] {
 }
 
 /**
- * We still need babel (not just oxc/rolldown's native transforms) for two
- * reasons:
- *
- * - template compilation: `babel-plugin-ember-template-compilation` turns the
- *   content-tag output into `precompileTemplate` calls; oxc has no equivalent.
- * - decorators: Ember uses the legacy/stage-1 decorator signature together
- *   with `decorator-transforms`, which rewrites decorated class fields
- *   (`@tracked x`) into getter/setters backed by a runtime. oxc's native
- *   "legacy decorators" emit tsc-style `__decorate` output, which does not
- *   match those semantics.
- *
- * But we don't want to send *every* file through babel and give back the speed
- * rolldown/oxc buys us -- so we run babel via `maybeBabel`, which filters down
- * to only the files that actually need it (template-tag, decorators, template
- * imports). Everything else stays on the native transform.
- *
- * The library's own babel config is used when it exists -- its
- * `babel.publish.config.*` (root or `config/`) in preference to its
- * `babel.config.*`, since this is a publish build. Without one, `defaultPlugins` covers templates, decorators,
- * and TypeScript, so no config file is required.
- *
- * Libraries default to `babelHelpers: "bundled"` so the emitted output is
- * self-contained.
+ * We still need babel (not just oxc / rolldown's native transforms) for two reasons:
+ *
+ * - template compilation.
+ *   `babel-plugin-ember-template-compilation` turns the content-tag output
+ *   into `precompileTemplate` calls.
+ *   oxc has no equivalent.
+ *
+ * - decorators.
+ *   Ember uses the legacy / stage-1 decorator signature together with `decorator-transforms`,
+ *   which rewrites decorated class fields (`@tracked x`) into getter / setters backed by a runtime.
+ *   oxc's native "legacy decorators" emit tsc-style `__decorate` output,
+ *   which does not match those semantics.
+ *
+ * But we don't want to send *every* file through babel
+ * and give back the speed rolldown / oxc buys us.
+ *
+ * So we run babel via `maybeBabel`, which filters down to only the files that need it
+ * (template-tag, decorators, template imports).
+ * Everything else stays on the native transform.
+ *
+ * The library's own babel config is used when it exists.
+ * Its `babel.publish.config.*` (root or `config/`) wins over its `babel.config.*`,
+ * since this is a publish build.
+ *
+ * Without one, `defaultPlugins` covers templates, decorators, and TypeScript,
+ * so no config file is required.
+ *
+ * Libraries default to `babelHelpers: "bundled"`, so the emitted output is self-contained.
  */
 export function emberBabel(options: BabelOptions = {}): Plugin {
   const configFile = options.configFile === undefined ? detectConfigFile() : options.configFile;
@@ -190,10 +233,12 @@ export function emberBabel(options: BabelOptions = {}): Plugin {
 
   return maybeBabel({
     ...shared,
-    // No config file (or the caller opted out): don't let babel go looking
-    // for one -- we provide the whole plugin list inline.
+    // No config file (or the caller opted out).
+    // Don't let babel go looking for one: we provide the whole plugin list inline.
     configFile: false,
     babelrc: false,
-    plugins: defaultPlugins(options.templateTransforms).concat(options.plugins ?? []),
+    plugins: defaultPlugins(options.templateTransforms, options.bundle).concat(
+      options.plugins ?? [],
+    ),
   }) as unknown as Plugin;
 }

package/packages/rolldown/src/bundle.test.ts

@@ -0,0 +1,149 @@
+import { mkdir, mkdtemp, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { rolldown } from "rolldown";
+import type { InputOptions } from "rolldown";
+import { afterEach, describe, expect, it } from "vitest";
+
+import { emberBundle, emberSourceAliases } from "./bundle.ts";
+
+let restoreCwd: (() => void) | undefined;
+
+afterEach(() => {
+  restoreCwd?.();
+  restoreCwd = undefined;
+});
+
+/**
+ * An ember-source stub shaped like the real package:
+ * - a `./*` export whose conditions pick one of two builds
+ * - a `renamed-modules` map keyed by module file path
+ */
+const EMBER_SOURCE_MANIFEST = {
+  name: "ember-source",
+  version: "0.0.0",
+  type: "module",
+  exports: {
+    "./*": {
+      development: "./dist/dev/packages/*",
+      production: "./dist/prod/packages/*",
+      default: "./dist/prod/packages/*",
+    },
+    "./package.json": "./package.json",
+  },
+  "ember-addon": {
+    "renamed-modules": {
+      "@ember/modifier/index.js": "ember-source/@ember/modifier/index.js",
+      "@ember/modifier/on.js": "ember-source/@ember/modifier/on.js",
+      "@ember/-internals/glimmer/index.js": "ember-source/@ember/-internals/glimmer/index.js",
+      "@glimmer/runtime/index.js": "ember-source/@glimmer/runtime/index.js",
+      "rsvp/index.js": "ember-source/rsvp/index.js",
+      "ember/index.js": "ember-source/ember/index.js",
+    },
+  },
+};
+
+/**
+ * Each provided module exists in both builds, and says which build it is.
+ */
+const EMBER_SOURCE_MODULES = {
+  "@ember/modifier/index.js": `export const on = "on from BUILD";`,
+  "@ember/modifier/on.js": `export const on = "on from BUILD";`,
+};
+
+async function fixture({ emberSource = true } = {}): Promise<string> {
+  const dir = await mkdtemp(path.join(tmpdir(), "ember-rolldown-bundle-"));
+  await writeFile(
+    path.join(dir, "package.json"),
+    JSON.stringify({ name: "fixture", version: "0.0.0", type: "module" }),
+  );
+
+  if (emberSource) {
+    const stubDir = path.join(dir, "node_modules/ember-source");
+    await mkdir(stubDir, { recursive: true });
+    await writeFile(path.join(stubDir, "package.json"), JSON.stringify(EMBER_SOURCE_MANIFEST));
+
+    for (const build of ["dev", "prod"]) {
+      for (const [modulePath, source] of Object.entries(EMBER_SOURCE_MODULES)) {
+        const file = path.join(stubDir, "dist", build, "packages", modulePath);
+        await mkdir(path.dirname(file), { recursive: true });
+        await writeFile(file, source.replace("BUILD", build));
+      }
+    }
+  }
+
+  const previousCwd = process.cwd();
+  process.chdir(dir);
+  restoreCwd = () => process.chdir(previousCwd);
+
+  return dir;
+}
+
+async function bundle(dir: string, entry: string, resolve: InputOptions["resolve"] = {}) {
+  await writeFile(path.join(dir, "index.js"), entry);
+
+  const build = await rolldown({
+    input: path.join(dir, "index.js"),
+    plugins: [emberBundle()],
+    resolve,
+    onwarn() {},
+  });
+  const { output } = await build.generate({ format: "es" });
+
+  return output.filter((chunk) => "code" in chunk).map((chunk) => chunk.code)[0] ?? "";
+}
+
+describe("emberSourceAliases", () => {
+  it("aliases each provided package into ember-source", async () => {
+    await fixture();
+
+    expect(emberSourceAliases()).toEqual({
+      "@ember/modifier": "ember-source/@ember/modifier",
+      "@ember/-internals": "ember-source/@ember/-internals",
+      "@glimmer/runtime": "ember-source/@glimmer/runtime",
+      rsvp: "ember-source/rsvp",
+      ember: "ember-source/ember",
+    });
+  });
+
+  it("has nothing to alias without ember-source in the graph", async () => {
+    await fixture({ emberSource: false });
+
+    expect(emberSourceAliases()).toEqual({});
+  });
+});
+
+describe("emberBundle", () => {
+  it("bundles a provided package's index and module files from the production build", async () => {
+    const dir = await fixture();
+
+    const code = await bundle(
+      dir,
+      `import { on } from "@ember/modifier";\nimport { on as onModule } from "@ember/modifier/on";\nexport { on, onModule };`,
+    );
+
+    expect(code).toContain(`"on from prod"`);
+    expect(code).not.toContain(`from "@ember/modifier`);
+  });
+
+  it("follows the development condition", async () => {
+    const dir = await fixture();
+
+    const code = await bundle(dir, `export { on } from "@ember/modifier";`, {
+      conditionNames: ["development"],
+    });
+
+    expect(code).toContain(`"on from dev"`);
+  });
+
+  it("keeps explicit aliases", async () => {
+    const dir = await fixture();
+    await writeFile(path.join(dir, "mine.js"), `export const on = "mine";`);
+
+    const code = await bundle(dir, `export { on } from "@ember/modifier";`, {
+      alias: { "@ember/modifier": path.join(dir, "mine.js") },
+    });
+
+    expect(code).toContain(`"mine"`);
+  });
+});

package/packages/rolldown/src/bundle.ts

@@ -0,0 +1,71 @@
+import type { Plugin } from "rolldown";
+
+import { emberSourceRenamedModules } from "./externals.ts";
+
+/**
+ * The package name a renamed-modules key belongs to
+ *   `@ember/modifier/on.js` → `@ember/modifier`
+ *   `rsvp/index.js` → `rsvp`
+ */
+function packageOf(modulePath: string): string {
+  const segments = modulePath.split("/");
+  const length = modulePath.startsWith("@") ? 2 : 1;
+
+  return segments.slice(0, length).join("/");
+}
+
+/**
+ * One alias per package ember-source provides, pointing into ember-source
+ *   `@ember/modifier` → `ember-source/@ember/modifier`
+ *
+ * The provided packages are the ones named in `ember-addon.renamed-modules`
+ * (`@ember/*`, `@glimmer/tracking`, `rsvp`, `backburner.js`, …).
+ *
+ * Real packages such as `@glimmer/component` are not in it,
+ * so they keep resolving from node_modules.
+ */
+export function emberSourceAliases(): Record<string, string> {
+  const aliases: Record<string, string> = {};
+
+  for (const modulePath of Object.keys(emberSourceRenamedModules())) {
+    const name = packageOf(modulePath);
+
+    aliases[name] = `ember-source/${name}`;
+  }
+
+  return aliases;
+}
+
+/**
+ * Makes the modules ember-source provides resolvable,
+ * so a bundle-mode build can include them.
+ *
+ * ember-source exports every module under `./*`,
+ * with `development` and `production` conditions selecting one of its two builds.
+ *
+ * A bare `@ember/modifier` is not that path, though.
+ * It only exists as `ember-source/@ember/modifier`.
+ *
+ * So this plugin adds the alias for each provided package,
+ * and leaves the rest to the resolver:
+ * - the `default` condition selects the production build
+ * - `resolve.conditionNames: ["development"]` selects the development build
+ *   (tsdown: `inputOptions.resolve.conditionNames`)
+ *
+ * Aliases set explicitly in the build config win over these.
+ */
+export function emberBundle(): Plugin {
+  return {
+    name: "ember:bundle",
+
+    options(inputOptions) {
+      inputOptions.resolve ??= {};
+      inputOptions.resolve.alias = {
+        ...emberSourceAliases(),
+        ...inputOptions.resolve.alias,
+      };
+
+      return inputOptions;
+    },
+  };
+}

package/packages/rolldown/src/config.ts

@@ -1,33 +1,48 @@
 import type { TsdownPlugin, UserConfig } from "tsdown";
 
 /**
- * Sensible defaults for an Ember v2 library, applied through plugin hooks so
- * they travel with `ember()` — you get them whether you use this package's
- * `defineConfig`, tsdown's, or a plain `tsdown.config.js` / `rolldown.config.js`.
+ * Sensible defaults for an Ember v2 library.
+ *
+ * Applied through plugin hooks, so they travel with `ember()`.
+ * You get them whether you use this package's `defineConfig`, tsdown's,
+ * or a plain `tsdown.config.js` / `rolldown.config.js`.
  *
  * Every value is applied with `??=`, so anything you set explicitly wins.
  *
- * Under tsdown, the full set applies via the `tsdownConfig` hook (analogous to
- * Vite's `config` hook):
+ * Under tsdown, the full set applies via the `tsdownConfig` hook
+ * (analogous to Vite's `config` hook):
  *
- * - `sourcemap` — emit sourcemaps alongside the output.
- * - `clean` — wipe `dist/` between builds.
- * - `dts` — emit `.d.ts` declarations (via isolated declarations).
- * - `outExtensions` — `.js`/`.d.ts` rather than tsdown's default `.mjs`/`.d.mts`,
- *   since exports maps conventionally point at `.js`/`.d.ts`.
- * - `report` — off; the size report is noise for a library build.
- * - `deps.neverBundle` — leave node builtins and the ember virtual packages to
- *   the consuming app (`emberExternals()` handles the rest).
+ * - `sourcemap` — emit sourcemaps alongside the output
+ * - `clean` — wipe `dist/` between builds
+ * - `dts` — emit `.d.ts` declarations (via isolated declarations)
+ * - `outExtensions` — `.js` / `.d.ts` rather than tsdown's default `.mjs` / `.d.mts`
+ *   (exports maps conventionally point at `.js` / `.d.ts`)
+ * - `report` — off.
+ *   The size report is noise for a library build.
+ * - `deps.neverBundle` — leave node builtins and the ember virtual packages
+ *   to the consuming app (`emberExternals()` handles the rest)
  *
- * A plain rolldown build has no notion of `clean`/`dts`/`outExtensions`/`report`
- * (those are tsdown-level concepts), so only the options with rolldown
- * equivalents are applied there, via rolldown's own `outputOptions` hook:
+ * A plain rolldown build has no notion of `clean` / `dts` / `outExtensions` / `report`.
+ * Those are tsdown-level concepts.
+ * So only the options with rolldown equivalents are applied there,
+ * via rolldown's own `outputOptions` hook:
  *
- * - `output.sourcemap` — on (output option).
+ * - `output.sourcemap` — on
  *
  * Externals are handled by `emberExternals()` (a `resolveId` hook) in both cases.
+ *
+ * Bundle mode flips the dependency defaults.
+ * The output is a self-contained browser artifact, so:
+ *
+ * - `platform` — `browser`
+ * - `deps.alwaysBundle` — everything but node builtins
+ *   (including the package's own `dependencies` and `peerDependencies`,
+ *    and the declarations' type imports)
+ * - `deps.neverBundle` — node builtins only
+ * - `deps.onlyBundle` — `false`
+ *   (bundling node_modules is the point, so tsdown's hint about it is noise)
  */
-export function emberConfig(): TsdownPlugin {
+export function emberConfig({ bundle = false }: { bundle?: boolean } = {}): TsdownPlugin {
   return {
     name: "ember:config",
 
@@ -39,6 +54,15 @@ export function emberConfig(): TsdownPlugin {
       config.report ??= false;
 
       config.deps ??= {};
+
+      if (bundle) {
+        config.platform ??= "browser";
+        config.deps.alwaysBundle ??= (id) => !id.startsWith("node:");
+        config.deps.neverBundle ??= ["node:*"];
+        config.deps.onlyBundle ??= false;
+        return;
+      }
+
       config.deps.neverBundle ??= ["node:*", "@ember/*", "@glimmer/*"];
     },