ember.nvp 1.1.0 → 1.3.0

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

@@ -6,13 +6,30 @@ import { afterEach, describe, expect, it } from "vitest";
 
 import { ember } from "../index.ts";
 
+interface Dist {
+  /** Sorted dist-relative paths of every emitted file. */
+  files: string[];
+  /** dist-relative path -> content, for every emitted .d.ts and .css file. */
+  contents: Record<string, string>;
+}
+
+let restoreCwd: (() => void) | undefined;
+
+afterEach(() => {
+  restoreCwd?.();
+  restoreCwd = undefined;
+});
+
 /**
  * Drives `ember()` through a real tsdown build (the dts pipeline included).
  * `files` is a map of relative path -> source, written into a temp dir that
  * becomes the cwd for the build (the externals and isolated-declarations
  * plugins read package.json / tsconfig.json from cwd, like the tsdown CLI).
+ *
+ * Returns the emitted file list plus the full contents of every declaration
+ * and css file (js output is covered by transform.test.ts).
  */
-async function buildFixture(files: Record<string, string>, entry: string[]): Promise<string> {
+async function buildFixture(files: Record<string, string>, entry: string[]): Promise<Dist> {
   const dir = await mkdtemp(path.join(tmpdir(), "ember-rolldown-dts-"));
 
   const withDefaults: Record<string, string> = {
@@ -45,33 +62,40 @@ async function buildFixture(files: Record<string, string>, entry: string[]): Pro
     plugins: [ember()],
   });
 
-  return dir;
-}
+  const distDir = path.join(dir, "dist");
+  const dist: Dist = { files: [], contents: {} };
 
-let restoreCwd: (() => void) | undefined;
+  for (const entry of await readdir(distDir, { withFileTypes: true, recursive: true })) {
+    if (!entry.isFile()) continue;
 
-afterEach(() => {
-  restoreCwd?.();
-  restoreCwd = undefined;
-});
+    const relative = path.relative(distDir, path.join(entry.parentPath, entry.name));
+    dist.files.push(relative);
 
-async function listFiles(dir: string): Promise<string[]> {
-  const out: string[] = [];
-  for (const entry of await readdir(dir, { withFileTypes: true, recursive: true })) {
-    if (entry.isFile()) {
-      out.push(path.relative(dir, path.join(entry.parentPath, entry.name)));
+    if (relative.endsWith(".d.ts") || relative.endsWith(".css")) {
+      dist.contents[relative] = await readFile(path.join(distDir, relative), "utf8");
     }
   }
-  return out.sort();
+
+  dist.files.sort();
+
+  return dist;
+}
+
+/** One printable document of every captured file, for a single snapshot. */
+function printed(dist: Dist): string {
+  return Object.entries(dist.contents)
+    .sort(([a], [b]) => a.localeCompare(b))
+    .map(([file, content]) => `//=== ${file}\n${content}`)
+    .join("\n");
 }
 
 describe("declarations (full ember() via tsdown)", () => {
   it("emits .d.ts for an entry that type-imports from a non-entry .gts", async () => {
-    // Mirrors the luna-core shape: the component is in the runtime graph via
+    // Mirrors a design-system shape: the component is in the runtime graph via
     // the index entry, while a second entry (a service) only *type*-imports
     // from it. The service's declaration then references the component's
     // (virtual) .d.ts, which only exists in the bundler's module graph.
-    const dir = await buildFixture(
+    const dist = await buildFixture(
       {
         "src/index.ts": `export { default as Popup } from './popup.gts';`,
         "src/service.ts": [
@@ -103,17 +127,164 @@ describe("declarations (full ember() via tsdown)", () => {
       ["./src/index.ts", "./src/service.ts"],
     );
 
-    const dist = await listFiles(path.join(dir, "dist"));
+    expect(dist.files).toMatchInlineSnapshot(`
+      [
+        "index.d.ts",
+        "index.js",
+        "index.js.map",
+        "popup-CjMmUEVb.d.ts",
+        "popup-CjMmUEVb.d.ts.map",
+        "service.d.ts",
+        "service.d.ts.map",
+        "service.js",
+        "service.js.map",
+      ]
+    `);
 
-    expect(dist).toContain("index.d.ts");
-    expect(dist).toContain("service.d.ts");
+    expect(printed(dist)).toMatchInlineSnapshot(`
+      "//=== index.d.ts
+      import { t as Popup } from "./popup-CjMmUEVb.js";
+      export { Popup };
+      //=== popup-CjMmUEVb.d.ts
+      import Component from "@glimmer/component";
+      //#region src/popup.d.ts
+      interface PopupBlock {
+        open: () => void;
+      }
+      interface PopupSignature {
+        Element: HTMLDivElement;
+        Blocks: {
+          default: [PopupBlock];
+        };
+      }
+      declare class Popup extends Component<PopupSignature> {}
+      //#endregion
+      export { PopupBlock as n, Popup as t };
+      //# sourceMappingURL=popup-CjMmUEVb.d.ts.map
+      //=== service.d.ts
+      import { n as PopupBlock } from "./popup-CjMmUEVb.js";
+      //#region src/service.d.ts
+      declare class TooltipService {
+        registerPopup(context: PopupBlock): void;
+      }
+      //#endregion
+      export { TooltipService };
+      //# sourceMappingURL=service.d.ts.map"
+    `);
+  });
 
-    const serviceDts = await readFile(path.join(dir, "dist/service.d.ts"), "utf8");
+  it("emits .d.ts when a .gts module is only ever type-imported", async () => {
+    // Nothing value-imports popup.gts, so its virtual module never enters the
+    // runtime graph: the only route to its declaration is the dts resolver
+    // loading it on demand. The declaration pipeline registers modules as
+    // their (virtual) source loads, so the import must resolve to the source
+    // id — a pre-rewritten `.d.ts` id skips that registration and dangles.
+    const dist = await buildFixture(
+      {
+        "src/service.ts": [
+          `import type { PopupBlock } from './components/popup.gts';`,
+          ``,
+          `export class TooltipService {`,
+          `  registerPopup(context: PopupBlock): void {`,
+          `    void context;`,
+          `  }`,
+          `}`,
+        ].join("\n"),
+        "src/components/popup.gts": [
+          `import Component from '@glimmer/component';`,
+          ``,
+          `export interface PopupBlock {`,
+          `  open: () => void;`,
+          `}`,
+          ``,
+          `export default class Popup extends Component {`,
+          `  <template>popup</template>`,
+          `}`,
+        ].join("\n"),
+      },
+      ["./src/service.ts"],
+    );
 
-    // The PopupBlock type must be reachable: either inlined into the bundled
-    // declaration or imported via a specifier that exists in dist.
-    expect(serviceDts).toContain("PopupBlock");
-    expect(serviceDts).not.toContain(".gts");
+    expect(dist.files).toMatchInlineSnapshot(`
+      [
+        "service.d.ts",
+        "service.d.ts.map",
+        "service.js",
+        "service.js.map",
+      ]
+    `);
+
+    expect(printed(dist)).toMatchInlineSnapshot(`
+      "//=== service.d.ts
+      import "@glimmer/component";
+      //#region src/components/popup.d.ts
+      interface PopupBlock {
+        open: () => void;
+      }
+      //#endregion
+      //#region src/service.d.ts
+      declare class TooltipService {
+        registerPopup(context: PopupBlock): void;
+      }
+      //#endregion
+      export { TooltipService };
+      //# sourceMappingURL=service.d.ts.map"
+    `);
+  });
+
+  it("emits .d.ts for a .gts that type-imports another (otherwise unimported) .gts", async () => {
+    // A nested component type-imports a sibling from the parent directory;
+    // its declaration then carries a relative source specifier for a module
+    // that exists only in the bundler's graph (never on disk, never in the
+    // runtime graph).
+    const dist = await buildFixture(
+      {
+        "src/index.ts": `export { default as OptionList } from './components/select/option-list.gts';`,
+        "src/components/select/option-list.gts": [
+          `import Component from '@glimmer/component';`,
+          `import type { PopupBlock } from '../popup.gts';`,
+          ``,
+          `export interface OptionListArgs {`,
+          `  registerPopup: (context: PopupBlock) => void;`,
+          `}`,
+          ``,
+          `export default class OptionList extends Component {`,
+          `  <template>options</template>`,
+          `}`,
+        ].join("\n"),
+        "src/components/popup.gts": [
+          `import Component from '@glimmer/component';`,
+          ``,
+          `export interface PopupBlock {`,
+          `  open: () => void;`,
+          `}`,
+          ``,
+          `export default class Popup extends Component {`,
+          `  <template>popup</template>`,
+          `}`,
+        ].join("\n"),
+      },
+      ["./src/index.ts"],
+    );
+
+    expect(dist.files).toMatchInlineSnapshot(`
+      [
+        "index.d.ts",
+        "index.d.ts.map",
+        "index.js",
+        "index.js.map",
+      ]
+    `);
+
+    expect(printed(dist)).toMatchInlineSnapshot(`
+      "//=== index.d.ts
+      import Component from "@glimmer/component";
+      //#region src/components/select/option-list.d.ts
+      declare class OptionList extends Component {}
+      //#endregion
+      export { OptionList };
+      //# sourceMappingURL=index.d.ts.map"
+    `);
   });
 
   it("bundles co-located CSS (via @tsdown/css) without breaking declarations", async () => {
@@ -121,8 +292,8 @@ describe("declarations (full ember() via tsdown)", () => {
     // handling the build dies on tsdown's css-guard — and because the failing
     // component module never loads, every declaration that references it
     // dangles (surfacing as misleading UNLOADABLE_DEPENDENCY errors on
-    // <component>.d.ts). @tsdown/css (this package's peer) makes both work.
-    const dir = await buildFixture(
+    // <component>.d.ts). @tsdown/css makes both work.
+    const dist = await buildFixture(
       {
         "src/index.ts": `export { default as Popup } from './popup.gts';`,
         "src/service.ts": [
@@ -149,18 +320,47 @@ describe("declarations (full ember() via tsdown)", () => {
       ["./src/index.ts", "./src/service.ts"],
     );
 
-    const dist = await listFiles(path.join(dir, "dist"));
-
-    const cssFiles = dist.filter((file) => file.endsWith(".css"));
-    expect(cssFiles).toHaveLength(1);
-
-    const css = await readFile(path.join(dir, "dist", cssFiles[0]!), "utf8");
-    expect(css).toContain(".popup");
+    expect(dist.files).toMatchInlineSnapshot(`
+      [
+        "index.d.ts",
+        "index.js",
+        "index.js.map",
+        "popup-CytznrQX.d.ts",
+        "popup-CytznrQX.d.ts.map",
+        "service.d.ts",
+        "service.d.ts.map",
+        "service.js",
+        "service.js.map",
+        "style.css",
+      ]
+    `);
 
-    // The cascade regression: the css-importing component's declaration must
-    // still be generated and reachable from the service's declaration.
-    const serviceDts = await readFile(path.join(dir, "dist/service.d.ts"), "utf8");
-    expect(serviceDts).toContain("PopupBlock");
-    expect(serviceDts).not.toContain(".gts");
+    expect(printed(dist)).toMatchInlineSnapshot(`
+      "//=== index.d.ts
+      import { t as Popup } from "./popup-CytznrQX.js";
+      export { Popup };
+      //=== popup-CytznrQX.d.ts
+      import Component from "@glimmer/component";
+      //#region src/popup.d.ts
+      interface PopupBlock {
+        open: () => void;
+      }
+      declare class Popup extends Component {}
+      //#endregion
+      export { PopupBlock as n, Popup as t };
+      //# sourceMappingURL=popup-CytznrQX.d.ts.map
+      //=== service.d.ts
+      import { n as PopupBlock } from "./popup-CytznrQX.js";
+      //#region src/service.d.ts
+      declare function register(context: PopupBlock): void;
+      //#endregion
+      export { register };
+      //# sourceMappingURL=service.d.ts.map
+      //=== style.css
+      .popup {
+        color: red;
+      }
+      "
+    `);
   });
 });

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

@@ -0,0 +1,118 @@
+import { mkdir, mkdtemp, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { rolldown } from "rolldown";
+import { afterEach, describe, expect, it } from "vitest";
+
+import { emberExternals } from "./externals.ts";
+
+let restoreCwd: (() => void) | undefined;
+
+afterEach(() => {
+  restoreCwd?.();
+  restoreCwd = undefined;
+});
+
+/**
+ * An ember-source stub whose `ember-addon.renamed-modules` provides
+ * `@glimmer/runtime` (file-path keys, like the real manifest).
+ */
+const EMBER_SOURCE_STUB = {
+  name: "ember-source",
+  version: "0.0.0",
+  "ember-addon": {
+    "renamed-modules": {
+      "@glimmer/runtime/index.js": "ember-source/@glimmer/runtime/index.js",
+      "@ember/-internals/glimmer/index.js": "ember-source/@ember/-internals/glimmer/index.js",
+    },
+  },
+};
+
+/**
+ * Writes a fixture package (manifest + optional stub ember-source in its
+ * node_modules) and cds into it — the plugin reads both from the library's
+ * own context, like the tsdown CLI.
+ */
+async function fixture(manifest: object, { emberSource = true } = {}): Promise<string> {
+  const dir = await mkdtemp(path.join(tmpdir(), "ember-rolldown-externals-"));
+  await writeFile(path.join(dir, "package.json"), JSON.stringify(manifest));
+
+  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_STUB));
+  }
+
+  const previousCwd = process.cwd();
+  process.chdir(dir);
+  restoreCwd = () => process.chdir(previousCwd);
+
+  return dir;
+}
+
+/** Runs the plugin's own hooks directly against the current fixture. */
+function resolveWith(source: string): unknown {
+  const plugin = emberExternals();
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-explicit-any
+  (plugin.buildStart as any).call({ addWatchFile() {} });
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-explicit-any
+  return (plugin.resolveId as any).handler(source);
+}
+
+describe("emberExternals", () => {
+  it("externalizes declared dependencies and the ember virtual packages", async () => {
+    await fixture({ dependencies: { "some-dep": "*" } });
+    expect(resolveWith("some-dep")).toBe(false);
+    expect(resolveWith("@ember/component")).toBe(false);
+    expect(resolveWith("@glimmer/tracking")).toBe(false);
+  });
+
+  it("externalizes the modules ember-source provides via renamed-modules", async () => {
+    // Private API like @glimmer/runtime exists only inside the app's
+    // ember-source (its ember-addon.renamed-modules) — @embroider/core's
+    // emberVirtualPackages doesn't list it.
+    await fixture({});
+    expect(resolveWith("@glimmer/runtime")).toBe(false);
+    expect(resolveWith("@ember/-internals/glimmer")).toBe(false);
+  });
+
+  it("does not blanket-externalize @glimmer packages ember-source doesn't provide", async () => {
+    // e.g. @glimmer/component is a real package a library may want bundled;
+    // only declared deps / virtual packages / renamed-modules are external.
+    await fixture({});
+    expect(resolveWith("@glimmer/not-provided")).toBeUndefined();
+  });
+
+  it("leaves undeclared packages alone, with or without ember-source", async () => {
+    await fixture({});
+    expect(resolveWith("left-pad")).toBeUndefined();
+
+    await fixture({}, { emberSource: false });
+    expect(resolveWith("left-pad")).toBeUndefined();
+    // No ember-source in the graph -> no renamed-modules to consult.
+    expect(resolveWith("@glimmer/runtime")).toBeUndefined();
+  });
+
+  it("keeps a renamed-modules import external through a real build", async () => {
+    const dir = await fixture({ name: "build-fixture" });
+    await writeFile(
+      path.join(dir, "index.ts"),
+      `import { curry } from '@glimmer/runtime';\nexport const curried: unknown = curry;\n`,
+    );
+
+    const warnings: string[] = [];
+    const build = await rolldown({
+      input: path.join(dir, "index.ts"),
+      plugins: [emberExternals()],
+      onwarn(warning) {
+        warnings.push(warning.code ?? String(warning));
+      },
+    });
+    const { output } = await build.generate({ format: "es" });
+
+    expect(warnings.filter((code) => code === "UNRESOLVED_IMPORT")).toEqual([]);
+
+    const code = output.filter((chunk) => "code" in chunk).map((chunk) => chunk.code)[0] ?? "";
+    expect(code).toContain(`from "@glimmer/runtime"`);
+  });
+});

package/packages/rolldown/src/externals.ts

@@ -1,4 +1,6 @@
 import { readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
 
 import type { Plugin } from "rolldown";
 
@@ -33,6 +35,38 @@ function resolvableDependencies(): Set<string> {
   return deps;
 }
 
+/**
+ * The module names ember-source provides by renaming them into itself — the
+ * keys of its `ember-addon.renamed-modules`, normalized from file paths to
+ * import specifiers (`@glimmer/runtime/index.js` → `@glimmer/runtime`).
+ *
+ * This is the authoritative list of ember's provided modules, including
+ * private API that @embroider/core's emberVirtualPackages doesn't cover
+ * (e.g. `@glimmer/runtime`). It deliberately does NOT include real packages
+ * like `@glimmer/component`, which a library may want bundled.
+ *
+ * Resolved from the library's own dependency graph; empty when ember-source
+ * isn't resolvable there.
+ */
+function emberSourceRenamedModules(): Set<string> {
+  const provided = new Set<string>();
+
+  try {
+    const require = createRequire(path.resolve("package.json"));
+    const manifest = require("ember-source/package.json") as {
+      "ember-addon"?: { "renamed-modules"?: Record<string, string> };
+    };
+
+    for (const key of Object.keys(manifest["ember-addon"]?.["renamed-modules"] ?? {})) {
+      provided.add(key.replace(/\.js$/, "").replace(/\/index$/, ""));
+    }
+  } catch {
+    // The library doesn't have ember-source in its graph; nothing to provide.
+  }
+
+  return provided;
+}
+
 /**
  * Keeps the library's declared dependencies and the ember virtual packages
  * (things like `@ember/component`, `@glimmer/tracking`, the template compiler,
@@ -41,6 +75,7 @@ function resolvableDependencies(): Set<string> {
  */
 export function emberExternals(): Plugin {
   let deps: Set<string>;
+  let renamedModules: Set<string>;
 
   return {
     name: "ember:externals",
@@ -48,6 +83,7 @@ export function emberExternals(): Plugin {
     buildStart() {
       this.addWatchFile("package.json");
       deps = resolvableDependencies();
+      renamedModules = emberSourceRenamedModules();
     },
 
     resolveId: {
@@ -76,6 +112,15 @@ export function emberExternals(): Plugin {
           return false;
         }
 
+        // Modules ember-source provides by renaming them into itself
+        // (`ember-addon.renamed-modules`) — private API like
+        // `@glimmer/runtime` that only exists inside the app's ember-source.
+        // Matched on the full specifier: the renamed modules are module
+        // paths, not packages.
+        if (renamedModules.has(source)) {
+          return false;
+        }
+
         return undefined;
       },
     },

package/packages/rolldown/src/isolated-declarations.test.ts

@@ -0,0 +1,122 @@
+import { mkdir, mkdtemp, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { build } from "tsdown";
+import { afterEach, describe, expect, it } from "vitest";
+
+import { ember } from "../index.ts";
+
+let restoreCwd: (() => void) | undefined;
+
+afterEach(() => {
+  restoreCwd?.();
+  restoreCwd = undefined;
+});
+
+/**
+ * Runs a real tsdown build of a single trivial entry in a temp dir, so the
+ * isolated-declarations guard reads the tsconfig files written by the test the
+ * same way it does under the tsdown CLI. Returns the build's rejection, or
+ * `undefined` when it succeeded.
+ */
+async function buildFixture(
+  files: Record<string, string>,
+  tsconfig?: string | boolean,
+): Promise<Error | undefined> {
+  const dir = await mkdtemp(path.join(tmpdir(), "ember-rolldown-isolated-declarations-"));
+
+  const withDefaults: Record<string, string> = {
+    "package.json": JSON.stringify({ name: "fixture", version: "0.0.0", type: "module" }),
+    "src/index.ts": `export const greeting: string = 'hello';`,
+    ...files,
+  };
+
+  for (const [relative, source] of Object.entries(withDefaults)) {
+    const full = path.join(dir, relative);
+    await mkdir(path.dirname(full), { recursive: true });
+    await writeFile(full, source, "utf8");
+  }
+
+  const previousCwd = process.cwd();
+  process.chdir(dir);
+  restoreCwd = () => process.chdir(previousCwd);
+
+  try {
+    await build({
+      entry: ["./src/index.ts"],
+      config: false,
+      logLevel: "silent",
+      tsconfig,
+      plugins: [ember()],
+    });
+
+    return undefined;
+  } catch (error) {
+    return error as Error;
+  }
+}
+
+const withFlag = JSON.stringify({
+  compilerOptions: { isolatedDeclarations: true, declaration: true },
+});
+const withoutFlag = JSON.stringify({ compilerOptions: { declaration: true } });
+
+describe("isolated declarations guard", () => {
+  it("errors when the cwd tsconfig.json does not set the flag", async () => {
+    const error = await buildFixture({ "tsconfig.json": withoutFlag });
+
+    expect(error?.message).toContain(`must set "compilerOptions.isolatedDeclarations": true`);
+  });
+
+  it("passes when the cwd tsconfig.json sets the flag", async () => {
+    expect(await buildFixture({ "tsconfig.json": withFlag })).toBeUndefined();
+  });
+
+  it("checks the tsconfig the `tsconfig` option points at, not tsconfig.json", async () => {
+    // The shape a library with in-package dev code wants: a permissive
+    // tsconfig.json for editors and `tsc --noEmit` over everything, and a
+    // publish-only tsconfig -- the one the build uses -- carrying the flag.
+    const error = await buildFixture(
+      { "tsconfig.json": withoutFlag, "tsconfig.publish.json": withFlag },
+      "./tsconfig.publish.json",
+    );
+
+    expect(error).toBeUndefined();
+  });
+
+  it("errors when the tsconfig the `tsconfig` option points at lacks the flag", async () => {
+    const error = await buildFixture(
+      { "tsconfig.json": withFlag, "tsconfig.publish.json": withoutFlag },
+      "./tsconfig.publish.json",
+    );
+
+    expect(error?.message).toContain("tsconfig.publish.json");
+    expect(error?.message).toContain(`must set "compilerOptions.isolatedDeclarations": true`);
+  });
+
+  it("resolves a directory `tsconfig` option to the tsconfig.json inside it", async () => {
+    const error = await buildFixture(
+      { "tsconfig.json": withFlag, "config/tsconfig.json": withoutFlag },
+      "./config",
+    );
+
+    expect(error?.message).toContain(`must set "compilerOptions.isolatedDeclarations": true`);
+  });
+
+  it("skips the check when there is no tsconfig at all", async () => {
+    expect(await buildFixture({})).toBeUndefined();
+  });
+
+  it("skips the check when tsconfig is disabled", async () => {
+    expect(await buildFixture({ "tsconfig.json": withoutFlag }, false)).toBeUndefined();
+  });
+
+  it("inherits the flag through an extends chain", async () => {
+    const error = await buildFixture({
+      "tsconfig.base.json": withFlag,
+      "tsconfig.json": JSON.stringify({ extends: "./tsconfig.base.json" }),
+    });
+
+    expect(error).toBeUndefined();
+  });
+});