ember.nvp 0.0.0 → 0.2.0

package/src/layers/prettier/files/.prettierrc.js

@@ -0,0 +1,4 @@
+export default {
+  printWidth: 100,
+  plugins: ["prettier-plugin-ember-template-tag"],
+};

package/src/layers/prettier/index.js

@@ -0,0 +1,65 @@
+import { packageJson, files } from "ember-apply";
+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
+ *
+ * Adds Prettier for code formatting
+ */
+export default {
+  label: formatLabel("Prettier", "code formatting"),
+  hint: "the defaults",
+
+  /**
+   * @param {import('#utils/project.js').Project} project
+   */
+  async run(project) {
+    await files.applyFolder(join(import.meta.dirname, "files"), project.directory);
+
+    await packageJson.addDevDependencies(
+      await getLatest({
+        prettier: "^3.8.1",
+        "prettier-plugin-ember-template-tag": "^2.1.2",
+      }),
+      project.directory,
+    );
+
+    await packageJson.addScripts(
+      {
+        format: "prettier --write .",
+        "lint:prettier": "prettier --check .",
+      },
+      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/run-tests.mjs

@@ -0,0 +1,30 @@
+import { chromium } from "playwright";
+
+const browser = await chromium.launch();
+const page = await browser.newPage();
+
+page.on("console", (msg) => console.log(msg.text()));
+
+await page.goto("http://localhost:4173/tests");
+
+await page.waitForFunction(
+  () => {
+    const elem = document.getElementById("qunit-testresult");
+    return elem?.classList.contains("complete");
+  },
+  { timeout: 30000 },
+);
+
+const failed = await page.evaluate(() => {
+  const elem = document.getElementById("qunit-testresult");
+  return elem?.querySelector(".failed")?.textContent;
+});
+
+await browser.close();
+
+if (failed && parseInt(failed) > 0) {
+  console.error(`❌ ${failed} test(s) failed`);
+  process.exit(1);
+}
+
+console.log("✅ All tests passed!");

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

@@ -0,0 +1,30 @@
+<!doctype html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <title>Tests</title>
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+  </head>
+  <body>
+    <div id="qunit"></div>
+    <div id="qunit-fixture">
+      <div id="ember-testing-container">
+        <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

@@ -0,0 +1,66 @@
+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 { setup } from "qunit-dom";
+import { setupEmberOnerrorValidation, start as qunitStart } from "ember-qunit";
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-expect-error
+import { getGlobalConfig } from "@embroider/macros/src/addon/runtime";
+
+import Application from "#app/app";
+import config, { enterTestMode } from "#config";
+
+Object.assign(window, {
+  visit,
+  getSettledState,
+  getPendingWaiterState,
+  currentURL,
+  currentRouteName,
+  getOwner,
+  snapshotTimers: (label?: string) => {
+    console.debug(
+      label ?? "snapshotTimers",
+      JSON.parse(
+        JSON.stringify({
+          settled: getSettledState(),
+          waiters: getPendingWaiterState(),
+        }),
+      ),
+    );
+  },
+});
+
+export function start() {
+  enterTestMode();
+
+  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/index.js

@@ -0,0 +1,102 @@
+import { applyFolderTo } from "#utils/fs.js";
+import { getLatest } from "#utils/npm.js";
+import { packageJson, files } from "ember-apply";
+import { join } from "node:path";
+
+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",
+};
+
+/**
+ * @type {import('#types').Layer}
+ */
+export default {
+  label: "QUnit",
+
+  async run(project) {
+    let filePath = join(import.meta.dirname, "files");
+    await applyFolderTo(filePath, project);
+    let ts = await project.hasOrWantsLayer("typescript");
+
+    await packageJson.addDevDependencies(
+      await getLatest({
+        ...deps,
+        ...(ts ? tsDeps : {}),
+      }),
+      project.directory,
+    );
+
+    // Add scripts
+    await packageJson.addScripts(
+      {
+        "build:test": "vite build --mode development",
+        "test:ci": "testem ci --port 0",
+        test: "pnpm build:test && pnpm test:ci",
+      },
+      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);
+  });
+});