ember.nvp 0.6.0 → 1.0.0

package/src/utils/rewrite-imports.js

@@ -0,0 +1,157 @@
+import fs from "node:fs";
+import { dirname, extname } from "node:path";
+import { toTree, print } from "ember-estree";
+import enhancedResolve from "enhanced-resolve";
+
+const { ResolverFactory, CachedInputFileSystem } = enhancedResolve;
+
+/**
+ * The module files this util operates on. Doubles as the candidate
+ * extensions the resolver may append when a request has none (or when we
+ * retry a request without its original extension) -- the single source
+ * of truth for both.
+ */
+const MODULE_EXTENSIONS = [".js", ".gjs", ".ts", ".gts"];
+
+function createResolver() {
+  return ResolverFactory.createResolver({
+    // short-lived cache: files are being written while generation runs
+    fileSystem: new CachedInputFileSystem(fs, 100),
+    useSyncFileSystemCalls: true,
+    extensions: MODULE_EXTENSIONS,
+    // no conditionNames: we only resolve local paths and sub-path
+    // self-imports (whose targets in the emitted `imports` field are
+    // plain strings, which match regardless of conditions)
+  });
+}
+
+/**
+ * Imports must match files. Generation renames files (e.g. type removal
+ * turns .ts into .js), so for every local specifier (./, ../, and #
+ * subpath-imports -- expanded against the project's package.json
+ * `imports` field) we check what actually exists in the emitted project
+ * tree:
+ *
+ * - the specifier resolves to a file and carries an extension? leave it
+ *   alone.
+ * - it resolves but has no extension? append the resolved file's
+ *   extension (fully-specified local imports resolve faster), unless the
+ *   fully-specified form no longer maps to the same file (e.g. `#config`,
+ *   whose `imports` target carries the extension itself).
+ * - it doesn't resolve, but the same specifier with whatever extension
+ *   IS on disk does? rewrite it to that.
+ * - nothing matches? leave it alone -- we can't know better, and the
+ *   project's own build will report it loudly.
+ *
+ * Non-module files are returned untouched.
+ *
+ * ember-estree parses gjs natively and its visitors fire on actual module
+ * specifiers only (static imports, re-exports, and dynamic import()) --
+ * matched specifiers are rewritten on the AST and the File is printed
+ * back out (comments included). Formatting is the project's own concern:
+ * new projects run their configured lint:fix / format right away (it's
+ * in the CLI's "Next steps").
+ *
+ * Files with no specifiers to rewrite are returned untouched.
+ *
+ * @param {string} code the source as it will be emitted
+ * @param {string} emittedPath the path the file will be written to
+ * @returns {string}
+ */
+export function rewriteImportsToMatchFiles(code, emittedPath) {
+  if (!MODULE_EXTENSIONS.includes(extname(emittedPath))) return code;
+
+  let issuerDirectory = dirname(emittedPath);
+  let resolver = createResolver();
+
+  /**
+   * @param {string} specifier
+   * @returns {string | null} the resolved file path, if any
+   */
+  function resolveFrom(specifier) {
+    try {
+      return resolver.resolveSync({}, issuerDirectory, specifier) || null;
+    } catch {
+      return null;
+    }
+  }
+
+  let changed = false;
+
+  /**
+   * @param {unknown} source
+   */
+  function consider(source) {
+    if (!source || typeof source !== "object") return;
+
+    let node = /** @type {import('ember-estree').ASTNode} */ (source);
+
+    if (node.type !== "Literal" || typeof node.value !== "string") return;
+
+    let specifier = node.value;
+    let isLocal =
+      specifier.startsWith("./") || specifier.startsWith("../") || specifier.startsWith("#");
+
+    if (!isLocal) return;
+
+    let currentExtension = extname(specifier);
+    let resolved = resolveFrom(specifier);
+
+    if (resolved) {
+      // fully specified and correct
+      if (currentExtension) return;
+
+      // extensionless: append the resolved file's extension, as long as
+      // the fully-specified form still maps to the same file (`#config`
+      // maps with the extension in the target, so `#config.js` wouldn't)
+      let candidate = specifier + extname(resolved);
+
+      if (resolveFrom(candidate) !== resolved) return;
+
+      rewrite(node, candidate);
+      return;
+    }
+
+    if (!currentExtension) return;
+
+    // check which file actually exists for this specifier
+    let base = specifier.slice(0, -currentExtension.length);
+    let resolvedBase = resolveFrom(base);
+
+    if (!resolvedBase) return;
+
+    let replacement = base + extname(resolvedBase);
+
+    if (replacement === specifier) return;
+
+    rewrite(node, replacement);
+  }
+
+  /**
+   * @param {import('ember-estree').ASTNode} node
+   * @param {string} replacement
+   */
+  function rewrite(node, replacement) {
+    node.value = replacement;
+    node.raw = JSON.stringify(replacement);
+    changed = true;
+  }
+
+  // (not templateOnly, so this is always a FileNode)
+  let tree = /** @type {import('ember-estree').FileNode} */ (
+    toTree(code, {
+      filePath: emittedPath,
+      visitors: {
+        ImportDeclaration: (node) => consider(node.source),
+        ExportNamedDeclaration: (node) => consider(node.source),
+        ExportAllDeclaration: (node) => consider(node.source),
+        // dynamic import()
+        ImportExpression: (node) => consider(node.source),
+      },
+    })
+  );
+
+  if (!changed) return code;
+
+  return print(tree);
+}

package/src/utils/tsdown-config.js

@@ -0,0 +1,85 @@
+import { readFile, writeFile } from "node:fs/promises";
+import { toTree, print, statements } from "ember-estree";
+
+/**
+ * Adds a property to the object passed to `defineConfig(...)` in the
+ * project's tsdown.config.js.
+ *
+ * No-ops when the property is already present (layers re-run), and when
+ * the config doesn't have the `defineConfig({ ... })` shape -- an existing
+ * project's hand-rolled config is the user's to manage.
+ *
+ * @param {import('#utils/project.js').Project} project
+ * @param {string} propertyName
+ * @param {string} propertySource the property as source, e.g. `publint: true`
+ */
+export async function addTsdownConfigProperty(project, propertyName, propertySource) {
+  const configPath = project.path("tsdown.config.js");
+  const contents = await readFile(configPath, "utf-8");
+
+  /** @type {import('ember-estree').ASTNode | null} */
+  let configObject = null;
+
+  const tree = /** @type {import('ember-estree').FileNode} */ (
+    toTree(contents, {
+      filePath: configPath,
+      visitors: {
+        CallExpression(node) {
+          const callee = /** @type {import('ember-estree').ASTNode} */ (node.callee);
+
+          if (callee?.type !== "Identifier" || callee.name !== "defineConfig") return;
+
+          const [argument] = /** @type {import('ember-estree').ASTNode[]} */ (node.arguments ?? []);
+
+          if (argument?.type === "ObjectExpression") {
+            configObject = argument;
+          }
+        },
+      },
+    })
+  );
+
+  if (!configObject) return;
+
+  const found = /** @type {import('ember-estree').ASTNode} */ (configObject);
+  const properties = /** @type {import('ember-estree').ASTNode[]} */ (found.properties ?? []);
+
+  const alreadyPresent = properties.some((property) => {
+    const key = /** @type {import('ember-estree').ASTNode} */ (property.key);
+
+    return key?.type === "Identifier" && key.name === propertyName;
+  });
+
+  if (alreadyPresent) return;
+
+  const [statement] = statements`defineConfig({ ${propertySource} });`;
+
+  if (!statement) return;
+
+  const expression = /** @type {import('ember-estree').ASTNode} */ (statement.expression);
+  const [templateObject] = /** @type {import('ember-estree').ASTNode[]} */ (expression.arguments);
+  const [property] = /** @type {import('ember-estree').ASTNode[]} */ (
+    templateObject?.properties ?? []
+  );
+
+  if (!property) return;
+
+  properties.push(property);
+  found.properties = properties;
+
+  await writeFile(configPath, print(tree));
+}
+
+/**
+ * Whether the project's tsdown.config.js configures `propertyName`.
+ *
+ * @param {import('#utils/project.js').Project} project
+ * @param {string} propertyName
+ */
+export async function hasTsdownConfigProperty(project, propertyName) {
+  if (!project.hasFile("tsdown.config.js")) return false;
+
+  const contents = await readFile(project.path("tsdown.config.js"), "utf-8");
+
+  return contents.includes(propertyName);
+}

package/src/utils/types.ts

@@ -8,7 +8,11 @@ export interface Layer {
    */
   label: string;
   hint?: string;
-  defaultValue?: () => unknown;
+  /**
+   * Whether the layer is pre-selected in the CLI (the user can still
+   * deselect it).
+   */
+  defaultValue?: (projectType: ProjectType) => unknown;
   /**
    * The function that applies the codemod
    *

package/test/ember.nvp/base-library.test.ts

@@ -0,0 +1,236 @@
+import { describe, it, beforeAll, afterAll, expect } from "vitest";
+import { generate, mktemp, pinYukuParser } from "#test-helpers";
+import { writeLibrarySource } from "./library-src-fixtures.ts";
+import { execa } from "execa";
+import { mkdir, readdir, readFile, rm, writeFile } from "node:fs/promises";
+import { join, relative, sep } from "node:path";
+
+import type { Project } from "ember.nvp";
+
+/**
+ * The minimal-library base has to produce a *buildable* library: these tests
+ * generate both flavors (JavaScript and TypeScript), snapshot the interesting
+ * generated files, and run the real `pnpm build` (tsdown + rolldown) against
+ * them.
+ */
+
+async function listFiles(directory: string): Promise<string[]> {
+  const entries = await readdir(directory, { withFileTypes: true, recursive: true });
+
+  return entries
+    .filter((entry) => entry.isFile())
+    .map((entry) => relative(directory, join(entry.parentPath, entry.name)))
+    .filter((path) => !path.split(sep).includes("node_modules"))
+    .sort();
+}
+
+async function read(project: Project, filePath: string): Promise<string> {
+  return readFile(join(project.directory, filePath), "utf-8");
+}
+
+async function installAndBuild(project: Project) {
+  await pinYukuParser(project);
+
+  let install = await execa("pnpm install", { cwd: project.directory, shell: true });
+  expect(install.exitCode).toBe(0);
+
+  let build = await execa("pnpm build", { cwd: project.directory, shell: true });
+  expect(build.exitCode).toBe(0);
+}
+
+describe("base: minimal-library", () => {
+  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("JavaScript", () => {
+    let project: Project;
+
+    beforeAll(async () => {
+      project = await generate({ type: "library", name: "my-lib", layers: [] });
+      dirs.push(project.directory);
+    });
+
+    it("generates the expected files (src is empty)", async () => {
+      expect(await listFiles(project.directory)).toMatchInlineSnapshot(`
+        [
+          ".gitignore",
+          "README.md",
+          "package.json",
+          "src/index.js",
+          "tsdown.config.js",
+        ]
+      `);
+
+      expect(await read(project, "src/index.js")).toBe("");
+    });
+
+    it("is publishable", async () => {
+      let manifest = JSON.parse(await read(project, "package.json"));
+
+      // The template is private (it lives in a workspace); the generated
+      // library must not be
+      expect(manifest).not.toHaveProperty("private");
+    });
+
+    it("has no TypeScript leftovers", async () => {
+      let manifest = JSON.parse(await read(project, "package.json"));
+
+      expect(manifest.devDependencies).not.toHaveProperty("typescript");
+      expect(manifest.devDependencies).not.toHaveProperty("@ember/library-tsconfig");
+      // No declarations are emitted without types
+      expect(JSON.stringify(manifest.exports)).not.toContain("types");
+
+      expect(await read(project, "tsdown.config.js")).toMatchInlineSnapshot(`
+        "import { defineConfig } from "tsdown";
+        import { ember } from "@nullvoxpopuli/ember-rolldown";
+
+        export default defineConfig({
+          entry: ["./src/index.js"],
+          dts: false,
+          plugins: [ember()],
+        });
+        "
+      `);
+    });
+
+    it("removes the TS plugin from an existing project's babel config", async () => {
+      // The base doesn't emit a babel.config.js, but generation can run
+      // over an existing project that has one
+      let directory = await mktemp("existing-lib");
+
+      dirs.push(directory);
+
+      await mkdir(directory, { recursive: true });
+      await writeFile(
+        join(directory, "babel.config.js"),
+        `export default {
+  plugins: [
+    ["@babel/plugin-transform-typescript", { allExtensions: true }],
+    ["module:decorator-transforms"],
+  ],
+};
+`,
+      );
+
+      let existing = await generate({ directory, type: "library", name: "existing-lib" });
+
+      let babelConfig = await readFile(join(existing.directory, "babel.config.js"), "utf-8");
+
+      expect(babelConfig).not.toContain("@babel/plugin-transform-typescript");
+      expect(babelConfig).toContain("module:decorator-transforms");
+    });
+
+    it("builds (with example source written in)", async () => {
+      await writeLibrarySource(project, "javascript");
+      await installAndBuild(project);
+
+      let output = await read(project, "dist/index.js");
+
+      // Published libraries ship precompileTemplate (the consuming app does
+      // the final compile), never wire format
+      expect(output).toContain("precompileTemplate");
+      expect(output).not.toContain("createTemplateFactory");
+
+      expect(await listFiles(join(project.directory, "dist"))).toMatchInlineSnapshot(`
+        [
+          "index.js",
+          "index.js.map",
+        ]
+      `);
+    });
+  });
+
+  describe("TypeScript", () => {
+    let project: Project;
+
+    beforeAll(async () => {
+      project = await generate({ type: "library", name: "my-lib", layers: ["typescript"] });
+      dirs.push(project.directory);
+    });
+
+    it("generates the expected files (src is empty)", async () => {
+      expect(await listFiles(project.directory)).toMatchInlineSnapshot(`
+        [
+          ".gitignore",
+          "README.md",
+          "package.json",
+          "src/index.ts",
+          "tsconfig.json",
+          "tsdown.config.js",
+        ]
+      `);
+
+      expect(await read(project, "src/index.ts")).toBe("");
+    });
+
+    it("type checks", async () => {
+      await writeLibrarySource(project, "typescript");
+      await pinYukuParser(project);
+
+      let install = await execa("pnpm install", { cwd: project.directory, shell: true });
+      expect(install.exitCode).toBe(0);
+
+      let types = await execa("pnpm lint:types", { cwd: project.directory, shell: true });
+      expect(types.exitCode).toBe(0);
+    });
+
+    it("builds, including declarations", async () => {
+      await installAndBuild(project);
+
+      let output = await read(project, "dist/index.js");
+
+      expect(output).toContain("precompileTemplate");
+      expect(output).not.toContain("createTemplateFactory");
+
+      let declarations = await read(project, "dist/index.d.ts");
+
+      expect(declarations).toContain("declare class Greeting extends Component<GreetingSignature>");
+      expect(declarations).toContain("declare const Badge: TOC<BadgeSignature>");
+      expect(declarations).toContain("declare function add(a: number, b: number): number");
+
+      expect(await listFiles(join(project.directory, "dist"))).toMatchInlineSnapshot(`
+        [
+          "index.d.ts",
+          "index.d.ts.map",
+          "index.js",
+          "index.js.map",
+        ]
+      `);
+    });
+
+    it("errors when tsconfig lacks isolatedDeclarations", async () => {
+      let tsconfigPath = join(project.directory, "tsconfig.json");
+      let original = await readFile(tsconfigPath, "utf-8");
+
+      try {
+        await writeFile(
+          tsconfigPath,
+          JSON.stringify({
+            extends: "@ember/library-tsconfig",
+            include: ["src"],
+            compilerOptions: { allowJs: true, rootDir: "./src" },
+          }),
+        );
+
+        let build = await execa("pnpm build", {
+          cwd: project.directory,
+          shell: true,
+          reject: false,
+          all: true,
+        });
+
+        expect(build.exitCode).not.toBe(0);
+        expect(build.all).toContain('"compilerOptions.isolatedDeclarations": true');
+      } finally {
+        await writeFile(tsconfigPath, original);
+      }
+    });
+  });
+});

package/test/ember.nvp/generator-replace-or-update.test.ts

@@ -1,10 +1,9 @@
 import { describe, it, expect, afterAll } from "vitest";
 import { generate, layers, expectIsSetup } from "#test-helpers";
 import { generateProject } from "ember.nvp";
-import { writeFile } from "node:fs/promises";
+import { rm, writeFile } from "node:fs/promises";
 import { existsSync } from "node:fs";
 import { join } from "node:path";
-import { rimraf } from "rimraf";
 
 /**
  * The replace-or-update question only matters when a project already exists
@@ -21,7 +20,7 @@ describe("generating over an existing project", () => {
     if (process.env.CI) return;
 
     for (const dir of dirs) {
-      await rimraf(dir, { maxRetries: 3, retryDelay: 100 });
+      await rm(dir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
     }
   });
 

package/test/ember.nvp/inspector-support.test.ts

@@ -0,0 +1,179 @@
+import { describe, it, expect } from "vitest";
+
+import { hasInspectorSupport, wireInspectorSupport } from "#utils/inspector-support.js";
+
+/**
+ * The Application definition is found structurally, so every shape an app
+ * author may have refactored their app file into gets wired the same way
+ * the freshly generated shape does.
+ */
+describe("wireInspectorSupport", () => {
+  it("wires the generated shape (export default class extends Application)", () => {
+    const code = [
+      `import Application from "ember-strict-application-resolver";`,
+      ``,
+      `export default class App extends Application {`,
+      `  modules = {`,
+      `    ...import.meta.glob("./router.*", { eager: true }),`,
+      `  };`,
+      `}`,
+    ].join("\n");
+
+    expect(wireInspectorSupport(code, "app/app.ts")).toMatchInlineSnapshot(`
+      "import Application from "ember-strict-application-resolver";
+      import setupInspector from "@embroider/legacy-inspector-support/ember-source-4.12";
+      export default class App extends Application {
+        modules = { ...import.meta.glob("./router.*", { eager: true }) };
+        inspector = setupInspector(this);
+      }"
+    `);
+  });
+
+  it("wires a named class exported in a separate statement", () => {
+    const code = [
+      `import Application from "ember-strict-application-resolver";`,
+      ``,
+      `class App extends Application {`,
+      `  modules = {};`,
+      `}`,
+      ``,
+      `export default App;`,
+    ].join("\n");
+
+    expect(wireInspectorSupport(code, "app/app.js")).toMatchInlineSnapshot(`
+      "import Application from "ember-strict-application-resolver";
+      import setupInspector from "@embroider/legacy-inspector-support/ember-source-4.12";
+      class App extends Application {
+        modules = {  };
+        inspector = setupInspector(this);
+      }
+      export default App"
+    `);
+  });
+
+  it("wires an anonymous default-exported class", () => {
+    const code = [
+      `import Application from "ember-strict-application-resolver";`,
+      ``,
+      `export default class extends Application {}`,
+    ].join("\n");
+
+    expect(wireInspectorSupport(code, "app/app.js")).toMatchInlineSnapshot(`
+      "import Application from "ember-strict-application-resolver";
+      import setupInspector from "@embroider/legacy-inspector-support/ember-source-4.12";
+      export default class extends Application {
+        inspector = setupInspector(this);
+      }"
+    `);
+  });
+
+  it("wires a class expression assigned to a variable", () => {
+    const code = [
+      `import Application from "ember-strict-application-resolver";`,
+      ``,
+      `const App = class extends Application {`,
+      `  modules = {};`,
+      `};`,
+      ``,
+      `export default App;`,
+    ].join("\n");
+
+    expect(wireInspectorSupport(code, "app/app.js")).toMatchInlineSnapshot(`
+      "import Application from "ember-strict-application-resolver";
+      import setupInspector from "@embroider/legacy-inspector-support/ember-source-4.12";
+      const App = class extends Application {
+        modules = {  };
+        inspector = setupInspector(this);
+      };
+      export default App"
+    `);
+  });
+
+  it("wires a class extending @ember/application under a renamed import", () => {
+    const code = [
+      `import Base from "@ember/application";`,
+      ``,
+      `export default class App extends Base {}`,
+    ].join("\n");
+
+    expect(wireInspectorSupport(code, "app/app.ts")).toMatchInlineSnapshot(`
+      "import Base from "@ember/application";
+      import setupInspector from "@embroider/legacy-inspector-support/ember-source-4.12";
+      export default class App extends Base {
+        inspector = setupInspector(this);
+      }"
+    `);
+  });
+
+  it("adds only the missing member when the import is already present", () => {
+    const code = [
+      `import wireUp from "@embroider/legacy-inspector-support/ember-source-4.12";`,
+      `import Application from "ember-strict-application-resolver";`,
+      ``,
+      `export default class App extends Application {}`,
+    ].join("\n");
+
+    expect(wireInspectorSupport(code, "app/app.ts")).toMatchInlineSnapshot(`
+      "import wireUp from "@embroider/legacy-inspector-support/ember-source-4.12";
+      import Application from "ember-strict-application-resolver";
+      export default class App extends Application {
+        inspector = wireUp(this);
+      }"
+    `);
+  });
+
+  it("is idempotent", () => {
+    const code = [
+      `import Application from "ember-strict-application-resolver";`,
+      ``,
+      `export default class App extends Application {`,
+      `  modules = {};`,
+      `}`,
+    ].join("\n");
+
+    const once = wireInspectorSupport(code, "app/app.ts");
+    const twice = wireInspectorSupport(once, "app/app.ts");
+
+    expect(twice).toBe(once);
+  });
+
+  it("leaves a module without an Application definition alone", () => {
+    const code = [`export function noApplicationHere() {}`, ``].join("\n");
+
+    expect(wireInspectorSupport(code, "app/app.js")).toBe(code);
+  });
+
+  it("leaves a class that does not extend an Application import alone", () => {
+    const code = [
+      `import Component from "@glimmer/component";`,
+      ``,
+      `export default class App extends Component {}`,
+    ].join("\n");
+
+    expect(wireInspectorSupport(code, "app/app.ts")).toBe(code);
+  });
+});
+
+describe("hasInspectorSupport", () => {
+  it("is false before wiring and true after", () => {
+    const code = [
+      `import Application from "ember-strict-application-resolver";`,
+      ``,
+      `export default class App extends Application {}`,
+    ].join("\n");
+
+    expect(hasInspectorSupport(code, "app/app.ts")).toBe(false);
+    expect(hasInspectorSupport(wireInspectorSupport(code, "app/app.ts"), "app/app.ts")).toBe(true);
+  });
+
+  it("is false when only the import is present", () => {
+    const code = [
+      `import setupInspector from "@embroider/legacy-inspector-support/ember-source-4.12";`,
+      `import Application from "ember-strict-application-resolver";`,
+      ``,
+      `export default class App extends Application {}`,
+    ].join("\n");
+
+    expect(hasInspectorSupport(code, "app/app.ts")).toBe(false);
+  });
+});