ember.nvp 1.8.0 → 1.10.0

package/src/layers/expect-type/files/type-tests/index.test.ts

@@ -0,0 +1,4 @@
+import { expectTypeOf } from "expect-type";
+
+// Replace this with type tests for your library's exports
+expectTypeOf(1).toEqualTypeOf<number>();

package/src/layers/expect-type/files/type-tests/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../tsconfig.json",
+  "include": ["."],
+  "compilerOptions": {
+    "rootDir": "..",
+    "noEmit": true
+  }
+}

package/src/layers/expect-type/index.js

@@ -0,0 +1,114 @@
+import { packageJson } from "ember-apply";
+import { join } from "node:path";
+import { applyFolderTo } from "#utils/fs.js";
+import { getLatest } from "#utils/npm.js";
+import { usesTypeScript7 } from "#utils/typescript.js";
+
+const deps = {
+  "expect-type": "^1.3.0",
+};
+
+/**
+ * The library tsconfig only includes `src` (it drives declaration output),
+ * so type tests get their own project.
+ */
+const scripts = {
+  "lint:type-tests": "ember-tsc --noEmit --project type-tests",
+};
+
+const typescript7Scripts = {
+  "lint:type-tests": "tsc --noEmit --runExternalCode --project type-tests",
+};
+
+/**
+ * @type {import('#types').Layer}
+ */
+export default {
+  label: "expect-type",
+  hint: "type tests for the published API",
+
+  async run(project) {
+    // Apps aren't published, so they have no public API to pin
+    if (!project.isLibrary) return;
+
+    if (!(await project.hasOrWantsLayer("typescript"))) return;
+
+    await applyFolderTo(join(import.meta.dirname, "files"), project);
+    await packageJson.addDevDependencies(await getLatest(deps), project.directory);
+    await packageJson.addScripts(
+      usesTypeScript7(project, await packageJson.read(project.directory))
+        ? typescript7Scripts
+        : scripts,
+      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.isLibrary || !(await project.hasOrWantsLayer("typescript"))) {
+      return explain ? { isSetup: true, reasons } : true;
+    }
+
+    if (!project.hasFile("type-tests/tsconfig.json")) {
+      if (!explain) return false;
+
+      reasons.push("type-tests/tsconfig.json 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(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;
+  },
+
+  /**
+   * @param {import('#utils/project.js').Project} project
+   */
+  async readme(project) {
+    if (!project.isLibrary || !(await project.hasOrWantsLayer("typescript"))) return;
+
+    return `### Type tests
+
+Type tests in \`type-tests/\` use [expect-type](https://github.com/mmkal/expect-type) to pin the types of the public API.
+
+- \`${project.runPrefix} lint:type-tests\` - Typecheck the type tests`;
+  },
+};

package/src/layers/github-actions/app.test.ts

@@ -32,7 +32,7 @@ for (let packageManager of ["pnpm", "npm"] as const) {
     });
 
     it("after emitting with an eslint layer", async () => {
-      await reapply(project, ["eslint-bundled-nvp", "github-actions"]);
+      await reapply(project, ["eslint-bundled", "github-actions"]);
 
       let result = await githubActionsLayer.isSetup(project);
 

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

@@ -8,6 +8,9 @@ const expect = hardExpect.soft;
 
 let githubActionsLayer = layers.find((layer) => layer.name === "github-actions")!;
 
+// version 7 is covered in test/ember.nvp/layer-typescript.test.ts
+const options = { typescript: { version: "6" } };
+
 describe("starting with javascript", () => {
   let project: Project;
 
@@ -15,6 +18,7 @@ describe("starting with javascript", () => {
     project = await generate({
       type: "app",
       packageManager: "pnpm",
+      options,
       layers: ["git"],
     });
   });
@@ -41,6 +45,7 @@ describe("starting with typescript", () => {
     project = await generate({
       type: "app",
       packageManager: "pnpm",
+      options,
       layers: ["typescript", "git"],
     });
   });
@@ -67,6 +72,7 @@ describe("package.json scripts", () => {
     project = await generate({
       type: "app",
       packageManager: "pnpm",
+      options,
       layers: ["typescript", "git"],
     });
 

package/src/layers/typescript/index.js

@@ -1,43 +1,20 @@
-import { js, packageJson } from "ember-apply";
-import { join } from "node:path";
-import { cp } from "node:fs/promises";
-import { existsSync } from "node:fs";
-import { hasConfiguredTSBabel, prependPlugin } from "#utils/babel.js";
-import { getLatest } from "#utils/npm.js";
+import { packageJson } from "ember-apply";
+import { readManifest } from "#utils/manifest.js";
 import { isLibraryType } from "#utils/project-type.js";
-
-const bases = join(import.meta.dirname, "../../bases");
-const appBase = join(bases, "minimal-app/files");
-const extensionBase = join(bases, "minimal-extension/files");
-const libraryBase = join(bases, "minimal-library/files");
-const customElementBase = join(bases, "minimal-custom-element/files");
-
-const sharedDeps = {
-  "@glint/ember-tsc": "^1.0.8",
-  "@glint/template": "^1.7.3",
-  "@glint/tsserver-plugin": "^2.0.8",
-  typescript: "^6.0.3",
-};
-
-const appDeps = {
-  // Apps strip types via their own babel.config.js.
-  // Libraries have no babel config: ember() handles type stripping.
-  "@babel/plugin-transform-typescript": "^7.28.5",
-  "@ember/app-tsconfig": "^2.0.0",
-};
-
-const libraryDeps = {
-  "@ember/library-tsconfig": "^2.0.0",
-};
+import { usesTypeScript7 } from "#utils/typescript.js";
+import * as typescript6 from "./typescript-6.js";
+import * as typescript7 from "./typescript-7.js";
 
 /**
+ * A project that has TypeScript 7 keeps it, even when version 6 is selected.
+ * Nothing moves a project from 7 back to 6 yet.
+ *
  * @param {import('#utils/project.js').Project} project
  */
-function depsFor(project) {
-  return {
-    ...sharedDeps,
-    ...(project.isLibrary ? libraryDeps : appDeps),
-  };
+async function setupFor(project) {
+  let manifest = await packageJson.read(project.directory);
+
+  return usesTypeScript7(project, manifest) ? typescript7 : typescript6;
 }
 
 /**
@@ -56,14 +33,38 @@ export default {
     return isLibraryType(projectType);
   },
 
+  options: {
+    version: {
+      type: "select",
+      prompt: "Which TypeScript version?",
+      default: "7",
+      options: [
+        {
+          value: "7",
+          label: "TypeScript 7.1+",
+          hint: "native tsc, checks .gts and .gjs with ember-content-mapper",
+        },
+        {
+          value: "6",
+          label: "TypeScript 6",
+          hint: "checks with Glint's ember-tsc",
+        },
+      ],
+      async detect(project) {
+        let deps = (await readManifest(project)).devDependencies ?? {};
+
+        if (deps["@typescript/native"]) return "7";
+        if (deps.typescript) return "6";
+
+        return undefined;
+      },
+    },
+  },
+
   async run(project) {
-    /**
-     * TODO:
-     * - if jsconfig exists, switch to tsconfig
-     */
-    await addTSConfig(project);
-    await updatePackageJson(project);
-    await updateBabelConfig(project);
+    let setup = await setupFor(project);
+
+    await setup.run(project);
   },
 
   /**
@@ -79,37 +80,9 @@ export default {
    * @returns {Promise<boolean>}
    */
   async isSetup(project, explain) {
-    const reasons = [];
-
-    if (!project.hasFile("tsconfig.json")) {
-      if (!explain) return false;
-
-      reasons.push("tsconfig.json is missing");
-    }
-
-    // Only projects with their own babel config need the TS plugin in it.
-    // Without one (libraries), ember() strips types.
-    if (project.hasFile("babel.config.js") && !(await hasConfiguredTSBabel(project))) {
-      if (!explain) return false;
-
-      reasons.push(`babel.config is missing @babel/plugin-transform-typescript`);
-    }
-
     let manifest = await packageJson.read(project.directory);
-
-    if (!manifest.scripts?.["lint:types"]) {
-      if (!explain) return false;
-
-      reasons.push(`package.json is missing the "lint:types" 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`);
-      }
-    }
+    let setup = usesTypeScript7(project, manifest) ? typescript7 : typescript6;
+    let reasons = await setup.reasons(project, manifest);
 
     if (explain) {
       return {
@@ -124,82 +97,9 @@ export default {
   /**
    * @param {import('#utils/project.js').Project} project
    */
-  readme(project) {
-    return `### TypeScript
+  async readme(project) {
+    let setup = await setupFor(project);
 
-This project uses TypeScript and Glint for static type checking.
-
-- \`${project.runPrefix} lint:types\` - Typecheck code with Glint/TypeScript`;
+    return setup.readme(project);
   },
 };
-
-/**
- * @param {import('#utils/project.js').Project} project
- */
-async function updatePackageJson(project) {
-  await packageJson.modify(async (json) => {
-    json.scripts ||= {};
-    json.devDependencies ||= {};
-
-    Object.assign(json.scripts, {
-      "lint:types": "ember-tsc --noEmit",
-    });
-    Object.assign(json.devDependencies, await getLatest(depsFor(project)));
-  }, project.directory);
-}
-
-/**
- * Copies the base's tsconfig, unless the project already has one.
- *
- * @param {import('#utils/project.js').Project} project
- */
-async function addTSConfig(project) {
-  if (existsSync(project.path("tsconfig.json"))) {
-    return;
-  }
-
-  if (project.type === "app") {
-    await cp(join(appBase, "tsconfig.json"), project.path("tsconfig.json"));
-    return;
-  }
-
-  if (project.type === "extension") {
-    await cp(join(extensionBase, "tsconfig.json"), project.path("tsconfig.json"));
-    return;
-  }
-
-  if (project.type === "library") {
-    await cp(join(libraryBase, "tsconfig.json"), project.path("tsconfig.json"));
-    return;
-  }
-
-  if (project.type === "custom-element") {
-    await cp(join(customElementBase, "tsconfig.json"), project.path("tsconfig.json"));
-  }
-}
-
-/**
- * @param {import('#utils/project.js').Project} project
- */
-async function updateBabelConfig(project) {
-  if (!project.hasFile("babel.config.js")) {
-    // Nothing to patch (libraries): ember() strips types.
-    return;
-  }
-
-  if (await hasConfiguredTSBabel(project)) {
-    return;
-  }
-
-  await prependPlugin(
-    project,
-    `[
-      "@babel/plugin-transform-typescript",
-      {
-        allExtensions: true,
-        onlyRemoveTypeImports: true,
-        allowDeclareFields: true,
-      },
-    ]`,
-  );
-}

package/src/layers/typescript/typescript-6.js

@@ -0,0 +1,102 @@
+import { packageJson } from "ember-apply";
+import { hasConfiguredTSBabel } from "#utils/babel.js";
+import { getLatest } from "#utils/npm.js";
+import { addTSConfig, updateBabelConfig } from "#utils/typescript.js";
+
+const sharedDeps = {
+  "@glint/ember-tsc": "^1.0.8",
+  "@glint/template": "^1.7.3",
+  "@glint/tsserver-plugin": "^2.0.8",
+  typescript: "^6.0.3",
+};
+
+const appDeps = {
+  // Apps strip types via their own babel.config.js.
+  // Libraries have no babel config: ember() handles type stripping.
+  "@babel/plugin-transform-typescript": "^7.28.5",
+  "@ember/app-tsconfig": "^2.0.0",
+};
+
+const libraryDeps = {
+  "@ember/library-tsconfig": "^2.0.0",
+};
+
+/**
+ * @param {import('#utils/project.js').Project} project
+ */
+function depsFor(project) {
+  return {
+    ...sharedDeps,
+    ...(project.isLibrary ? libraryDeps : appDeps),
+  };
+}
+
+/**
+ * @param {import('#utils/project.js').Project} project
+ */
+export async function run(project) {
+  /**
+   * TODO:
+   * - if jsconfig exists, switch to tsconfig
+   */
+  await addTSConfig(project);
+  await updatePackageJson(project);
+  await updateBabelConfig(project);
+}
+
+/**
+ * @param {import('#utils/project.js').Project} project
+ * @param {Record<string, any>} manifest
+ * @returns {Promise<string[]>} why TypeScript 6 is not set up
+ */
+export async function reasons(project, manifest) {
+  const reasons = [];
+
+  if (!project.hasFile("tsconfig.json")) {
+    reasons.push("tsconfig.json is missing");
+  }
+
+  // Only projects with their own babel config need the TS plugin in it.
+  // Without one (libraries), ember() strips types.
+  if (project.hasFile("babel.config.js") && !(await hasConfiguredTSBabel(project))) {
+    reasons.push(`babel.config is missing @babel/plugin-transform-typescript`);
+  }
+
+  if (!manifest.scripts?.["lint:types"]) {
+    reasons.push(`package.json is missing the "lint:types" script`);
+  }
+
+  for (let dep of Object.keys(depsFor(project))) {
+    if (!manifest.devDependencies?.[dep]) {
+      reasons.push(`package.json is missing ${dep} in devDependencies`);
+    }
+  }
+
+  return reasons;
+}
+
+/**
+ * @param {import('#utils/project.js').Project} project
+ */
+export function readme(project) {
+  return `### TypeScript
+
+This project uses TypeScript and Glint for static type checking.
+
+- \`${project.runPrefix} lint:types\` - Typecheck code with Glint/TypeScript`;
+}
+
+/**
+ * @param {import('#utils/project.js').Project} project
+ */
+async function updatePackageJson(project) {
+  await packageJson.modify(async (json) => {
+    json.scripts ||= {};
+    json.devDependencies ||= {};
+
+    Object.assign(json.scripts, {
+      "lint:types": "ember-tsc --noEmit",
+    });
+    Object.assign(json.devDependencies, await getLatest(depsFor(project)));
+  }, project.directory);
+}

package/src/layers/typescript/typescript-7.js

@@ -0,0 +1,177 @@
+import { packageJson, tsconfig } from "ember-apply";
+import { hasConfiguredTSBabel } from "#utils/babel.js";
+import { getLatest } from "#utils/npm.js";
+import {
+  TYPESCRIPT_7,
+  addTSConfig,
+  hasTypeScript6,
+  syncTypeScript6,
+  updateBabelConfig,
+} from "#utils/typescript.js";
+
+const MAPPER = "ember-content-mapper";
+
+/**
+ * TypeScript 7 does not load tsserver plugins.
+ * The content mapper replaces this one.
+ */
+const TSSERVER_PLUGIN = "@glint/tsserver-plugin";
+
+/**
+ * `@typescript/native` owns the `tsc` bin.
+ * `typescript` is left to eslint, which needs TypeScript 6, see `syncTypeScript6`.
+ *
+ * The mapper transforms with `@glint/ember-tsc` and references its types.
+ * `@glint/template` types the signatures written by hand.
+ */
+const sharedDeps = {
+  "@glint/ember-tsc": "^1.11.0",
+  "@glint/template": "^1.7.3",
+  "@typescript/native": TYPESCRIPT_7,
+  [MAPPER]: "^0.3.1",
+};
+
+const appDeps = {
+  // Apps strip types via their own babel.config.js.
+  // Libraries have no babel config: ember() handles type stripping.
+  "@babel/plugin-transform-typescript": "^7.28.5",
+  "@ember/app-tsconfig": "^2.0.0",
+};
+
+const libraryDeps = {
+  "@ember/library-tsconfig": "^2.0.0",
+};
+
+const scripts = {
+  "lint:types": "tsc --noEmit --runExternalCode",
+};
+
+/**
+ * @param {import('#utils/project.js').Project} project
+ */
+function depsFor(project) {
+  return {
+    ...sharedDeps,
+    ...(project.isLibrary ? libraryDeps : appDeps),
+  };
+}
+
+/**
+ * @param {Record<string, any>} config
+ * @returns {boolean}
+ */
+function hasContentMapper(config) {
+  return (
+    Array.isArray(config.contentMappers) &&
+    config.contentMappers.some((/** @type {any} */ mapper) => mapper?.package === MAPPER)
+  );
+}
+
+/**
+ * @param {import('#utils/project.js').Project} project
+ */
+export async function run(project) {
+  await addTSConfig(project);
+  await updateTSConfig(project);
+  await updatePackageJson(project);
+  await syncTypeScript6(project);
+  await updateBabelConfig(project);
+}
+
+/**
+ * @param {import('#utils/project.js').Project} project
+ * @param {Record<string, any>} manifest
+ * @returns {Promise<string[]>} why TypeScript 7 is not set up
+ */
+export async function reasons(project, manifest) {
+  const reasons = [];
+
+  if (!project.hasFile("tsconfig.json")) {
+    reasons.push("tsconfig.json is missing");
+  } else if (!hasContentMapper(await tsconfig.read(project.directory))) {
+    reasons.push(`tsconfig.json is missing the ${MAPPER} entry in contentMappers`);
+  }
+
+  // Only projects with their own babel config need the TS plugin in it.
+  // Without one (libraries), ember() strips types.
+  if (project.hasFile("babel.config.js") && !(await hasConfiguredTSBabel(project))) {
+    reasons.push(`babel.config is missing @babel/plugin-transform-typescript`);
+  }
+
+  if (!manifest.scripts?.["lint:types"]?.includes("--runExternalCode")) {
+    reasons.push(`package.json's "lint:types" script is missing --runExternalCode`);
+  }
+
+  for (let dep of Object.keys(depsFor(project))) {
+    if (!manifest.devDependencies?.[dep]) {
+      reasons.push(`package.json is missing ${dep} in devDependencies`);
+    }
+  }
+
+  if (manifest.devDependencies?.typescript && !hasTypeScript6(manifest)) {
+    reasons.push(`package.json's typescript must be @typescript/typescript6, or tsc is ambiguous`);
+  }
+
+  return reasons;
+}
+
+/**
+ * @param {import('#utils/project.js').Project} project
+ */
+export function readme(project) {
+  return `### TypeScript
+
+This project uses TypeScript 7 and [ember-content-mapper](https://github.com/NullVoxPopuli/ember-content-mapper) for static type checking.
+
+- \`${project.runPrefix} 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)`;
+}
+
+/**
+ * @param {import('#utils/project.js').Project} project
+ */
+async function updateTSConfig(project) {
+  let config = await tsconfig.read(project.directory);
+
+  if (hasContentMapper(config) && !hasTSServerPlugin(config)) return;
+
+  await tsconfig.modify((json) => {
+    if (!hasContentMapper(json)) {
+      json.contentMappers ||= [];
+      json.contentMappers.push({ package: MAPPER, extensions: [".gts", ".gjs"] });
+    }
+
+    if (hasTSServerPlugin(json)) {
+      json.compilerOptions.plugins = json.compilerOptions.plugins.filter(
+        (/** @type {any} */ plugin) => plugin?.name !== TSSERVER_PLUGIN,
+      );
+
+      if (json.compilerOptions.plugins.length === 0) {
+        delete json.compilerOptions.plugins;
+      }
+    }
+  }, project.directory);
+}
+
+/**
+ * @param {Record<string, any>} config
+ * @returns {boolean}
+ */
+function hasTSServerPlugin(config) {
+  let plugins = config.compilerOptions?.plugins;
+
+  return (
+    Array.isArray(plugins) &&
+    plugins.some((/** @type {any} */ plugin) => plugin?.name === TSSERVER_PLUGIN)
+  );
+}
+
+/**
+ * @param {import('#utils/project.js').Project} project
+ */
+async function updatePackageJson(project) {
+  await packageJson.addScripts(scripts, project.directory);
+  await packageJson.addDevDependencies(await getLatest(depsFor(project)), project.directory);
+  await packageJson.removeDevDependencies([TSSERVER_PLUGIN], project.directory);
+}

package/src/utils/manifest.js

@@ -1,3 +1,4 @@
+import { packageJson } from "ember-apply";
 import { hasAllKeys } from "./object.js";
 
 /**
@@ -7,3 +8,15 @@ import { hasAllKeys } from "./object.js";
 export function hasDevDeps(manifest, listOrObject) {
   return hasAllKeys(manifest.devDependencies ?? {}, listOrObject);
 }
+
+/**
+ * Like `packageJson.read`, but an empty object when there is no package.json yet
+ *
+ * @param {import('./project.js').Project} project
+ * @returns {Promise<Record<string, any>>}
+ */
+export async function readManifest(project) {
+  if (!project.hasFile("package.json")) return {};
+
+  return packageJson.read(project.directory);
+}