ember.nvp 0.1.0 → 0.2.1

package/src/layers/prettier/index.js

@@ -1,8 +1,9 @@
 import { packageJson, files } from "ember-apply";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
+import { join } from "node:path";
+import { existsSync } from "node:fs";
+import { getLatest } from "#utils/npm.js";
+import { formatLabel } from "#utils/cli.js";
+import { maybeLintWithConcurrently } from "#consolidators/linting.js";
 
 /**
  * Prettier Layer
@@ -10,29 +11,55 @@ const __dirname = dirname(fileURLToPath(import.meta.url));
  * Adds Prettier for code formatting
  */
 export default {
-  label: "Prettier",
-  description: "Code formatting with Prettier",
+  label: formatLabel("Prettier", "code formatting"),
+  hint: "the defaults",
 
-  async run({ targetDir }) {
-    // Apply config files
-    await files.applyFolder(join(__dirname, "files"), targetDir);
+  /**
+   * @param {import('#utils/project.js').Project} project
+   */
+  async run(project) {
+    await files.applyFolder(join(import.meta.dirname, "files"), project.directory);
 
-    // Add devDependencies
     await packageJson.addDevDependencies(
-      {
-        prettier: "^3.4.2",
-        "prettier-plugin-ember-template-tag": "^2.0.2",
-      },
-      targetDir,
+      await getLatest({
+        prettier: "^3.8.1",
+        "prettier-plugin-ember-template-tag": "^2.1.2",
+      }),
+      project.directory,
     );
 
-    // Add scripts
     await packageJson.addScripts(
       {
         format: "prettier --write .",
-        "format:check": "prettier --check .",
+        "lint:prettier": "prettier --check .",
       },
-      targetDir,
+      project.directory,
     );
+
+    await maybeLintWithConcurrently(project);
+  },
+
+  /**
+   * @param {import('#utils/project.js').Project} project
+   */
+  async isSetup(project) {
+    let manifest = await packageJson.read(project.directory);
+
+    let scripts = Object.values(manifest.scripts ?? {}).filter((script) =>
+      script.includes("prettier"),
+    );
+
+    if (!scripts.some((script) => script.includes("--write"))) {
+      return false;
+    }
+    if (!scripts.some((script) => script.includes("--check"))) {
+      return false;
+    }
+
+    if (!existsSync(join(project.directory, ".prettierrc.js"))) {
+      return false;
+    }
+
+    return true;
   },
 };

package/src/layers/qunit/app.test.ts

@@ -0,0 +1,90 @@
+import { beforeAll, describe, it, expect as hardExpect, afterAll } from "vitest";
+import { expectIsSetup, generate, layers, reapply } from "#test-helpers";
+
+import type { Project } from "ember.nvp";
+import { rm } from "node:fs/promises";
+
+const expect = hardExpect.soft;
+
+let layer = layers.find((layer) => layer.name === "qunit")!;
+
+describe("starting without qunit", () => {
+  let project: Project;
+
+  beforeAll(async () => {
+    project = await generate({
+      type: "app",
+      packageManager: "pnpm",
+      layers: ["git"],
+    });
+  });
+
+  afterAll(async () => {
+    await rm(project.directory, { recursive: true, force: true });
+  });
+
+  it("applying qunit", async () => {
+    await reapply(project, ["qunit"]);
+
+    await expectIsSetup(project, layer);
+    expect(await project.gitHasDiff()).toBe(false);
+  });
+});
+
+describe("starting with qunit", () => {
+  let project: Project;
+
+  beforeAll(async () => {
+    project = await generate({
+      type: "app",
+      packageManager: "pnpm",
+      layers: ["qunit", "git"],
+    });
+  });
+
+  afterAll(async () => {
+    await rm(project.directory, { recursive: true, force: true });
+  });
+
+  it("reapplying causes no changes", async () => {
+    await reapply(project, ["qunit"]);
+
+    await expectIsSetup(project, layer);
+    expect(await project.gitHasDiff()).toBe(false);
+  });
+});
+
+describe("package.json scripts", () => {
+  let project: Project;
+
+  beforeAll(async () => {
+    project = await generate({
+      type: "app",
+      packageManager: "pnpm",
+      layers: ["qunit", "git"],
+    });
+
+    let { exitCode } = await project.run("pnpm install");
+
+    hardExpect(exitCode).toBe(0);
+
+    await expectIsSetup(project, layer);
+  });
+
+  afterAll(async () => {
+    await rm(project.directory, { recursive: true, force: true });
+  });
+
+  it("running tests works", async () => {
+    {
+      let { exitCode, stderr, stdout } = await project.run("pnpm test");
+
+      if (exitCode !== 0) {
+        console.log(stderr);
+        console.log(stdout);
+      }
+
+      expect(exitCode).toBe(0);
+    }
+  });
+});

package/src/layers/qunit/files/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/files/tests/index.html

@@ -1,14 +1,9 @@
 <!doctype html>
-<html lang="en">
+<html>
   <head>
     <meta charset="utf-8" />
-    <title>__PROJECT_NAME__ Tests</title>
-    <meta name="description" content="" />
+    <title>Tests</title>
     <meta name="viewport" content="width=device-width, initial-scale=1" />
-
-    <link rel="stylesheet" href="https://unpkg.com/qunit@2/qunit/qunit.css" />
-
-    <script type="module" src="/@embroider/virtual/test-support.js"></script>
   </head>
   <body>
     <div id="qunit"></div>
@@ -17,5 +12,19 @@
         <div id="ember-testing"></div>
       </div>
     </div>
+
+    <script src="/testem.js" integrity="" data-embroider-ignore></script>
+    <script type="module">
+      import "ember-testing";
+    </script>
+
+    <script type="module">
+      import { start } from "./test-helper";
+      // traditional test locations
+      import.meta.glob("./**/*.{js,ts,gjs,gts}", { eager: true });
+      // co-located test locations
+      import.meta.glob("./**/*-test.{js,ts,gjs,gts}", { eager: true, base: "../app" });
+      start();
+    </script>
   </body>
 </html>

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

@@ -1,12 +1,70 @@
-import Application from "#app/app.ts";
-import config from "#app/config.ts";
+import { getOwner } from "@ember/owner";
+import {
+  currentRouteName,
+  currentURL,
+  getSettledState,
+  resetOnerror,
+  setApplication,
+  visit,
+} from "@ember/test-helpers";
+import { getPendingWaiterState } from "@ember/test-waiters";
 import * as QUnit from "qunit";
-import { setApplication } from "@ember/test-helpers";
 import { setup } from "qunit-dom";
-import { start } from "ember-qunit";
+import { setupEmberOnerrorValidation, start as qunitStart } from "ember-qunit";
+import { setTesting } from "@embroider/macros";
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-expect-error
+import { getGlobalConfig } from "@embroider/macros/src/addon/runtime";
 
-setApplication(Application.create(config));
+import Application from "#app/app";
+import config from "#config";
 
-setup(QUnit.assert);
+Object.assign(window, {
+  visit,
+  getSettledState,
+  getPendingWaiterState,
+  currentURL,
+  currentRouteName,
+  getOwner,
+  snapshotTimers: (label?: string) => {
+    console.debug(
+      label ?? "snapshotTimers",
+      JSON.parse(
+        JSON.stringify({
+          settled: getSettledState(),
+          waiters: getPendingWaiterState(),
+        }),
+      ),
+    );
+  },
+});
 
-start();
+export function start() {
+  config.locationType = "none";
+  config.APP.rootElement = "#ember-testing";
+  config.APP.autoboot = false;
+  setTesting(true);
+
+  const theMacrosGlobal = getGlobalConfig();
+
+  /**
+   * Caveats:
+   * - https://github.com/embroider-build/embroider/issues/2660
+   * - https://github.com/embroider-build/embroider/issues/1998
+   *
+   */
+  theMacrosGlobal["@embroider/macros"] ||= {};
+  theMacrosGlobal["@embroider/macros"].isTesting ||= true;
+
+  setApplication(Application.create(config.APP));
+  setup(QUnit.assert);
+  setupEmberOnerrorValidation();
+
+  QUnit.moduleStart(({ name }) => console.group(name));
+  QUnit.testStart(({ name }) => console.group(name));
+  QUnit.testDone(() => console.groupEnd());
+  QUnit.moduleDone(() => console.groupEnd());
+  QUnit.testDone(resetOnerror);
+
+  qunitStart();
+}

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

@@ -0,0 +1,26 @@
+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 () {
+  /**
+   * In compile-time mode `isTesting()` is inlined as `false` at build time,
+   * regardless of what the runtime global config says. Only when the test
+   * build runs the macros plugin in runtime mode (see babel.config.js +
+   * EMBER_ENV=test) does `isTesting()` reflect the value set by
+   * `setTesting(true)` in tests/test-helper.ts.
+   */
+  test("isTesting() is true", function (assert) {
+    assert.strictEqual(isTesting(), true);
+  });
+
+  /**
+   * `@ember/debug`'s `assert(description, condition)` is only active when
+   * DEBUG is true (i.e. non-production builds). Assertions are stripped
+   * from production bundles, so this also doubles as a sanity check that
+   * the test build keeps DEBUG enabled.
+   */
+  test("@ember/debug assert throws when the condition is false", function (assert) {
+    assert.throws(() => emberAssert("string", false));
+  });
+});

package/src/layers/qunit/index.js

@@ -1,53 +1,102 @@
+import { applyFolderTo } from "#utils/fs.js";
+import { getLatest } from "#utils/npm.js";
 import { packageJson, files } from "ember-apply";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-import { readFile } from "node:fs/promises";
+import { join } from "node:path";
 
-const __dirname = dirname(fileURLToPath(import.meta.url));
+const deps = {
+  "@ember/test-helpers": "^5.4.1",
+  "@ember/test-waiters": "^4.1.0",
+  "ember-qunit": "^9.0.4",
+  "qunit-theme-ember": "^1.0.0",
+  qunit: "^2.25.0",
+  "qunit-dom": "3.5.0",
+  testem: "3.17.0",
+};
+const tsDeps = {
+  "@types/qunit": "^2.19.12",
+};
 
 /**
- * QUnit Layer
- *
- * Adds QUnit testing support (Ember's traditional testing framework)
+ * @type {import('#types').Layer}
  */
 export default {
   label: "QUnit",
-  description: "Testing with QUnit",
-
-  async run({ targetDir, projectName }) {
-    // Apply test files
-    await files.applyFolder(join(__dirname, "files"), targetDir);
 
-    // Replace __PROJECT_NAME__ in tests/index.html
-    const testHtmlPath = join(targetDir, "tests", "index.html");
-    const content = await readFile(testHtmlPath, "utf-8");
-    const updated = content.replaceAll("__PROJECT_NAME__", projectName);
-    await files.copyFileTo(testHtmlPath, { content: updated });
-
-    // Add dependencies
-    await packageJson.addDependencies(
-      {
-        "@ember/test-helpers": "^4.0.4",
-      },
-      targetDir,
-    );
+  async run(project) {
+    let filePath = join(import.meta.dirname, "files");
+    await applyFolderTo(filePath, project);
+    let ts = await project.hasOrWantsLayer("typescript");
 
-    // Add devDependencies
     await packageJson.addDevDependencies(
-      {
-        qunit: "^2.22.0",
-        "@ember/test-waiters": "^3.1.0",
-        playwright: "^1.49.1",
-      },
-      targetDir,
+      await getLatest({
+        ...deps,
+        ...(ts ? tsDeps : {}),
+      }),
+      project.directory,
     );
 
     // Add scripts
     await packageJson.addScripts(
       {
-        test: "vite build && node ./run-tests.mjs",
+        "build:test": "EMBER_ENV=test NODE_ENV=development vite build --mode development",
+        "test:ci": "testem ci --port 0",
+        test: "pnpm build:test && pnpm test:ci",
       },
-      targetDir,
+      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 depsToCheck = [Object.keys(deps), project.wantsTypeScript ? Object.keys(tsDeps) : ""]
+      .flat()
+      .filter(Boolean);
+
+    let manifest = await packageJson.read(project.directory);
+
+    if (!manifest.scripts?.["build:test"]) {
+      if (!explain) return false;
+
+      reasons.push(`package.json is missing the "build:test" script`);
+    }
+
+    if (!manifest.scripts?.["test:ci"]) {
+      if (!explain) return false;
+
+      reasons.push(`package.json is missing the "test:ci" script`);
+    }
+    if (!manifest.scripts?.["test"]) {
+      if (!explain) return false;
+
+      reasons.push(`package.json is missing the "test" script`);
+    }
+
+    for (let dep of depsToCheck) {
+      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/release-plan/index.js

@@ -0,0 +1,5 @@
+export default {
+  label: "release-plan",
+  description: "release automation so that you can release anywhere",
+  run() {},
+};

package/src/layers/renovate/files/app.json5

@@ -0,0 +1,14 @@
+// Docs:
+// https://docs.renovatebot.com/configuration-options/
+//
+// This config: https://github.com/nullVoxPopuli/renovate
+// - weekly automated updates
+// - requires that packages be released for at least 5 days before opening a PR with that dependency
+// - doesn't constantly rebase open PRs
+// - provides opinionated package rules for reduced PR spam
+// - opens a separate PR to re-roll your lockfile occasionally
+// - appropriate for application development
+{
+  extends: ["github>NullVoxPopuli/renovate:js.json5"],
+  packageRules: [],
+}

package/src/layers/renovate/files/library.json5

@@ -0,0 +1,16 @@
+// Docs:
+// https://docs.renovatebot.com/configuration-options/
+//
+// This config: https://github.com/nullVoxPopuli/renovate
+// - weekly automated updates
+// - requires that packages be released for at least 5 days before opening a PR with that dependency
+// - doesn't constantly rebase open PRs
+// - provides opinionated package rules for reduced PR spam
+// - opens a separate PR to re-roll your lockfile occasionally
+// - appropriate for npm library development
+//   (auto-updating of engines, peerDependencies, and dependencies is disabled
+//    only devDependencies get automatically upgraded in order ot keep your repo stable)
+{
+  extends: ["github>NullVoxPopuli/renovate:npm.json5"],
+  packageRules: [],
+}

package/src/layers/renovate/index.js

@@ -0,0 +1,68 @@
+import { files } from "ember-apply";
+import { existsSync } from "node:fs";
+import { mkdir } from "node:fs/promises";
+import { join } from "node:path";
+
+/**
+ * @type {import('#types').Layer}
+ */
+export default {
+  label: "renovate [bot]",
+  hint: "Automatically have dependencies upgrade for you on a schedule",
+  async run(project) {
+    if (hasRenovateConfig(project)) {
+      return;
+    }
+
+    let source =
+      project.type === "app"
+        ? join(import.meta.dirname, "files/app.json5")
+        : join(import.meta.dirname, "files/library.json5");
+
+    let destination = join(project.directory, ".github/renovate.json5");
+
+    await mkdir(join(project.directory, ".github"), { recursive: true });
+    await files.copyFileTo(destination, { source });
+  },
+
+  /**
+   * @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 = [];
+
+    if (!hasRenovateConfig(project)) {
+      reasons.push("renovate.json5 is missing");
+
+      if (!explain) return false;
+    }
+
+    if (explain) {
+      return {
+        isSetup: reasons.length === 0,
+        reasons,
+      };
+    }
+
+    return reasons.length === 0;
+  },
+};
+
+/**
+ *
+ * @param {import('#utils/project.js').Project} project
+ * @returns
+ */
+function hasRenovateConfig(project) {
+  let destination = join(project.directory, ".github/renovate.json5");
+  return existsSync(destination);
+}

package/src/layers/typescript/app.test.ts

@@ -0,0 +1,93 @@
+import { beforeAll, describe, it, expect as hardExpect, afterAll } from "vitest";
+import { generate, layers, reapply } from "#test-helpers";
+
+import type { Project } from "ember.nvp";
+import { rm } from "node:fs/promises";
+
+const expect = hardExpect.soft;
+
+let githubActionsLayer = layers.find((layer) => layer.name === "github-actions")!;
+
+describe("starting with javascript", () => {
+  let project: Project;
+
+  beforeAll(async () => {
+    project = await generate({
+      type: "app",
+      packageManager: "pnpm",
+      layers: ["git"],
+    });
+  });
+
+  afterAll(async () => {
+    await rm(project.directory, { recursive: true, force: true });
+  });
+
+  it("applying typescript causes no changes", async () => {
+    await reapply(project, ["typescript"]);
+
+    let result = await githubActionsLayer.isSetup(project);
+
+    expect(result).toBe(true);
+    expect(await project.gitHasDiff()).toBe(false);
+    expect(project.hasFile("tsconfig.json")).toBe(true);
+  });
+});
+
+describe("starting with typescript", () => {
+  let project: Project;
+
+  beforeAll(async () => {
+    project = await generate({
+      type: "app",
+      packageManager: "pnpm",
+      layers: ["typescript", "git"],
+    });
+  });
+
+  afterAll(async () => {
+    await rm(project.directory, { recursive: true, force: true });
+  });
+
+  it("reapplying typescript causes no changes", async () => {
+    await reapply(project, ["typescript"]);
+
+    let result = await githubActionsLayer.isSetup(project);
+
+    expect(result).toBe(true);
+    expect(await project.gitHasDiff()).toBe(false);
+    expect(project.hasFile("tsconfig.json")).toBe(true);
+  });
+});
+
+describe("package.json scripts", () => {
+  let project: Project;
+
+  beforeAll(async () => {
+    project = await generate({
+      type: "app",
+      packageManager: "pnpm",
+      layers: ["typescript", "git"],
+    });
+
+    let { exitCode } = await project.run("pnpm install");
+
+    hardExpect(exitCode).toBe(0);
+  });
+
+  afterAll(async () => {
+    await rm(project.directory, { recursive: true, force: true });
+  });
+
+  it("type checking works", async () => {
+    let { exitCode } = await project.run("pnpm lint:types");
+
+    expect(exitCode).toBe(0);
+  });
+
+  it("build works", async () => {
+    let { exitCode } = await project.run("pnpm build");
+
+    expect(exitCode).toBe(0);
+  });
+});