ember.nvp 0.5.0 → 0.7.0

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);
   }

package/src/utils/rewrite-imports.js

@@ -0,0 +1,157 @@
+import fs from "node:fs";
+import { dirname, extname } from "node:path";
+import { toTree, print } from "ember-estree";
+import enhancedResolve from "enhanced-resolve";
+
+const { ResolverFactory, CachedInputFileSystem } = enhancedResolve;
+
+/**
+ * The module files this util operates on. Doubles as the candidate
+ * extensions the resolver may append when a request has none (or when we
+ * retry a request without its original extension) -- the single source
+ * of truth for both.
+ */
+const MODULE_EXTENSIONS = [".js", ".gjs", ".ts", ".gts"];
+
+function createResolver() {
+  return ResolverFactory.createResolver({
+    // short-lived cache: files are being written while generation runs
+    fileSystem: new CachedInputFileSystem(fs, 100),
+    useSyncFileSystemCalls: true,
+    extensions: MODULE_EXTENSIONS,
+    // no conditionNames: we only resolve local paths and sub-path
+    // self-imports (whose targets in the emitted `imports` field are
+    // plain strings, which match regardless of conditions)
+  });
+}
+
+/**
+ * Imports must match files. Generation renames files (e.g. type removal
+ * turns .ts into .js), so for every local specifier (./, ../, and #
+ * subpath-imports -- expanded against the project's package.json
+ * `imports` field) we check what actually exists in the emitted project
+ * tree:
+ *
+ * - the specifier resolves to a file and carries an extension? leave it
+ *   alone.
+ * - it resolves but has no extension? append the resolved file's
+ *   extension (fully-specified local imports resolve faster), unless the
+ *   fully-specified form no longer maps to the same file (e.g. `#config`,
+ *   whose `imports` target carries the extension itself).
+ * - it doesn't resolve, but the same specifier with whatever extension
+ *   IS on disk does? rewrite it to that.
+ * - nothing matches? leave it alone -- we can't know better, and the
+ *   project's own build will report it loudly.
+ *
+ * Non-module files are returned untouched.
+ *
+ * ember-estree parses gjs natively and its visitors fire on actual module
+ * specifiers only (static imports, re-exports, and dynamic import()) --
+ * matched specifiers are rewritten on the AST and the File is printed
+ * back out (comments included). Formatting is the project's own concern:
+ * new projects run their configured lint:fix / format right away (it's
+ * in the CLI's "Next steps").
+ *
+ * Files with no specifiers to rewrite are returned untouched.
+ *
+ * @param {string} code the source as it will be emitted
+ * @param {string} emittedPath the path the file will be written to
+ * @returns {string}
+ */
+export function rewriteImportsToMatchFiles(code, emittedPath) {
+  if (!MODULE_EXTENSIONS.includes(extname(emittedPath))) return code;
+
+  let issuerDirectory = dirname(emittedPath);
+  let resolver = createResolver();
+
+  /**
+   * @param {string} specifier
+   * @returns {string | null} the resolved file path, if any
+   */
+  function resolveFrom(specifier) {
+    try {
+      return resolver.resolveSync({}, issuerDirectory, specifier) || null;
+    } catch {
+      return null;
+    }
+  }
+
+  let changed = false;
+
+  /**
+   * @param {unknown} source
+   */
+  function consider(source) {
+    if (!source || typeof source !== "object") return;
+
+    let node = /** @type {import('ember-estree').ASTNode} */ (source);
+
+    if (node.type !== "Literal" || typeof node.value !== "string") return;
+
+    let specifier = node.value;
+    let isLocal =
+      specifier.startsWith("./") || specifier.startsWith("../") || specifier.startsWith("#");
+
+    if (!isLocal) return;
+
+    let currentExtension = extname(specifier);
+    let resolved = resolveFrom(specifier);
+
+    if (resolved) {
+      // fully specified and correct
+      if (currentExtension) return;
+
+      // extensionless: append the resolved file's extension, as long as
+      // the fully-specified form still maps to the same file (`#config`
+      // maps with the extension in the target, so `#config.js` wouldn't)
+      let candidate = specifier + extname(resolved);
+
+      if (resolveFrom(candidate) !== resolved) return;
+
+      rewrite(node, candidate);
+      return;
+    }
+
+    if (!currentExtension) return;
+
+    // check which file actually exists for this specifier
+    let base = specifier.slice(0, -currentExtension.length);
+    let resolvedBase = resolveFrom(base);
+
+    if (!resolvedBase) return;
+
+    let replacement = base + extname(resolvedBase);
+
+    if (replacement === specifier) return;
+
+    rewrite(node, replacement);
+  }
+
+  /**
+   * @param {import('ember-estree').ASTNode} node
+   * @param {string} replacement
+   */
+  function rewrite(node, replacement) {
+    node.value = replacement;
+    node.raw = JSON.stringify(replacement);
+    changed = true;
+  }
+
+  // (not templateOnly, so this is always a FileNode)
+  let tree = /** @type {import('ember-estree').FileNode} */ (
+    toTree(code, {
+      filePath: emittedPath,
+      visitors: {
+        ImportDeclaration: (node) => consider(node.source),
+        ExportNamedDeclaration: (node) => consider(node.source),
+        ExportAllDeclaration: (node) => consider(node.source),
+        // dynamic import()
+        ImportExpression: (node) => consider(node.source),
+      },
+    })
+  );
+
+  if (!changed) return code;
+
+  return print(tree);
+}