ember.nvp 1.3.0 → 1.5.0

package/packages/rolldown/src/published-types.test.ts

@@ -0,0 +1,102 @@
+import { execa } from "execa";
+import { readdir, readFile, rm, stat } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { beforeAll, describe, expect, it } from "vitest";
+
+/**
+ * This package's own published shape: consumers write their build config in
+ * TypeScript, so `import { ember } from "@nullvoxpopuli/ember-rolldown"` has to
+ * carry types. Without them it is an implicit `any` (TS7016), and a config file
+ * silently stops being type-checked.
+ */
+const packageDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+
+interface Manifest {
+  dependencies: Record<string, string>;
+  peerDependencies: Record<string, string>;
+  publishConfig: { exports: Record<string, Record<string, string>> };
+}
+
+async function readManifest(): Promise<Manifest> {
+  return JSON.parse(await readFile(path.join(packageDir, "package.json"), "utf8")) as Manifest;
+}
+
+async function exists(relative: string) {
+  return Boolean(await stat(path.join(packageDir, relative)).catch(() => null));
+}
+
+async function declarations() {
+  const files = (await readdir(path.join(packageDir, "dist"))).filter((file) =>
+    file.endsWith(".d.ts"),
+  );
+
+  return Object.fromEntries(
+    await Promise.all(
+      files.map(
+        async (file) =>
+          [file, await readFile(path.join(packageDir, "dist", file), "utf8")] as const,
+      ),
+    ),
+  );
+}
+
+describe("published types", () => {
+  beforeAll(async () => {
+    // `clean` is on, but don't let these assertions depend on that: stale
+    // artifacts from an earlier build satisfy every one of them on their own
+    await rm(path.join(packageDir, "dist"), { recursive: true, force: true });
+    await execa("pnpm", ["build"], { cwd: packageDir });
+  }, 120_000);
+
+  it("every publishConfig export declares types, and they exist", async () => {
+    const manifest = await readManifest();
+    const entries = Object.entries(manifest.publishConfig.exports);
+
+    expect(entries.length).toBeGreaterThan(0);
+
+    for (const [subpath, conditions] of entries) {
+      expect(conditions, `${subpath} declares types`).toHaveProperty("types");
+      expect(await exists(conditions["types"]!), `${subpath} -> ${conditions["types"]}`).toBe(true);
+      expect(await exists(conditions["default"]!), `${subpath} -> ${conditions["default"]}`).toBe(
+        true,
+      );
+    }
+  });
+
+  /**
+   * A declaration may only reach for packages a consumer is guaranteed to have.
+   * Reference a devDependency and there are two ways to lose, both quiet:
+   * the specifier survives and consumers can't resolve it (`skipLibCheck` hides
+   * that, degrading the type to an error type), or the declaration bundler
+   * inlines the whole type surface — a ~200kB copy of rolldown's types, in the
+   * case that prompted this test, nominally distinct from the consumer's own.
+   *
+   * `ember()` returns plugins, so `RolldownPluginLike` exists to keep rolldown
+   * on the devDependency side of that line.
+   */
+  it("declarations only reference packages consumers have", async () => {
+    const manifest = await readManifest();
+    const available = new Set([
+      ...Object.keys(manifest.dependencies),
+      ...Object.keys(manifest.peerDependencies),
+    ]);
+
+    for (const [file, contents] of Object.entries(await declarations())) {
+      const specifiers = [...contents.matchAll(/^import .* from "([^"]+)";$/gm)]
+        .map(([, specifier]) => specifier!)
+        .filter((specifier) => !specifier.startsWith("."));
+
+      for (const specifier of specifiers) {
+        const owner = specifier.startsWith("@")
+          ? specifier.split("/").slice(0, 2).join("/")
+          : specifier.split("/")[0]!;
+
+        expect(available, `${file} imports ${specifier}`).toContain(owner);
+      }
+
+      // an inlined copy of a bundler's types, rather than an import of them
+      expect(contents, `${file} inlines rolldown's types`).not.toMatch(/interface PluginContext/);
+    }
+  });
+});

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

@@ -2,6 +2,7 @@ import { mkdtemp, mkdir, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import path from "node:path";
 import { rolldown } from "rolldown";
+import type { Plugin } from "rolldown";
 import { describe, expect, it } from "vitest";
 
 import { emberTransform } from "./transform.ts";
@@ -15,7 +16,10 @@ import { emberTransform } from "./transform.ts";
  */
 async function bundle(
   files: Record<string, string>,
-  { input = ["index.ts"] }: { input?: string[] } = {},
+  {
+    input = ["index.ts"],
+    plugins = () => [],
+  }: { input?: string[]; plugins?: (dir: string) => Plugin[] } = {},
 ): Promise<string> {
   const dir = await mkdtemp(path.join(tmpdir(), "ember-rolldown-build-"));
 
@@ -29,7 +33,7 @@ async function bundle(
 
   const build = await rolldown({
     input: input.map((relative) => path.join(dir, relative)),
-    plugins: [emberTransform()],
+    plugins: [emberTransform(), ...plugins(dir)],
     external: (id) => !isLocal(id),
     onwarn() {},
   });
@@ -174,6 +178,50 @@ describe("emberTransform (full plugin via rolldown)", () => {
     `);
   });
 
+  it("resolves an absolute .gts specifier imported from a plugin's virtual module", async () => {
+    /**
+     * The shape a code-generating plugin emits: a virtual module (id prefixed
+     * with `\0`, so it exists nowhere on disk) whose generated source imports
+     * real files by absolute path, because it has no directory to be relative
+     * to. `path.dirname` of such an id is `"\0."`, so the specifier must not be
+     * resolved against the importer's directory.
+     */
+    const registry = (dir: string): Plugin[] => {
+      const source = "./registry?virtual=views";
+      const virtualId = `\0${source}`;
+
+      return [
+        {
+          name: "test:virtual-registry",
+          resolveId(id) {
+            return id === source ? virtualId : null;
+          },
+          load(id) {
+            if (id !== virtualId) return null;
+
+            return [
+              `import example from '${path.join(dir, "components/view/example.gts")}';`,
+              `export const views = { example };`,
+            ].join("\n");
+          },
+        },
+      ];
+    };
+
+    const code = await bundle(
+      {
+        "index.ts": `export { views } from './registry?virtual=views';`,
+        "components/view/example.gts": `<template>example</template>`,
+      },
+      { plugins: registry },
+    );
+
+    // The absolutely-specified .gts got compiled and bundled in.
+    expect(code).not.toContain("<template>");
+    expect(code).toContain("template(");
+    expect(code).toContain("example");
+  });
+
   it("compiles a .gts module used directly as an entry (no importer)", async () => {
     const code = await bundle(
       {

package/packages/rolldown/src/transform.ts

@@ -93,7 +93,14 @@ export function emberTransform(): Plugin {
           };
         }
 
-        const fileName = path.join(path.dirname(importer), id);
+        // An absolute specifier already names the file, so it needs no
+        // importer-relative resolution — and joining it onto the importer's
+        // directory would corrupt it. That is not hypothetical: a plugin's
+        // virtual module (id prefixed with `\0`) can generate imports of
+        // on-disk files by absolute path, and `path.dirname("\0./registry")`
+        // is `"\0."`, so joining yields `"\0./Users/.../thing.gts"` — a path
+        // no `existsSync`/`readFile` can accept (it has a null byte in it).
+        const fileName = path.isAbsolute(id) ? id : path.join(path.dirname(importer), id);
 
         if (id.endsWith(".gts")) {
           return {

package/packages/rolldown/tsdown.config.ts

@@ -0,0 +1,11 @@
+import { defineConfig } from "tsdown";
+
+import { emberConfig } from "./src/config.ts";
+
+export default defineConfig({
+  entry: {
+    index: "index.ts",
+    "app-reexports": "src/app-reexports.ts",
+  },
+  plugins: [emberConfig()],
+});

package/src/bases/minimal-app/app.test.ts

@@ -3,8 +3,9 @@ import { generate, build, reapply } from "#test-helpers";
 import { packageJson } from "ember-apply";
 
 import type { Project } from "ember.nvp";
-import { rm } from "node:fs/promises";
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
 import { globSync } from "node:fs";
+import { join } from "node:path";
 
 const expect = hardExpect.soft;
 
@@ -100,6 +101,106 @@ describe("typescript", () => {
   });
 });
 
+const DEBUG_MARKERS = {
+  assert: "__debug_fixture_assert__",
+  deprecate: "__debug_fixture_deprecate__",
+  warn: "__debug_fixture_warn__",
+  isDevelopingApp: "__debug_fixture_is_developing_app__",
+};
+
+/**
+ * Lives in app/services/ so that app.ts's eager
+ * `import.meta.glob("./services/**\/*")` pulls it into the build
+ * without needing to modify any generated files.
+ */
+const debugFixture = `
+import { assert, deprecate, warn } from "@ember/debug";
+import { isDevelopingApp, macroCondition } from "@embroider/macros";
+
+assert("${DEBUG_MARKERS.assert}", true);
+
+deprecate("${DEBUG_MARKERS.deprecate}", true, {
+  id: "debug-fixture",
+  until: "999.0.0",
+  for: "debug-fixture",
+  since: { available: "0.0.0", enabled: "0.0.0" },
+});
+
+warn("${DEBUG_MARKERS.warn}", true, { id: "debug-fixture" });
+
+if (macroCondition(isDevelopingApp())) {
+  console.log("${DEBUG_MARKERS.isDevelopingApp}");
+}
+`;
+
+/**
+ * Only .js files -- the sourcemaps (.map) contain the original
+ * source (with markers) even in production builds.
+ */
+async function builtJavaScript(project: Project): Promise<string> {
+  let files = globSync("dist/**/*.js", { cwd: project.directory });
+
+  hardExpect(files.length, "build produced JS files").toBeGreaterThan(0);
+
+  let contents = await Promise.all(
+    files.map((file) => readFile(join(project.directory, file), "utf-8")),
+  );
+
+  return contents.join("\n");
+}
+
+describe("debug macros", () => {
+  let project: Project;
+
+  beforeAll(async () => {
+    project = await generate({
+      type: "app",
+      layers: ["typescript"],
+    });
+
+    await mkdir(join(project.directory, "app/services"), { recursive: true });
+    await writeFile(join(project.directory, "app/services/debug-fixture.ts"), debugFixture);
+
+    let { exitCode } = await project.install();
+
+    hardExpect(exitCode, "Install succeeds").toBe(0);
+  });
+
+  afterAll(async () => {
+    await rm(project.directory, { recursive: true, force: true });
+  });
+
+  it("has the debug-macros babel plugin", async () => {
+    let content = await project.read("babel.config.js");
+
+    expect(content).toContain("babel-plugin-debug-macros");
+  });
+
+  it("development build keeps debug code", async () => {
+    let { exitCode } = await build(project);
+
+    hardExpect(exitCode).toBe(0);
+
+    let output = await builtJavaScript(project);
+
+    for (let [name, marker] of Object.entries(DEBUG_MARKERS)) {
+      expect(output, `development build contains ${name}`).toContain(marker);
+    }
+  });
+
+  it("production build strips assert(), deprecate(), warn(), and if (macroCondition(isDevelopingApp()))", async () => {
+    let { exitCode } = await build(project, "production");
+
+    hardExpect(exitCode).toBe(0);
+
+    let output = await builtJavaScript(project);
+
+    for (let [name, marker] of Object.entries(DEBUG_MARKERS)) {
+      expect(output, `production build strips ${name}`).not.toContain(marker);
+    }
+  });
+});
+
 describe("javascript", () => {
   let project: Project;
   beforeAll(async () => {

package/src/bases/minimal-app/files/app/app.ts

@@ -10,7 +10,7 @@
  * - https://ember-primitives.pages.dev/6-utils/createService.md
  *   - https://ember-primitives.pages.dev/6-utils/createAsyncService.md
  */
-import Application from "ember-strict-application-resolver";
+import Application from "@ember/application";
 
 export default class App extends Application {
   modules = {

package/src/bases/minimal-app/files/babel.config.js

@@ -1,5 +1,7 @@
 import { buildMacros } from "@embroider/macros/babel";
 
+const isProduction = process.env.NODE_ENV === "production";
+
 const macros = buildMacros({
   configure(config) {
     if (process.env.EMBER_ENV === "test") {
@@ -40,8 +42,22 @@ export default {
         regenerator: false,
       },
     ],
+    isProduction && [
+      "babel-plugin-debug-macros",
+      {
+        debugTools: {
+          isDebug: false,
+          source: "@ember/debug",
+          assertPredicateIndex: 1,
+        },
+        externalizeHelpers: {
+          module: "@ember/debug",
+        },
+      },
+      "@ember/debug stripping",
+    ],
     ...macros.babelMacros,
-  ],
+  ].filter(Boolean),
 
   generatorOpts: {
     compact: false,

package/src/bases/minimal-app/files/package.json

@@ -29,8 +29,7 @@
     "@embroider/router": "^3.0.6",
     "@glimmer/component": "^2.1.1",
     "decorator-transforms": "^2.3.2",
-    "ember-source": "~7.0.0",
-    "ember-strict-application-resolver": "^0.1.0"
+    "ember-source": "~7.2.0"
   },
   "devDependencies": {
     "@babel/core": "^7.29.7",
@@ -44,6 +43,7 @@
     "@glint/tsserver-plugin": "^2.5.5",
     "@nullvoxpopuli/ember-vite": "workspace:*",
     "@rollup/plugin-babel": "^7.1.0",
+    "babel-plugin-debug-macros": "^2.0.0",
     "babel-plugin-ember-template-compilation": "^4.0.0",
     "typescript": "^6.0.3",
     "vite": "^8.0.14"

package/src/bases/minimal-extension/files/app/app.ts

@@ -10,7 +10,7 @@
  * - https://ember-primitives.pages.dev/6-utils/createService.md
  *   - https://ember-primitives.pages.dev/6-utils/createAsyncService.md
  */
-import Application from "ember-strict-application-resolver";
+import Application from "@ember/application";
 
 export default class App extends Application {
   modules = {

package/src/bases/minimal-extension/files/babel.config.js

@@ -1,5 +1,7 @@
 import { buildMacros } from "@embroider/macros/babel";
 
+const isProduction = process.env.NODE_ENV === "production";
+
 const macros = buildMacros({
   configure(config) {
     if (process.env.EMBER_ENV === "test") {
@@ -40,8 +42,22 @@ export default {
         regenerator: false,
       },
     ],
+    isProduction && [
+      "babel-plugin-debug-macros",
+      {
+        debugTools: {
+          isDebug: false,
+          source: "@ember/debug",
+          assertPredicateIndex: 1,
+        },
+        externalizeHelpers: {
+          module: "@ember/debug",
+        },
+      },
+      "@ember/debug stripping",
+    ],
     ...macros.babelMacros,
-  ],
+  ].filter(Boolean),
 
   generatorOpts: {
     compact: false,

package/src/bases/minimal-extension/files/package.json

@@ -30,8 +30,7 @@
     "@embroider/router": "^3.0.6",
     "@glimmer/component": "^2.1.1",
     "decorator-transforms": "^2.3.2",
-    "ember-source": "~7.0.0",
-    "ember-strict-application-resolver": "^0.1.0"
+    "ember-source": "~7.2.0"
   },
   "devDependencies": {
     "@babel/core": "^7.29.7",
@@ -45,6 +44,7 @@
     "@glint/tsserver-plugin": "^2.5.5",
     "@nullvoxpopuli/ember-vite": "workspace:*",
     "@rollup/plugin-babel": "^7.1.0",
+    "babel-plugin-debug-macros": "^2.0.0",
     "babel-plugin-ember-template-compilation": "^4.0.0",
     "typescript": "^6.0.3",
     "vite": "^8.0.14"

package/src/bases/minimal-library/files/package.json

@@ -36,7 +36,7 @@
     "@ember/library-tsconfig": "^2.0.0",
     "@glimmer/component": "^2.1.1",
     "@nullvoxpopuli/ember-rolldown": "workspace:*",
-    "ember-source": "~7.0.0",
+    "ember-source": "~7.2.0",
     "tsdown": "^0.22.7",
     "typescript": "^6.0.3"
   },

package/src/layers/qunit/index.js

@@ -28,7 +28,6 @@ const libraryDeps = {
   "@embroider/macros": "^1.20.3",
   "@nullvoxpopuli/ember-vite": "workspace:*",
   "babel-plugin-ember-template-compilation": "^4.0.0",
-  "ember-strict-application-resolver": "^0.1.0",
   vite: "^8.0.14",
 };
 const libraryTsDeps = {

package/src/layers/qunit/library-files/tests/test-helper.ts

@@ -4,7 +4,7 @@ import * as QUnit from "qunit";
 import { setup } from "qunit-dom";
 import { setupEmberOnerrorValidation, start as qunitStart } from "ember-qunit";
 import { setTesting } from "@embroider/macros";
-import EmberApp from "ember-strict-application-resolver";
+import EmberApp from "@ember/application";
 
 class Router extends EmberRouter {
   location = "none";

package/src/layers/readme/index.js

@@ -21,23 +21,23 @@ An Ember application created with \`ember.nvp\`.
 
 ### Installation
 
-~~~sh
+\`\`\`sh
 ${project.packageManager} install
-~~~
+\`\`\`
 
 ### Development
 
 To start the local development server:
 
-~~~sh
+\`\`\`sh
 ${project.runPrefix} dev
-~~~
+\`\`\`
 
 or
 
-~~~sh
+\`\`\`sh
 ${project.runPrefix} start
-~~~
+\`\`\`
 ${layerDocsMarkdown}`;
 }
 
@@ -61,29 +61,29 @@ A browser extension using Ember created with \`ember.nvp\`.
 
 To start development:
 
-~~~sh
+\`\`\`sh
 ${project.runPrefix} dev
-~~~
+\`\`\`
 
 or
 
-~~~sh
+\`\`\`sh
 ${project.runPrefix} start
-~~~
+\`\`\`
 
 ### Building
 
 To build the library:
 
-~~~sh
+\`\`\`sh
 ${project.runPrefix} build
-~~~
+\`\`\`
 
 or
 
-~~~sh
+\`\`\`sh
 ${project.runPrefix} build:watch
-~~~
+\`\`\`
 ${layerDocsMarkdown}`;
 }
 
@@ -107,9 +107,9 @@ An Ember library/addon created with \`ember.nvp\`.
 
 To build the library:
 
-~~~sh
+\`\`\`sh
 ${project.runPrefix} build
-~~~
+\`\`\`
 ${layerDocsMarkdown}`;
 }
 

package/src/utils/babel.js

@@ -65,15 +65,33 @@ export async function prependPlugin(project, plugin, configPath = "babel.config.
     root
       .find(j.Property, {
         key: { name: "plugins" },
-        value: { type: "ArrayExpression" },
       })
       .forEach(
         /**
          * @param {any} path
          */
         (path) => {
-          path.node.value.elements.unshift(plugin);
+          let array = pluginsArrayOf(path.node.value);
+
+          array?.elements.unshift(plugin);
         },
       );
   });
 }
+
+/**
+ * The plugins value may be the array itself, or the array with
+ * methods chained off of it: `[ ... ].filter(Boolean)`
+ *
+ * @param {any} node
+ * @returns {any | undefined} the underlying ArrayExpression
+ */
+function pluginsArrayOf(node) {
+  if (node.type === "ArrayExpression") return node;
+
+  if (node.type === "CallExpression" && node.callee.type === "MemberExpression") {
+    return pluginsArrayOf(node.callee.object);
+  }
+
+  return undefined;
+}