ember.nvp 0.6.0 → 1.0.0

package/src/layers/are-the-types-wrong/index.js

@@ -0,0 +1,74 @@
+import { packageJson } from "ember-apply";
+import { getLatest } from "#utils/npm.js";
+import { addTsdownConfigProperty, hasTsdownConfigProperty } from "#utils/tsdown-config.js";
+
+const deps = {
+  "@arethetypeswrong/core": "^0.18.5",
+};
+
+/**
+ * @type {import('#types').Layer}
+ */
+export default {
+  label: "Are The Types Wrong?",
+  hint: "validate the published declarations on every build",
+
+  async run(project) {
+    // Publish checks: apps aren't published
+    if (project.type !== "library") return;
+
+    // Declarations are the thing being checked
+    if (!(await project.hasOrWantsLayer("typescript"))) return;
+
+    // ESM-only packages don't offer the CJS resolution modes the strict
+    // profile requires
+    await addTsdownConfigProperty(project, "attw", `attw: { profile: "esm-only" }`);
+    await packageJson.addDevDependencies(await getLatest(deps), project.directory);
+  },
+
+  /**
+   * @overload
+   * @param {import('#utils/project.js').Project} project
+   * @param {true} explain
+   * @returns {Promise<{ isSetup: boolean; reasons: string[] }>}
+   */
+  /**
+   * @overload
+   * @param {import('#utils/project.js').Project} project
+   * @param {boolean | undefined} [explain]
+   * @returns {Promise<boolean>}
+   */
+  async isSetup(project, explain) {
+    /** @type {string[]} */
+    const reasons = [];
+
+    // Nothing to set up outside TypeScript libraries, so nothing can be
+    // missing
+    if (project.type !== "library" || !(await project.hasOrWantsLayer("typescript"))) {
+      return explain ? { isSetup: true, reasons } : true;
+    }
+
+    if (!(await hasTsdownConfigProperty(project, "attw"))) {
+      if (!explain) return false;
+
+      reasons.push("tsdown.config.js does not configure attw");
+    }
+
+    let manifest = await packageJson.read(project.directory);
+
+    if (!manifest.devDependencies?.["@arethetypeswrong/core"]) {
+      if (!explain) return false;
+
+      reasons.push("package.json is missing @arethetypeswrong/core in devDependencies");
+    }
+
+    if (explain) {
+      return {
+        isSetup: reasons.length === 0,
+        reasons,
+      };
+    }
+
+    return reasons.length === 0;
+  },
+};

package/src/layers/git/files/gitignore

@@ -1 +1,14 @@
-node_modules
+# compiled output
+/dist/
+/dist-*
+
+# dependencies
+/node_modules/
+
+# misc
+*.local
+/.pnp*
+/.eslintcache
+/coverage/
+/npm-debug.log*
+/testem.log

package/src/layers/git/index.js

@@ -1,5 +1,6 @@
 import { hasGit, initGit, isInGit } from "#utils/git.js";
 import { formatLabel } from "#utils/cli.js";
+import { existsSync } from "node:fs";
 import { join } from "node:path";
 import { cp } from "node:fs/promises";
 
@@ -7,10 +8,7 @@ export default {
   label: formatLabel("git init"),
   hint: "set up this project as a fresh git repository",
 
-  /**
-   * @param {import('#utils/project.js').Project} project
-   */
-  async defaultValue(project) {
+  async defaultValue() {
     return !isInGit();
   },
 
@@ -27,7 +25,10 @@ export default {
       let gitIgnorePath = join(import.meta.dirname, "files/gitignore");
       let targetPath = join(project.directory, ".gitignore");
 
-      await cp(gitIgnorePath, targetPath, { force: true });
+      // Don't clobber a .gitignore provided by a base or by the user
+      if (!existsSync(targetPath)) {
+        await cp(gitIgnorePath, targetPath);
+      }
     }
 
     return initOk;

package/src/layers/github-actions/index.js

@@ -69,7 +69,7 @@ concurrency:
   cancel-in-progress: true`;
 
 const lint = {
-  npm: `lint:
+  npm: `  lint:
     name: "Lints"
     runs-on: ubuntu-latest
     steps:
@@ -78,18 +78,20 @@ const lint = {
         with:
           node-version: 24
       - run: npm install
-      - run: npm run lint`,
+      - run: npm run lint
+`,
   pnpm: `  lint:
     name: "Lints"
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v6
       - uses: wyvox/action-setup-pnpm@v3
-      - run: pnpm lint`,
+      - run: pnpm lint
+`,
 };
 
 const test = {
-  npm: `test:
+  npm: `  test:
     name: "Tests"
     runs-on: ubuntu-latest
     steps:
@@ -98,14 +100,16 @@ const test = {
         with:
           node-version: 24
       - run: npm install
-      - run: npm test`,
+      - run: npm test
+`,
   pnpm: `  test:
     name: "Tests"
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v6
       - uses: wyvox/action-setup-pnpm@v3
-      - run: pnpm test`,
+      - run: pnpm test
+`,
 };
 
 /**
@@ -175,7 +179,7 @@ async function addOrUpdateLints(project, file) {
     file += "\n\njobs:\n";
   }
 
-  return file + "\n" + lint[project.desires.packageManager];
+  return file + lint[project.desires.packageManager];
 }
 
 /**
@@ -196,5 +200,5 @@ async function addOrUpdateTests(project, file) {
     file += "\n\njobs:\n";
   }
 
-  return file + "\n" + test[project.desires.packageManager];
+  return file + test[project.desires.packageManager];
 }

package/src/layers/index.js

@@ -4,7 +4,7 @@ import { join } from "node:path";
 /**
  * @type {Set<string>}
  */
-export const TODO = new Set(["vitest", "release-plan", "eslint-ejected"]);
+export const TODO = new Set(["release-plan", "eslint-ejected"]);
 
 /**
  * @returns {Promise<Array<import('#types').DiscoveredLayer>>}

package/src/layers/inspector-support/index.js

@@ -0,0 +1,101 @@
+import { packageJson } from "ember-apply";
+import { writeFile } from "node:fs/promises";
+import { getLatest } from "#utils/npm.js";
+import {
+  hasInspectorSupport,
+  INSPECTOR_PACKAGE,
+  wireInspectorSupport,
+} from "#utils/inspector-support.js";
+
+const deps = {
+  [INSPECTOR_PACKAGE]: "^0.1.3",
+};
+
+const APPLICATION_FILES = ["app/app.ts", "app/app.js"];
+
+/**
+ * @param {import('#utils/project.js').Project} project
+ * @returns {string | undefined}
+ */
+function findApplicationFile(project) {
+  return APPLICATION_FILES.find((file) => project.hasFile(file));
+}
+
+/**
+ * @type {import('#types').Layer}
+ */
+export default {
+  label: "Inspector Support",
+  hint: "Make the app inspectable by the Ember Inspector browser extension",
+
+  async run(project) {
+    let file = findApplicationFile(project);
+
+    // libraries have no Application to wire
+    if (!file) return;
+
+    let path = project.path(file);
+    let code = (await project.read(file)) ?? "";
+    let wired = wireInspectorSupport(code, path);
+
+    if (wired !== code) {
+      await writeFile(path, wired);
+    }
+
+    // the dependency is only useful once the Application actually got
+    // wired (the codemod leaves unrecognized Application shapes alone)
+    if (!hasInspectorSupport(wired, path)) return;
+
+    await packageJson.addDevDependencies(await getLatest(deps), project.directory);
+  },
+
+  /**
+   * @overload
+   * @param {import('#utils/project.js').Project} project
+   * @param {true} explain
+   * @returns {Promise<{ isSetup: boolean; reasons: string[] }>}
+   */
+  /**
+   * @overload
+   * @param {import('#utils/project.js').Project} project
+   * @param {boolean | undefined} [explain]
+   * @returns {Promise<boolean>}
+   */
+  async isSetup(project, explain) {
+    const reasons = [];
+    let file = findApplicationFile(project);
+
+    if (!file) {
+      if (!explain) return false;
+
+      reasons.push("there is no Application to wire (no app/app.ts or app/app.js)");
+    } else {
+      let code = (await project.read(file)) ?? "";
+
+      if (!hasInspectorSupport(code, project.path(file))) {
+        if (!explain) return false;
+
+        reasons.push(`${file} does not wire ${INSPECTOR_PACKAGE} into the Application`);
+      }
+    }
+
+    let manifest = await packageJson.read(project.directory);
+
+    for (let dep of Object.keys(deps)) {
+      if (!manifest.devDependencies?.[dep]) {
+        if (!explain) return false;
+
+        reasons.push(`package.json is missing ${dep} in devDependencies`);
+      }
+    }
+
+    if (explain) {
+      return {
+        isSetup: reasons.length === 0,
+        reasons,
+      };
+    }
+
+    return reasons.length === 0;
+  },
+};

package/src/layers/prettier/files/.prettierignore

@@ -8,6 +8,10 @@
 # dependencies
 /node_modules/
 
+# lockfiles
+pnpm-lock.yaml
+package-lock.json
+
 # misc
 /.env*
 /.vite/

package/src/layers/publint/index.js

@@ -0,0 +1,68 @@
+import { packageJson } from "ember-apply";
+import { getLatest } from "#utils/npm.js";
+import { addTsdownConfigProperty, hasTsdownConfigProperty } from "#utils/tsdown-config.js";
+
+const deps = {
+  publint: "^0.3.21",
+};
+
+/**
+ * @type {import('#types').Layer}
+ */
+export default {
+  label: "publint",
+  hint: "validate the publishable package shape on every build",
+
+  async run(project) {
+    // Publish checks: apps aren't published
+    if (project.type !== "library") return;
+
+    await addTsdownConfigProperty(project, "publint", "publint: true");
+    await packageJson.addDevDependencies(await getLatest(deps), project.directory);
+  },
+
+  /**
+   * @overload
+   * @param {import('#utils/project.js').Project} project
+   * @param {true} explain
+   * @returns {Promise<{ isSetup: boolean; reasons: string[] }>}
+   */
+  /**
+   * @overload
+   * @param {import('#utils/project.js').Project} project
+   * @param {boolean | undefined} [explain]
+   * @returns {Promise<boolean>}
+   */
+  async isSetup(project, explain) {
+    /** @type {string[]} */
+    const reasons = [];
+
+    // Nothing to set up outside libraries, so nothing can be missing
+    if (project.type !== "library") {
+      return explain ? { isSetup: true, reasons } : true;
+    }
+
+    if (!(await hasTsdownConfigProperty(project, "publint"))) {
+      if (!explain) return false;
+
+      reasons.push("tsdown.config.js does not configure publint");
+    }
+
+    let manifest = await packageJson.read(project.directory);
+
+    if (!manifest.devDependencies?.["publint"]) {
+      if (!explain) return false;
+
+      reasons.push("package.json is missing publint in devDependencies");
+    }
+
+    if (explain) {
+      return {
+        isSetup: reasons.length === 0,
+        reasons,
+      };
+    }
+
+    return reasons.length === 0;
+  },
+};

package/src/layers/qunit/files/tests/unit/macros-test.ts

@@ -1,6 +1,6 @@
+import { assert as emberAssert } from "@ember/debug";
 import { module, test } from "qunit";
 import { isTesting } from "@embroider/macros";
-import { assert as emberAssert } from "@ember/debug";
 
 module("@embroider/macros | runtime mode in tests", function () {
   /**
@@ -11,7 +11,7 @@ module("@embroider/macros | runtime mode in tests", function () {
    * `setTesting(true)` in tests/test-helper.ts.
    */
   test("isTesting() is true", function (assert) {
-    assert.strictEqual(isTesting(), true);
+    assert.true(isTesting());
   });
 
   /**

package/src/layers/qunit/index.js

@@ -1,6 +1,7 @@
 import { applyFolderTo } from "#utils/fs.js";
 import { getLatest } from "#utils/npm.js";
-import { packageJson, files } from "ember-apply";
+import { hasConfiguredPlugin, prependPlugin, removeConfiguredPlugin } from "#utils/babel.js";
+import { packageJson } from "ember-apply";
 import { join } from "node:path";
 
 const deps = {
@@ -16,6 +17,41 @@ const tsDeps = {
   "@types/qunit": "^2.19.12",
 };
 
+/**
+ * Libraries don't have the app base's vite stack, so the test build
+ * brings the pieces the generated configs and test-helper import
+ * directly. Everything else (babel itself, the embroider machinery)
+ * comes with @nullvoxpopuli/ember-vite.
+ */
+const libraryDeps = {
+  ...deps,
+  "@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 = {
+  ...tsDeps,
+  "@babel/plugin-transform-typescript": "^7.28.5",
+};
+
+const TEST_BABEL_CONFIG = "config/test/babel.config.js";
+
+/**
+ * @param {import('#utils/project.js').Project} project
+ */
+function depsFor(project) {
+  return project.type === "library" ? libraryDeps : deps;
+}
+
+/**
+ * @param {import('#utils/project.js').Project} project
+ */
+function tsDepsFor(project) {
+  return project.type === "library" ? libraryTsDeps : tsDeps;
+}
+
 /**
  * @type {import('#types').Layer}
  */
@@ -23,14 +59,23 @@ export default {
   label: "QUnit",
 
   async run(project) {
-    let filePath = join(import.meta.dirname, "files");
-    await applyFolderTo(filePath, project);
+    let isLibrary = project.type === "library";
     let ts = await project.hasOrWantsLayer("typescript");
 
+    if (isLibrary) {
+      await addSourceImports(project);
+    }
+
+    await applyFolderTo(join(import.meta.dirname, isLibrary ? "library-files" : "files"), project);
+
+    if (isLibrary) {
+      await syncTestBabelConfig(project, ts);
+    }
+
     await packageJson.addDevDependencies(
       await getLatest({
-        ...deps,
-        ...(ts ? tsDeps : {}),
+        ...depsFor(project),
+        ...(ts ? tsDepsFor(project) : {}),
       }),
       project.directory,
     );
@@ -39,7 +84,9 @@ export default {
     await packageJson.addScripts(
       {
         "build:test": "EMBER_ENV=test NODE_ENV=development vite build --mode development",
-        "test:ci": "testem ci --port 0",
+        "test:ci": isLibrary
+          ? "testem ci --file config/test/testem.cjs --port 0"
+          : "testem ci --port 0",
         test: "pnpm build:test && pnpm test:ci",
       },
       project.directory,
@@ -59,7 +106,10 @@ export default {
    */
   async isSetup(project, explain) {
     const reasons = [];
-    let depsToCheck = [Object.keys(deps), project.wantsTypeScript ? Object.keys(tsDeps) : ""]
+    let depsToCheck = [
+      Object.keys(depsFor(project)),
+      project.wantsTypeScript ? Object.keys(tsDepsFor(project)) : "",
+    ]
       .flat()
       .filter(Boolean);
 
@@ -100,3 +150,53 @@ export default {
     return reasons.length === 0;
   },
 };
+
+/**
+ * Tests import the library's source (not its published dist), so the
+ * `#src/*` subpath must exist before the test files are applied --
+ * applying rewrites their import extensions by resolving each specifier
+ * through this mapping.
+ *
+ * @param {import('#utils/project.js').Project} project
+ */
+async function addSourceImports(project) {
+  await packageJson.modify((json) => {
+    json.imports ||= {};
+    json.imports["#src/*"] ||= "./src/*";
+  }, project.directory);
+}
+
+/**
+ * The test babel config is the qunit layer's own (a root babel config,
+ * when a library has one, belongs to the publish build), so this layer
+ * also keeps the config's TypeScript handling in step with the project:
+ * the shipped config carries the TS plugin, which must not survive in a
+ * JavaScript project, and must come back when a project adopts the
+ * typescript layer later.
+ *
+ * @param {import('#utils/project.js').Project} project
+ * @param {boolean} ts
+ */
+async function syncTestBabelConfig(project, ts) {
+  if (!ts) {
+    await removeConfiguredPlugin(project, "@babel/plugin-transform-typescript", TEST_BABEL_CONFIG);
+    return;
+  }
+
+  if (await hasConfiguredPlugin(project, "@babel/plugin-transform-typescript", TEST_BABEL_CONFIG)) {
+    return;
+  }
+
+  await prependPlugin(
+    project,
+    `[
+      "@babel/plugin-transform-typescript",
+      {
+        allExtensions: true,
+        onlyRemoveTypeImports: true,
+        allowDeclareFields: true,
+      },
+    ]`,
+    TEST_BABEL_CONFIG,
+  );
+}

package/src/layers/qunit/library-files/config/test/babel.config.js

@@ -0,0 +1,41 @@
+import { buildMacros } from "@embroider/macros/babel";
+
+const macros = buildMacros({
+  configure(config) {
+    if (process.env.EMBER_ENV === "test") {
+      config.enableRuntimeMode();
+    }
+  },
+});
+
+export default {
+  plugins: [
+    [
+      "@babel/plugin-transform-typescript",
+      {
+        allExtensions: true,
+        onlyRemoveTypeImports: true,
+        allowDeclareFields: true,
+      },
+    ],
+    [
+      "babel-plugin-ember-template-compilation",
+      {
+        transforms: [...macros.templateMacros],
+      },
+    ],
+    [
+      "module:decorator-transforms",
+      {
+        runtime: {
+          import: import.meta.resolve("decorator-transforms/runtime-esm"),
+        },
+      },
+    ],
+    ...macros.babelMacros,
+  ],
+
+  generatorOpts: {
+    compact: false,
+  },
+};

package/src/layers/qunit/library-files/config/test/testem.cjs

@@ -0,0 +1,26 @@
+"use strict";
+
+if (typeof module !== "undefined") {
+  module.exports = {
+    test_page: "tests/index.html?hidepassed",
+    cwd: "dist",
+    disable_watching: true,
+    launch_in_ci: ["Chrome"],
+    launch_in_dev: ["Chrome"],
+    browser_start_timeout: 120,
+    browser_args: {
+      Chrome: {
+        ci: [
+          // --no-sandbox is needed when running Chrome inside a container
+          process.env.CI ? "--no-sandbox" : null,
+          "--headless",
+          "--disable-dev-shm-usage",
+          "--disable-software-rasterizer",
+          "--mute-audio",
+          "--remote-debugging-port=0",
+          "--window-size=1440,900",
+        ].filter(Boolean),
+      },
+    },
+  };
+}

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

@@ -0,0 +1,36 @@
+import EmberRouter from "@ember/routing/router";
+import { resetOnerror, setApplication } from "@ember/test-helpers";
+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";
+
+class Router extends EmberRouter {
+  location = "none";
+  rootURL = "/";
+}
+
+Router.map(function () {});
+
+class TestApp extends EmberApp {
+  modules = {
+    "./router": Router,
+  };
+}
+
+export function start() {
+  setTesting(true);
+  setApplication(
+    TestApp.create({
+      autoboot: false,
+      rootElement: "#ember-testing",
+    }),
+  );
+  setup(QUnit.assert);
+  setupEmberOnerrorValidation();
+
+  QUnit.testDone(resetOnerror);
+
+  qunitStart();
+}

package/src/layers/qunit/library-files/vite.config.mjs

@@ -0,0 +1,6 @@
+import { defineConfig } from "vite";
+import { ember } from "@nullvoxpopuli/ember-vite";
+
+export default defineConfig({
+  plugins: [ember({ babel: { configFile: "./config/test/babel.config.js" } })],
+});