ember.nvp 1.9.0 → 1.11.0

package/src/layers/eslint-bundled/index.js

@@ -0,0 +1,172 @@
+import { getLatest } from "#utils/npm.js";
+import { files, packageJson } from "ember-apply";
+import { formatLabel } from "#utils/cli.js";
+import { maybeLintWithConcurrently } from "#consolidators/linting.js";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { hasDevDeps, readManifest } from "#utils/manifest.js";
+import { hasTypeScript6, syncTypeScript6, usesTypeScript7 } from "#utils/typescript.js";
+
+/**
+ * The config package of each preset.
+ *
+ * Each preset also has a folder in `files/`.
+ *
+ * @type {Record<string, Record<string, string>>}
+ */
+const PRESETS = {
+  ember: { "ember-eslint": "^1.0.0" },
+  nvp: { "@nullvoxpopuli/eslint-configs": "^7.0.0" },
+};
+
+/**
+ * @param {Record<string, any>} manifest
+ * @returns {string | undefined}
+ */
+function presetIn(manifest) {
+  for (const [preset, deps] of Object.entries(PRESETS)) {
+    if (hasDevDeps(manifest, deps)) return preset;
+  }
+
+  return undefined;
+}
+
+/**
+ * @param {import('#utils/project.js').Project} project
+ * @returns {string | undefined} undefined when the layer is not selected
+ */
+function wantedPreset(project) {
+  if (!project.wantsLayer("eslint-bundled")) return undefined;
+
+  return project.getLayerOptions("eslint-bundled").preset;
+}
+
+/**
+ * @type {import('#types').Layer}
+ */
+export default {
+  label: formatLabel("ESLint", "encapsulated config"),
+  hint: `Minimal dependencies added to package.json`,
+
+  options: {
+    preset: {
+      type: "select",
+      prompt: "Which ESLint config?",
+      default: "ember",
+      options: [
+        {
+          value: "ember",
+          label: "ember-eslint",
+          hint: "Not official, but follows the official configuration",
+        },
+        {
+          value: "nvp",
+          label: "@nullvoxpopuli/eslint-configs",
+          hint: "NullVoxPopuli's config for apps, libraries, TypeScript, and more",
+        },
+      ],
+      async detect(project) {
+        return presetIn(await readManifest(project));
+      },
+    },
+  },
+
+  async run(project, { preset }) {
+    await files.applyFolder(join(import.meta.dirname, "files", preset), project.directory);
+
+    // Only one preset at a time, so that switching presets leaves nothing behind
+    for (const [other, deps] of Object.entries(PRESETS)) {
+      if (other === preset) continue;
+
+      await packageJson.removeDevDependencies(Object.keys(deps), project.directory);
+    }
+
+    await packageJson.addDevDependencies(
+      await getLatest({
+        ...PRESETS[preset],
+        eslint: "^10.9.1",
+      }),
+      project.directory,
+    );
+
+    await packageJson.addScripts(
+      {
+        "lint:eslint": "eslint . --cache",
+        "lint:eslint:fix": "eslint . --fix",
+      },
+      project.directory,
+    );
+
+    // typescript-eslint needs TypeScript 6
+    await syncTypeScript6(project);
+
+    await maybeLintWithConcurrently(project);
+  },
+
+  /**
+   * @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 (!existsSync(join(project.directory, "eslint.config.js"))) {
+      reasons.push("eslint.config.js is missing");
+
+      if (!explain) return false;
+    }
+
+    let manifest = await packageJson.read(project.directory);
+    let wanted = wantedPreset(project);
+
+    if (!hasDevDeps(manifest, ["eslint"])) {
+      reasons.push("missing required dependency: eslint");
+
+      if (!explain) return false;
+    }
+
+    if (wanted ? !hasDevDeps(manifest, PRESETS[wanted] ?? {}) : !presetIn(manifest)) {
+      reasons.push(`missing the config package of the ${wanted ?? "ember or nvp"} preset`);
+
+      if (!explain) return false;
+    }
+
+    if (usesTypeScript7(project, manifest) && !hasTypeScript6(manifest)) {
+      reasons.push("missing typescript (TypeScript 6) for typescript-eslint");
+
+      if (!explain) return false;
+    }
+
+    let scripts = Object.values(manifest.scripts ?? {}).filter((script) =>
+      script.includes("eslint"),
+    );
+
+    if (!scripts.some((script) => script.includes("--cache"))) {
+      reasons.push("missing eslint script with --cache flag");
+
+      if (!explain) return false;
+    }
+    if (!scripts.some((script) => script.includes("--fix"))) {
+      reasons.push("missing eslint script with --fix flag");
+
+      if (!explain) return false;
+    }
+
+    if (explain) {
+      return {
+        isSetup: reasons.length === 0,
+        reasons,
+      };
+    }
+
+    return reasons.length === 0;
+  },
+};

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

@@ -2,6 +2,7 @@ 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",
@@ -15,6 +16,10 @@ 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}
  */
@@ -30,7 +35,12 @@ export default {
 
     await applyFolderTo(join(import.meta.dirname, "files"), project);
     await packageJson.addDevDependencies(await getLatest(deps), project.directory);
-    await packageJson.addScripts(scripts, project.directory);
+    await packageJson.addScripts(
+      usesTypeScript7(project, await packageJson.read(project.directory))
+        ? typescript7Scripts
+        : scripts,
+      project.directory,
+    );
   },
 
   /**

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);
+}