ember.nvp 0.6.0 → 1.0.0

package/src/layers/typescript/index.js

@@ -9,21 +9,50 @@ const bases = join(import.meta.dirname, "../../bases");
 const appBase = join(bases, "minimal-app/files");
 const libraryBase = join(bases, "minimal-library/files");
 
-const deps = {
-  "@babel/plugin-transform-typescript": "^7.28.5",
-  "@ember/app-tsconfig": "^2.0.0",
+const sharedDeps = {
   "@glint/ember-tsc": "^1.0.8",
   "@glint/template": "^1.7.3",
   "@glint/tsserver-plugin": "^2.0.8",
-  typescript: "^5.9.3",
+  typescript: "^6.0.3",
+};
+
+const appDeps = {
+  // Apps strip types via their own babel.config.js; libraries have no babel
+  // config -- ember() handles type stripping.
+  "@babel/plugin-transform-typescript": "^7.28.5",
+  "@ember/app-tsconfig": "^2.0.0",
+};
+
+const libraryDeps = {
+  "@ember/library-tsconfig": "^2.0.0",
 };
 
+/**
+ * @param {import('#utils/project.js').Project} project
+ */
+function depsFor(project) {
+  return {
+    ...sharedDeps,
+    ...(project.type === "library" ? libraryDeps : appDeps),
+  };
+}
+
 /**
  * @type {import('#types').Layer}
  */
 export default {
   label: "TypeScript",
 
+  /**
+   * Libraries publish declarations, so they are TypeScript unless the
+   * user opts out.
+   *
+   * @param {import('#types').ProjectType} projectType
+   */
+  defaultValue(projectType) {
+    return projectType === "library";
+  },
+
   async run(project) {
     /**
      * if jsconfig exists, switch to tsconfig
@@ -57,7 +86,9 @@ export default {
       reasons.push("tsconfig.json is missing");
     }
 
-    if (!(await hasConfiguredTSBabel(project))) {
+    // Only projects with their own babel config need the TS plugin in it;
+    // without one (libraries), ember() strips types.
+    if (project.hasFile("babel.config.js") && !(await hasConfiguredTSBabel(project))) {
       if (!explain) return false;
 
       reasons.push(`babel.config is missing @babel/plugin-transform-typescript`);
@@ -71,7 +102,7 @@ export default {
       reasons.push(`package.json is missing the "lint:types" script`);
     }
 
-    for (let dep of Object.keys(deps)) {
+    for (let dep of Object.keys(depsFor(project))) {
       if (!manifest.devDependencies?.[dep]) {
         if (!explain) return false;
 
@@ -101,7 +132,7 @@ async function updatePackageJson(project) {
     Object.assign(json.scripts, {
       "lint:types": "ember-tsc --noEmit",
     });
-    Object.assign(json.devDependencies, await getLatest(deps));
+    Object.assign(json.devDependencies, await getLatest(depsFor(project)));
   }, project.directory);
 }
 
@@ -127,6 +158,11 @@ async function addTSConfig(project) {
  * @param {import('#utils/project.js').Project} project
  */
 async function updateBabelConfig(project) {
+  if (!project.hasFile("babel.config.js")) {
+    // No babel config to patch (libraries): ember() strips types.
+    return;
+  }
+
   if (await hasConfiguredTSBabel(project)) {
     return;
   }

package/src/layers/vitest/files/vitest.config.mjs

@@ -1,18 +1,18 @@
+import { ember } from "@nullvoxpopuli/ember-vite";
+import { webdriverio } from "@vitest/browser-webdriverio";
 import { defineConfig } from "vitest/config";
-import { extensions, ember } from "@embroider/vite";
-import { babel } from "@rollup/plugin-babel";
 
 export default defineConfig({
-  plugins: [
-    ember(),
-    babel({
-      babelHelpers: "runtime",
-      extensions: extensions.flatMap((extension) => [extension, ".gts", ".gjs"]),
-    }),
-  ],
+  plugins: [ember()],
   test: {
-    environment: "happy-dom",
-    setupFiles: ["./tests/test-helper.ts"],
     include: ["tests/**/*-test.{js,ts,gjs,gts}"],
+    maxConcurrency: 1,
+    passWithNoTests: true,
+    browser: {
+      provider: webdriverio(),
+      enabled: true,
+      headless: true,
+      instances: [{ browser: "chrome" }],
+    },
   },
 });

package/src/layers/vitest/index.js

@@ -1,7 +1,44 @@
+import { applyFolderTo } from "#utils/fs.js";
 import { getLatest } from "#utils/npm.js";
-import { packageJson, files } from "ember-apply";
+import { packageJson } from "ember-apply";
 import { join } from "node:path";
 
+const deps = {
+  "@ember/test-helpers": "^5.4.3",
+  "@vitest/browser": "^4.1.10",
+  "@vitest/browser-webdriverio": "^4.1.10",
+  "@vitest/ui": "^4.1.10",
+  "ember-vitest": "^0.4.0",
+  vitest: "^4.1.10",
+  webdriverio: "^9.29.1",
+};
+
+// Apps already get these from their base. The babel plugins are resolved
+// by name from the project by @nullvoxpopuli/ember-vite's no-config babel
+// fallback (decorator-transforms is already a base dependency).
+const libraryDeps = {
+  "@babel/plugin-transform-typescript": "^7.28.10",
+  "@nullvoxpopuli/ember-vite": "workspace:*",
+  "babel-plugin-ember-template-compilation": "^4.0.0",
+  vite: "^8.0.14",
+};
+
+const scripts = {
+  test: "vitest run",
+  "test:watch": "vitest",
+  "test:ui": "vitest --ui",
+};
+
+/**
+ * @param {import('#utils/project.js').Project} project
+ */
+function depsFor(project) {
+  return {
+    ...deps,
+    ...(project.type === "library" ? libraryDeps : {}),
+  };
+}
+
 /**
  * @type {import('#types').Layer}
  */
@@ -9,34 +46,11 @@ export default {
   label: "Vitest",
 
   async run(project) {
-    // Apply test files
-    await files.applyFolder(join(import.meta.dirname, "files"), project.directory);
-
-    // Add devDependencies
-    await packageJson.addDevDependencies(
-      await getLatest({
-        "@ember/test-helpers": "^5.4.1",
-        "@ember/test-waiters": "^4.1.1",
-        "@testing-library/dom": "^10.4.1",
-        "ember-vitest": "^0.3.3",
-        vitest: "^4.0.0",
-        "@vitest/ui": "^4.0.0",
-        "@vitest/browser": "^4.0.0",
-        "@vitest/browser-webdriverio": "^4.0.0",
-        webdriverio: "^9.23.2",
-      }),
-      project.directory,
-    );
-
-    // Add scripts
-    await packageJson.addScripts(
-      {
-        test: "vitest run",
-        "test:watch": "vitest",
-        "test:ui": "vitest --ui",
-      },
-      project.directory,
-    );
+    await applyFolderTo(join(import.meta.dirname, "files"), project);
+
+    await packageJson.addDevDependencies(await getLatest(depsFor(project)), project.directory);
+
+    await packageJson.addScripts(scripts, project.directory);
   },
 
   /**
@@ -52,15 +66,39 @@ export default {
    * @returns {Promise<boolean>}
    */
   async isSetup(project, explain) {
-    const reasons = ["Vitest setup detection not implemented"];
+    const reasons = [];
+
+    if (!project.hasFile("vitest.config.mjs")) {
+      if (!explain) return false;
+
+      reasons.push("vitest.config.mjs is missing");
+    }
+
+    let manifest = await packageJson.read(project.directory);
+
+    for (let script of Object.keys(scripts)) {
+      if (!manifest.scripts?.[script]) {
+        if (!explain) return false;
+
+        reasons.push(`package.json is missing the "${script}" script`);
+      }
+    }
+
+    for (let dep of Object.keys(depsFor(project))) {
+      if (!manifest.devDependencies?.[dep]) {
+        if (!explain) return false;
+
+        reasons.push(`package.json is missing ${dep} in devDependencies`);
+      }
+    }
 
     if (explain) {
       return {
-        isSetup: false,
+        isSetup: reasons.length === 0,
         reasons,
       };
     }
 
-    return false;
+    return reasons.length === 0;
   },
 };

package/src/utils/babel.js

@@ -11,11 +11,12 @@ export async function hasConfiguredTSBabel(project) {
 /**
  * @param {import('./project.js').Project} project
  * @param {string} pluginName
+ * @param {string} [configPath] which babel config to inspect
  */
-export async function hasConfiguredPlugin(project, pluginName) {
+export async function hasConfiguredPlugin(project, pluginName, configPath = "babel.config.js") {
   let hasPlugin = false;
 
-  await js.analyze(project.path("babel.config.js"), async ({ root, j }) => {
+  await js.analyze(project.path(configPath), async ({ root, j }) => {
     root
       .find(j.ArrayExpression, {
         elements: {
@@ -33,9 +34,10 @@ export async function hasConfiguredPlugin(project, pluginName) {
 /**
  * @param {import('./project.js').Project} project
  * @param {string} pluginName
+ * @param {string} [configPath] which babel config to modify
  */
-export async function removeConfiguredPlugin(project, pluginName) {
-  await js.transform(project.path("babel.config.js"), async ({ root, j }) => {
+export async function removeConfiguredPlugin(project, pluginName, configPath = "babel.config.js") {
+  await js.transform(project.path(configPath), async ({ root, j }) => {
     root
       .find(j.ArrayExpression, {
         elements: {
@@ -56,9 +58,10 @@ export async function removeConfiguredPlugin(project, pluginName) {
 /**
  * @param {import('./project.js').Project} project
  * @param {string} plugin
+ * @param {string} [configPath] which babel config to modify
  */
-export async function prependPlugin(project, plugin) {
-  await js.transform(project.path("babel.config.js"), async ({ root, j }) => {
+export async function prependPlugin(project, plugin, configPath = "babel.config.js") {
+  await js.transform(project.path(configPath), async ({ root, j }) => {
     root
       .find(j.Property, {
         key: { name: "plugins" },

package/src/utils/fs.js

@@ -3,6 +3,14 @@ import { readFile, glob, mkdir, writeFile } from "node:fs/promises";
 import { join, dirname } from "node:path";
 import { parse as parsePath } from "node:path";
 import { removeTypes } from "./remove-types.js";
+import { rewriteImportsToMatchFiles } from "./rewrite-imports.js";
+
+/**
+ * `**\/*` alone skips dotfiles, which bases legitimately provide
+ * (`.gitignore`, `.env.development`, ...): the extra patterns match
+ * dotfiles at any depth and files inside dot-directories (`.github/...`).
+ */
+const EVERY_FILE = ["**/*", "**/.*", "**/.*/**/*"];
 
 /**
  *
@@ -15,7 +23,10 @@ import { removeTypes } from "./remove-types.js";
  * @param {{to: import('#utils/project.js').Project, process: (data: { entry: string, contents: string }) => string | Promise<void>}} options sub folder within the target project to copy the contents to
  */
 export async function applyFolder(from, options) {
-  for await (const entry of glob("**/*", { exclude: ["**/node_modules", "**/dist"], cwd: from })) {
+  for await (const entry of glob(EVERY_FILE, {
+    exclude: ["**/node_modules", "**/dist"],
+    cwd: from,
+  })) {
     let sourcePath = join(from, entry);
     let targetPath = join(options.to.directory, entry);
     let directory = dirname(targetPath);
@@ -42,6 +53,19 @@ export async function applyFolder(from, options) {
  * @param {import('#utils/project.js').Project} project
  */
 export async function applyFolderTo(from, project) {
+  /**
+   * Files we wrote, to be import-rewritten in a second pass.
+   *
+   * Rewriting has to wait until every file is on disk: it checks which
+   * file a specifier actually resolves to, so rewriting while the folder
+   * is still half-applied depends on iteration order (e.g. `index.js`
+   * pointing at `./utils/math.ts` before `math.js` exists would be left
+   * alone, emitting a broken import).
+   *
+   * @type {string[]}
+   */
+  let written = [];
+
   await applyFolder(from, {
     to: project,
     async process({ entry, contents }) {
@@ -65,9 +89,9 @@ export async function applyFolderTo(from, project) {
              */
             return;
           }
-          let newContents = await removeTypes(ext, contents);
 
-          await writeFile(filePath, newContents);
+          await writeFile(filePath, await removeTypes(ext, contents));
+          written.push(filePath);
           return;
         }
       }
@@ -79,7 +103,24 @@ export async function applyFolderTo(from, project) {
          */
         return;
       }
+
       await writeFile(entry, contents);
+      written.push(entry);
     },
   });
+
+  /**
+   * Imports must always match the emitted files (and carry their
+   * extension). The util decides which files it applies to and is a
+   * no-op for everything else. Files that already existed are the
+   * user's; we leave them alone.
+   */
+  for (let filePath of written) {
+    let contents = await readFile(filePath, "utf-8");
+    let rewritten = rewriteImportsToMatchFiles(contents, filePath);
+
+    if (rewritten !== contents) {
+      await writeFile(filePath, rewritten);
+    }
+  }
 }

package/src/utils/inspector-support.js

@@ -0,0 +1,196 @@
+import { toTree, print, statement } from "ember-estree";
+
+export const INSPECTOR_PACKAGE = "@embroider/legacy-inspector-support";
+
+/**
+ * The `ember-source-4.12` flavor covers ember-source 4.12 and newer,
+ * which includes the ember-source the app base generates with.
+ */
+export const INSPECTOR_ENTRY = `${INSPECTOR_PACKAGE}/ember-source-4.12`;
+
+/**
+ * Modules whose default export is the Application (sub)class an app
+ * extends. The class extending one of these is where inspector support
+ * gets attached.
+ */
+const APPLICATION_MODULES = new Set(["ember-strict-application-resolver", "@ember/application"]);
+
+/** @typedef {import('ember-estree').ASTNode} ASTNode */
+
+/**
+ * @param {unknown} value
+ * @returns {ASTNode | null}
+ */
+function asNode(value) {
+  return value && typeof value === "object" ? /** @type {ASTNode} */ (value) : null;
+}
+
+/**
+ * @param {unknown} value
+ * @returns {string} an Identifier node's name ("" when it isn't one)
+ */
+function nameOf(value) {
+  let node = asNode(value);
+
+  return node?.type === "Identifier" && typeof node.name === "string" ? node.name : "";
+}
+
+/**
+ * @param {ASTNode} importNode
+ * @returns {ASTNode[]}
+ */
+function specifiersOf(importNode) {
+  return Array.isArray(importNode.specifiers)
+    ? /** @type {ASTNode[]} */ (importNode.specifiers)
+    : [];
+}
+
+/**
+ * @param {ASTNode} classNode
+ * @returns {ASTNode[]} the class's members
+ */
+function classMembers(classNode) {
+  let members = asNode(classNode.body)?.body;
+
+  return Array.isArray(members) ? /** @type {ASTNode[]} */ (members) : [];
+}
+
+/**
+ * Everything wiring and detection need to know about the module: its
+ * import declarations, the import from {@link INSPECTOR_PACKAGE} (any
+ * subpath), the class extending an Application import, and that class's
+ * `inspector` member.
+ *
+ * @param {string} code
+ * @param {string} filePath
+ */
+function analyze(code, filePath) {
+  /** @type {ASTNode[]} */
+  let imports = [];
+  /** @type {ASTNode[]} */
+  let classes = [];
+
+  // (not templateOnly, so this is always a FileNode)
+  let tree = /** @type {import('ember-estree').FileNode} */ (
+    toTree(code, {
+      filePath,
+      visitors: {
+        ImportDeclaration: (node) => imports.push(node),
+        ClassDeclaration: (node) => classes.push(node),
+        ClassExpression: (node) => classes.push(node),
+      },
+    })
+  );
+
+  /** @type {Set<string>} */
+  let applicationLocals = new Set();
+  /** @type {ASTNode | null} */
+  let inspectorImport = null;
+
+  for (let node of imports) {
+    let source = asNode(node.source);
+    let from = source?.type === "Literal" && typeof source.value === "string" ? source.value : "";
+
+    if (APPLICATION_MODULES.has(from)) {
+      for (let specifier of specifiersOf(node)) {
+        let local = nameOf(specifier.local);
+
+        if (local) applicationLocals.add(local);
+      }
+    }
+
+    if (from === INSPECTOR_PACKAGE || from.startsWith(`${INSPECTOR_PACKAGE}/`)) {
+      inspectorImport ??= node;
+    }
+  }
+
+  let applicationClass =
+    classes.find((node) => applicationLocals.has(nameOf(node.superClass))) ?? null;
+
+  let inspectorMember = applicationClass
+    ? (classMembers(applicationClass).find(
+        (member) => !member.static && !member.computed && nameOf(member.key) === "inspector",
+      ) ?? null)
+    : null;
+
+  return { tree, imports, inspectorImport, applicationClass, inspectorMember };
+}
+
+/**
+ * Whether the module already wires inspector support: it imports
+ * {@link INSPECTOR_PACKAGE} and its Application class carries the
+ * `inspector` member.
+ *
+ * @param {string} code
+ * @param {string} filePath
+ * @returns {boolean}
+ */
+export function hasInspectorSupport(code, filePath) {
+  let { inspectorImport, inspectorMember } = analyze(code, filePath);
+
+  return Boolean(inspectorImport && inspectorMember);
+}
+
+/**
+ * Wires ember-inspector support into the module containing the app's
+ * Application definition, the way the official app blueprint does:
+ *
+ * ```ts
+ * import setupInspector from "@embroider/legacy-inspector-support/ember-source-4.12";
+ *
+ * export default class App extends Application {
+ *   inspector = setupInspector(this);
+ * }
+ * ```
+ *
+ * The Application definition is found structurally -- any class
+ * (declaration or expression, named, anonymous, or assigned to a
+ * variable) extending a binding imported from an Application-providing
+ * module -- so user-restructured app files are wired the same as
+ * freshly generated ones.
+ *
+ * Idempotent: already-wired (or partially wired) modules keep their
+ * existing import name and member. Returns the code unchanged when
+ * there is nothing to do -- including when no Application definition
+ * can be found.
+ *
+ * @param {string} code
+ * @param {string} filePath
+ * @returns {string}
+ */
+export function wireInspectorSupport(code, filePath) {
+  let { tree, imports, inspectorImport, applicationClass, inspectorMember } = analyze(
+    code,
+    filePath,
+  );
+
+  if (!applicationClass) return code;
+  if (inspectorImport && inspectorMember) return code;
+
+  let localName = "setupInspector";
+
+  if (inspectorImport) {
+    let defaultSpecifier = specifiersOf(inspectorImport).find(
+      (specifier) => specifier.type === "ImportDefaultSpecifier",
+    );
+
+    localName = nameOf(defaultSpecifier?.local);
+
+    // an import that binds no default gives the member nothing to call
+    if (!localName) return code;
+  } else {
+    let body = /** @type {ASTNode[]} */ (tree.program.body);
+    let lastImport = imports.at(-1);
+    let insertAt = lastImport ? body.indexOf(lastImport) + 1 : 0;
+
+    body.splice(insertAt, 0, statement`import ${localName} from "${INSPECTOR_ENTRY}";`);
+  }
+
+  if (!inspectorMember) {
+    let [member] = classMembers(statement`class _ { inspector = ${localName}(this); }`);
+
+    if (member) classMembers(applicationClass).push(member);
+  }
+
+  return print(tree);
+}

package/src/utils/npm.js

@@ -7,6 +7,18 @@ import { join, resolve } from "node:path";
  */
 const CACHE = {};
 
+/**
+ * Local, not-yet-published workspace packages that must be `link:`ed rather
+ * than resolved from the registry. Maps the published package name to its
+ * folder under `packages/`.
+ *
+ * @type {{ [name: string]: string }}
+ */
+const LOCAL_PACKAGES = {
+  "@nullvoxpopuli/ember-vite": "vite",
+  "@nullvoxpopuli/ember-rolldown": "rolldown",
+};
+
 /**
  * @param {{ [name: string]: string }} deps map of dep name to semver range
  */
@@ -25,18 +37,20 @@ export async function getLatest(deps) {
 
       /**
        * HACK FOR CI.
-       * In practice, this package will be published separately, and that version will be used.
-       * Only the local, not-yet-published @nullvoxpopuli/ember-vite package needs the link;
-       * every other dependency must still resolve its real version.
+       * In practice, these packages will be published separately, and those
+       * versions will be used. Only the local, not-yet-published
+       * @nullvoxpopuli/ember-* packages need the link; every other dependency
+       * must still resolve its real version.
        *
        * We use `link:` (a symlink) rather than `file:` (a copy into the store)
-       * on purpose: the package ships TypeScript source, and Node 24 refuses to
+       * on purpose: the packages ship TypeScript source, and Node 24 refuses to
        * strip types for files physically located under node_modules. A symlink
-       * makes Node resolve the realpath to packages/vite (outside node_modules),
+       * makes Node resolve the realpath to packages/* (outside node_modules),
        * so its `.ts` runs directly.
        */
-      if (needsLocalLink && dep === "@nullvoxpopuli/ember-vite") {
-        version = "link:" + resolve(join(import.meta.dirname, "../../packages/vite"));
+      if (needsLocalLink && LOCAL_PACKAGES[dep]) {
+        version =
+          "link:" + resolve(join(import.meta.dirname, "../../packages", LOCAL_PACKAGES[dep]));
       } else {
         if (range == "workspace:*") {
           range = "latest";

package/src/utils/remove-types.js

@@ -9,6 +9,11 @@ import { substringBytes } from "./buffer.js";
  * @returns
  */
 export async function removeTypes(extension, code) {
+  // Nothing to transform (babel-remove-types throws on empty input)
+  if (code.trim() === "") {
+    return code;
+  }
+
   if (extension === ".gts") {
     return await wrappedRemoveTypes(code, babelRemoveTypes);
   }