ember.nvp 1.8.0 → 1.10.0

package/test/ember.nvp/layer-options.test.ts

@@ -0,0 +1,248 @@
+import { describe, it, expect, vi } from "vitest";
+import { stripVTControlCharacters } from "node:util";
+import { Project } from "#utils/project.js";
+import { coreOptions, parseCliArgs, parseLayerOptionsFromParsedArgs } from "#args";
+import { printHelp } from "../../src/cli/help.js";
+import type { DiscoveredLayer } from "#types";
+
+describe("Layer Options Feature", () => {
+  const fakeKitchenSinkLayer: DiscoveredLayer = {
+    name: "fake-kitchen-sink",
+    label: "Fake Kitchen Sink Layer",
+    hint: "demonstrates options",
+    options: {
+      unitCount: {
+        type: "number",
+        prompt: "How many units do you want?",
+        default: 7,
+        validate: (val: number) => (val > 0 ? undefined : "Must be greater than 0"),
+      },
+      customTitle: {
+        type: "text",
+        prompt: "Enter a custom title",
+        default: "My Kitchen Sink",
+        validate: (input: string) =>
+          input.trim().length > 0 ? undefined : "Title cannot be empty",
+      },
+      flavor: {
+        type: "select",
+        prompt: "Which kitchen sink flavor do you prefer?",
+        default: "standard",
+        options: [
+          { label: "Standard", value: "standard", hint: "Regular kitchen sink setup" },
+          { label: "Deluxe", value: "deluxe", hint: "Includes extra features" },
+        ],
+      },
+      enableLogging: {
+        type: "confirm",
+        prompt: "Enable detailed sink logging?",
+        default: true,
+      },
+      extras: {
+        type: "multiselect",
+        prompt: "Select optional kitchen sink extras",
+        default: ["soap-dispenser"],
+        options: [
+          { label: "Soap Dispenser", value: "soap-dispenser", hint: "Built-in pump" },
+          { label: "Garbage Disposal", value: "garbage-disposal", hint: "Continuous feed" },
+        ],
+        validate: (val: string[]) => (val.length > 0 ? undefined : "Select at least one extra"),
+      },
+    },
+    async run(_project, _options = {}) {
+      // noop
+    },
+    async isSetup(_project?: Project, explain?: boolean): Promise<any> {
+      return explain ? { isSetup: true, reasons: [] } : true;
+    },
+  };
+
+  describe("Project.prototype.getLayerOptions", () => {
+    it("returns default values when no user options are provided", () => {
+      const project = new Project("/tmp/test", {
+        name: "my-app",
+        type: "app",
+        path: "/tmp/test",
+        packageManager: "pnpm",
+        layers: [fakeKitchenSinkLayer],
+      });
+
+      expect(project.getLayerOptions("fake-kitchen-sink")).toEqual({
+        unitCount: 7,
+        customTitle: "My Kitchen Sink",
+        flavor: "standard",
+        enableLogging: true,
+        extras: ["soap-dispenser"],
+      });
+    });
+
+    it("overrides default values with user-supplied options", () => {
+      const project = new Project("/tmp/test", {
+        name: "my-app",
+        type: "app",
+        path: "/tmp/test",
+        packageManager: "pnpm",
+        layers: [fakeKitchenSinkLayer],
+        options: {
+          "fake-kitchen-sink": {
+            unitCount: 12,
+            customTitle: "Custom Sink",
+            flavor: "deluxe",
+            enableLogging: false,
+            extras: ["garbage-disposal"],
+          },
+        },
+      });
+
+      expect(project.getLayerOptions("fake-kitchen-sink")).toEqual({
+        unitCount: 12,
+        customTitle: "Custom Sink",
+        flavor: "deluxe",
+        enableLogging: false,
+        extras: ["garbage-disposal"],
+      });
+    });
+
+    it("returns empty object for layers without options or schemas", () => {
+      const plainLayer: DiscoveredLayer = {
+        name: "plain",
+        label: "Plain Layer",
+        async run() {},
+        async isSetup(_project?: Project, explain?: boolean): Promise<any> {
+          return explain ? { isSetup: true, reasons: [] } : true;
+        },
+      };
+
+      const project = new Project("/tmp/test", {
+        name: "my-app",
+        type: "app",
+        path: "/tmp/test",
+        packageManager: "pnpm",
+        layers: [plainLayer],
+      });
+
+      expect(project.getLayerOptions("plain")).toEqual({});
+    });
+  });
+
+  describe("CLI flags", () => {
+    const layers = [fakeKitchenSinkLayer];
+
+    function parse(args: string[]) {
+      return parseLayerOptionsFromParsedArgs(layers, parseCliArgs(args, layers));
+    }
+
+    it("parses layer options for all option types", () => {
+      expect(
+        parse([
+          "--fake-kitchen-sink.unitCount=15",
+          "--fake-kitchen-sink.customTitle",
+          "CLI Title",
+          "--fake-kitchen-sink.flavor",
+          "deluxe",
+          "--no-fake-kitchen-sink.enableLogging",
+          "--fake-kitchen-sink.extras",
+          "soap-dispenser",
+          "--fake-kitchen-sink.extras",
+          "garbage-disposal",
+        ]),
+      ).toEqual({
+        "fake-kitchen-sink": {
+          unitCount: 15,
+          customTitle: "CLI Title",
+          flavor: "deluxe",
+          enableLogging: false,
+          extras: ["soap-dispenser", "garbage-disposal"],
+        },
+      });
+    });
+
+    it("turns a confirm option on without a value", () => {
+      expect(parse(["--fake-kitchen-sink.enableLogging"])).toEqual({
+        "fake-kitchen-sink": { enableLogging: true },
+      });
+    });
+
+    it("parses multiselect options supplied as comma-separated string", () => {
+      expect(parse(["--fake-kitchen-sink.extras", "soap-dispenser, garbage-disposal"])).toEqual({
+        "fake-kitchen-sink": {
+          extras: ["soap-dispenser", "garbage-disposal"],
+        },
+      });
+    });
+
+    it("leaves out options that were not passed", () => {
+      expect(parse(["--name", "my-app"])).toEqual({});
+    });
+
+    it("ignores flags for layers that were not selected", () => {
+      const values = parseCliArgs(["--fake-kitchen-sink.flavor", "deluxe"], layers);
+
+      expect(parseLayerOptionsFromParsedArgs([], values)).toEqual({});
+    });
+
+    it("throws when a confirm option is given a value", () => {
+      expect(() => parseCliArgs(["--fake-kitchen-sink.enableLogging=false"], layers)).toThrow(
+        "Option '--fake-kitchen-sink.enableLogging' does not take an argument",
+      );
+    });
+
+    it("throws on an unknown option", () => {
+      expect(() => parseCliArgs(["--fake-kitchen-sink.unitcount=3"], layers)).toThrow(
+        "Unknown option '--fake-kitchen-sink.unitcount'",
+      );
+    });
+
+    it.each([
+      ["a value that fails validate", "--fake-kitchen-sink.unitCount=-5"],
+      ["a number in hex", "--fake-kitchen-sink.unitCount=0x10"],
+      ["an unlisted select value", "--fake-kitchen-sink.flavor=ultra"],
+      ["an unlisted multiselect value", "--fake-kitchen-sink.extras=invalid-extra"],
+    ])("exits on %s", (_, arg) => {
+      const exitSpy = vi.spyOn(process, "exit").mockImplementation((() => {
+        throw new Error("process.exit called");
+      }) as any);
+
+      try {
+        expect(() => parse([arg])).toThrow("process.exit called");
+        expect(exitSpy).toHaveBeenCalledWith(1);
+      } finally {
+        exitSpy.mockRestore();
+      }
+    });
+  });
+
+  it("lists layer options in --help", () => {
+    const lines: string[] = [];
+    const logSpy = vi.spyOn(console, "log").mockImplementation((line: string) => {
+      lines.push(stripVTControlCharacters(line));
+    });
+
+    try {
+      printHelp(coreOptions, [fakeKitchenSinkLayer]);
+    } finally {
+      logSpy.mockRestore();
+    }
+
+    const output = lines.join("\n");
+
+    expect(output.slice(output.indexOf("Layer Options:"))).toMatchInlineSnapshot(`
+      "Layer Options:
+            --fake-kitchen-sink.unitCount <number>
+            How many units do you want? [default: 7]
+
+            --fake-kitchen-sink.customTitle <string>
+            Enter a custom title [default: "My Kitchen Sink"]
+
+            --fake-kitchen-sink.flavor <string>
+            Which kitchen sink flavor do you prefer? [choices: "standard", "deluxe"] [default: "standard"]
+
+            --[no-]fake-kitchen-sink.enableLogging <boolean>
+            Enable detailed sink logging? [default: true]
+
+            --fake-kitchen-sink.extras <string>
+            Select optional kitchen sink extras [choices: "soap-dispenser", "garbage-disposal"] [default: ["soap-dispenser"]]
+      "
+    `);
+  });
+});

package/test/ember.nvp/layer-readme.test.ts

@@ -71,9 +71,11 @@ describe("layer: readme", () => {
 
         ### TypeScript
 
-        This project uses TypeScript and Glint for static type checking.
+        This project uses TypeScript 7 and [ember-content-mapper](https://github.com/NullVoxPopuli/ember-content-mapper) for static type checking.
 
-        - \`pnpm lint:types\` - Typecheck code with Glint/TypeScript
+        - \`pnpm lint:types\` - Typecheck code with TypeScript
+        - Imports of \`.gts\` and \`.gjs\` modules must include the extension
+        - Editor setup: see [ember-content-mapper's editors section](https://github.com/NullVoxPopuli/ember-content-mapper#editors)
         "
       `);
     });

package/test/ember.nvp/layer-typescript.test.ts

@@ -0,0 +1,302 @@
+import { describe, it, beforeAll, afterAll, expect } from "vitest";
+import { generate, expectIsSetup, layers, reapply } from "#test-helpers";
+import { writeLibrarySource } from "./library-src-fixtures.ts";
+import { execa } from "execa";
+import { rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { packageJson } from "ember-apply";
+
+import type { Project } from "ember.nvp";
+
+const typescript = layers.find((layer) => layer.name === "typescript")!;
+const eslint = layers.find((layer) => layer.name === "eslint-bundled")!;
+
+const typescript6 = { typescript: { version: "6" }, "eslint-bundled": { preset: "nvp" } };
+const typescript7 = { typescript: { version: "7" }, "eslint-bundled": { preset: "nvp" } };
+
+function run(project: Project, command: string) {
+  return execa(command, { cwd: project.directory, shell: true, all: true, reject: false });
+}
+
+async function devDependencies(project: Project): Promise<Record<string, string>> {
+  let manifest = await packageJson.read(project.directory);
+
+  return manifest.devDependencies ?? {};
+}
+
+describe("layer: typescript, version 7", () => {
+  const dirs: string[] = [];
+
+  afterAll(async () => {
+    if (process.env.CI) return;
+
+    for (const dir of dirs) {
+      await rm(dir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
+    }
+  });
+
+  describe("app with eslint", () => {
+    let project: Project;
+
+    beforeAll(async () => {
+      project = await generate({
+        type: "app",
+        layers: ["typescript", "eslint-bundled", "git"],
+        options: typescript7,
+      });
+      dirs.push(project.directory);
+    });
+
+    it("is setup", async () => {
+      await expectIsSetup(project, typescript);
+      await expectIsSetup(project, eslint);
+    });
+
+    it("installs TypeScript 7 as @typescript/native, and TypeScript 6 for typescript-eslint", async () => {
+      let deps = await devDependencies(project);
+
+      expect(deps["@typescript/native"]).toMatch(/^npm:typescript@7\./);
+      expect(deps["typescript"]).toMatch(/^npm:@typescript\/typescript6@6\./);
+      expect(deps).toHaveProperty("ember-content-mapper");
+      expect(deps).not.toHaveProperty("@glint/tsserver-plugin");
+    });
+
+    it("reapplying causes no changes", async () => {
+      await reapply(project, ["typescript", "eslint-bundled", "git"]);
+
+      expect(await project.gitHasDiff()).toBe(false);
+    });
+
+    describe("after install", () => {
+      beforeAll(async () => {
+        let install = await run(project, "pnpm install");
+        expect(install.exitCode, install.all).toBe(0);
+      });
+
+      it("type checking works", async () => {
+        let result = await run(project, "pnpm lint:types");
+
+        expect(result.exitCode, result.all).toBe(0);
+      });
+
+      it("reports template errors in .gts files", async () => {
+        let file = "app/templates/application.gts";
+        let original = await project.read(file);
+
+        await writeFile(
+          join(project.directory, file),
+          `const count: number = 1;\n\n<template>{{count.nope}}</template>\n`,
+        );
+
+        let result = await run(project, "pnpm lint:types");
+
+        await writeFile(join(project.directory, file), original!);
+
+        expect(result.exitCode).not.toBe(0);
+        expect(result.all).toContain("application.gts");
+        expect(result.all).toContain("'nope'");
+      });
+
+      it("linting works", async () => {
+        await run(project, "pnpm lint:eslint --fix");
+
+        let result = await run(project, "pnpm lint:eslint");
+
+        expect(result.exitCode, result.all).toBe(0);
+      });
+
+      it("build works", async () => {
+        let result = await run(project, "pnpm build");
+
+        expect(result.exitCode, result.all).toBe(0);
+      });
+    });
+  });
+
+  describe("app without eslint", () => {
+    let project: Project;
+
+    beforeAll(async () => {
+      project = await generate({ type: "app", layers: ["typescript"], options: typescript7 });
+      dirs.push(project.directory);
+    });
+
+    it("is setup", async () => {
+      await expectIsSetup(project, typescript);
+    });
+
+    it("has no typescript, because nothing needs TypeScript 6", async () => {
+      expect(await devDependencies(project)).not.toHaveProperty("typescript");
+    });
+
+    it("type checking works", async () => {
+      let install = await run(project, "pnpm install");
+      expect(install.exitCode, install.all).toBe(0);
+
+      let result = await run(project, "pnpm lint:types");
+
+      expect(result.exitCode, result.all).toBe(0);
+    });
+  });
+
+  describe.each(["app", "library"] as const)(
+    "migrating a TypeScript 6 %s without eslint",
+    (type) => {
+      let project: Project;
+
+      beforeAll(async () => {
+        let layers = ["typescript", "git"];
+        let before = await generate({
+          type,
+          layers,
+          options: { typescript: { version: "6" } },
+        });
+        dirs.push(before.directory);
+
+        expect(await devDependencies(before)).toHaveProperty("typescript");
+
+        project = await generate({
+          directory: before.directory,
+          type,
+          layers,
+          options: { typescript: { version: "7" } },
+        });
+      });
+
+      it("is setup, and detects version 7", async () => {
+        await expectIsSetup(project, typescript);
+        expect(await typescript.options?.version?.detect?.(project)).toBe("7");
+      });
+
+      it("removes typescript and the tsserver plugin, because nothing needs TypeScript 6", async () => {
+        let manifest = await packageJson.read(project.directory);
+
+        expect(manifest.scripts?.["lint:types"]).toBe("tsc --noEmit --runExternalCode");
+        expect(manifest.devDependencies?.["@typescript/native"]).toMatch(/^npm:typescript@7\./);
+        expect(manifest.devDependencies).not.toHaveProperty("typescript");
+        expect(manifest.devDependencies).not.toHaveProperty("@glint/tsserver-plugin");
+      });
+
+      it("reapplying causes no changes", async () => {
+        await reapply(project, ["typescript", "git"]);
+
+        expect(await project.gitHasDiff()).toBe(false);
+      });
+
+      it("type checking and the build work", async () => {
+        if (type === "library") await writeLibrarySource(project, "typescript");
+
+        let install = await run(project, "pnpm install");
+        expect(install.exitCode, install.all).toBe(0);
+
+        let types = await run(project, "pnpm lint:types");
+        expect(types.exitCode, types.all).toBe(0);
+
+        let build = await run(project, "pnpm build");
+        expect(build.exitCode, build.all).toBe(0);
+      });
+    },
+  );
+
+  describe("migrating a TypeScript 6 app with eslint", () => {
+    let project: Project;
+
+    beforeAll(async () => {
+      let layers = ["typescript", "eslint-bundled", "git"];
+      let before = await generate({ type: "app", layers, options: typescript6 });
+      dirs.push(before.directory);
+
+      project = await generate({
+        directory: before.directory,
+        type: "app",
+        layers,
+        options: typescript7,
+      });
+    });
+
+    it("is setup", async () => {
+      await expectIsSetup(project, typescript);
+      await expectIsSetup(project, eslint);
+    });
+
+    it("detects the version the project uses", async () => {
+      expect(await typescript.options?.version?.detect?.(project)).toBe("7");
+    });
+
+    it("switches to TypeScript 7 and keeps TypeScript 6 for typescript-eslint", async () => {
+      let manifest = await packageJson.read(project.directory);
+
+      expect(manifest.scripts?.["lint:types"]).toBe("tsc --noEmit --runExternalCode");
+      expect(manifest.devDependencies?.["typescript"]).toMatch(/^npm:@typescript\/typescript6@/);
+      expect(manifest.devDependencies).not.toHaveProperty("@glint/tsserver-plugin");
+    });
+
+    it("type checking and linting work", async () => {
+      let install = await run(project, "pnpm install");
+      expect(install.exitCode, install.all).toBe(0);
+
+      let types = await run(project, "pnpm lint:types");
+      expect(types.exitCode, types.all).toBe(0);
+
+      await run(project, "pnpm lint:eslint --fix");
+
+      let lint = await run(project, "pnpm lint:eslint");
+      expect(lint.exitCode, lint.all).toBe(0);
+    });
+  });
+
+  describe("library", () => {
+    let project: Project;
+
+    beforeAll(async () => {
+      project = await generate({
+        type: "library",
+        name: "my-lib",
+        layers: ["typescript", "expect-type"],
+        options: typescript7,
+      });
+      dirs.push(project.directory);
+
+      await writeLibrarySource(project, "typescript");
+
+      let install = await run(project, "pnpm install");
+      expect(install.exitCode, install.all).toBe(0);
+    });
+
+    it("is setup", async () => {
+      await expectIsSetup(project, typescript);
+    });
+
+    it("has no typescript, because nothing needs TypeScript 6", async () => {
+      expect(await devDependencies(project)).not.toHaveProperty("typescript");
+    });
+
+    it("type checking works", async () => {
+      let result = await run(project, "pnpm lint:types");
+
+      expect(result.exitCode, result.all).toBe(0);
+    });
+
+    it("type tests resolve .gts modules", async () => {
+      await writeFile(
+        join(project.directory, "type-tests/greeting.test.ts"),
+        `import { expectTypeOf } from "expect-type";
+import { Greeting, type GreetingSignature } from "../src/index.ts";
+
+expectTypeOf(Greeting).not.toBeAny();
+expectTypeOf<GreetingSignature["Args"]>().toEqualTypeOf<{ name: string }>();
+`,
+      );
+
+      let result = await run(project, "pnpm lint:type-tests");
+
+      expect(result.exitCode, result.all).toBe(0);
+    });
+
+    it("build works", async () => {
+      let result = await run(project, "pnpm build");
+
+      expect(result.exitCode, result.all).toBe(0);
+    });
+  });
+});

package/test/ember.nvp/layers.test.ts

@@ -11,8 +11,8 @@ describe("discoverLayers", () => {
     expect(layerNames).toMatchInlineSnapshot(`
       [
         "are-the-types-wrong",
-        "eslint-bundled-ember",
-        "eslint-bundled-nvp",
+        "eslint-bundled",
+        "expect-type",
         "git",
         "github-actions",
         "inspector-support",

package/test/ember.nvp/permutations/shared.ts

@@ -16,7 +16,7 @@ const RE_APPLY_ONLY = new Set<string>([
 ]);
 const INITIAL_ONLY = new Set<string>([
   // baseline,
-  // "eslint-bundled-nvp",
+  // "eslint-bundled",
   // "typescript"
 ]);
 
@@ -28,11 +28,11 @@ const INITIAL_ONLY = new Set<string>([
  */
 const NOT_YET_SUPPORTED: Record<ProjectType, Set<string>> = {
   // publish checks: apps aren't published
-  app: new Set(["publint", "are-the-types-wrong"]),
+  app: new Set(["publint", "are-the-types-wrong", "expect-type"]),
   // libraries have no Application to wire inspector support into
   library: new Set(["inspector-support"]),
   // publish checks: extensions aren't published (to npm)
-  extension: new Set(["publint", "are-the-types-wrong"]),
+  extension: new Set(["publint", "are-the-types-wrong", "expect-type"]),
   // same toolchain as libraries: no Application either
   "custom-element": new Set(["inspector-support"]),
 };
@@ -45,7 +45,7 @@ const TYPE_FOR_BASE: Record<(typeof bases)[number], ProjectType> = {
 };
 
 /**
- * Layers that only add lint / format / publish checks.
+ * Layers that only add lint / format / type / publish checks.
  *
  * They don't affect the runtime shape of a project,
  * so they permutate among themselves in a small "checks" matrix
@@ -55,12 +55,12 @@ const TYPE_FOR_BASE: Record<(typeof bases)[number], ProjectType> = {
  * so linear cross-group coverage remains.
  */
 const CHECK_LAYERS = new Set<string>([
-  "eslint-bundled-ember",
-  "eslint-bundled-nvp",
+  "eslint-bundled",
   "eslint-ejected",
   "prettier",
   "publint",
   "are-the-types-wrong",
+  "expect-type",
 ]);
 
 type PermutationGroup = "main" | "checks";