ember.nvp 1.13.0 → 1.15.0

package/src/migration-from/at-ember-tooling/classic-build-app-blueprint/index.js

@@ -0,0 +1,118 @@
+import { packageJson, tsconfig } from "ember-apply";
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { checkApp, migrateApp } from "../../app.js";
+import { EMBER_CLI_BUILD } from "../../ember-cli-build.js";
+import { firstExisting, listFiles, remove } from "../../files.js";
+import { changedTestemFlags } from "../../layers.js";
+
+/**
+ * Compiler options of the blueprint's tsconfig.json.
+ * `baseUrl` and `paths` map the app's module prefix to app/,
+ * which package.json `exports` does now.
+ */
+const BLUEPRINT_COMPILER_OPTIONS = new Set(["allowJs", "baseUrl", "noEmit", "paths", "types"]);
+
+/**
+ * The blueprint's types/global.d.ts, which sets up Glint 1 for loose-mode templates
+ */
+const GLINT_ENVIRONMENT = /^\s*import\s+["']@glint\/environment-ember-loose["'];?\s*$/;
+
+/**
+ * An app that builds with ember-cli:
+ * with broccoli, or with `@embroider/webpack` through `@embroider/compat`.
+ *
+ * This covers `@ember-tooling/classic-build-app-blueprint`,
+ * and the `app` blueprint that ember-cli had before it.
+ *
+ * The migration is the same as for `@ember/app-blueprint`,
+ * plus the moves that `ember-vite-codemod` makes:
+ * - app/index.html moves to index.html
+ *
+ * @type {import('#types').Migration}
+ */
+export default {
+  label: "@ember-tooling/classic-build-app-blueprint",
+  type: "app",
+
+  detect(directory) {
+    let build = firstExisting(directory, EMBER_CLI_BUILD);
+
+    if (!build) return false;
+
+    let source = readFileSync(join(directory, build), "utf-8");
+
+    return (
+      source.includes("ember-cli/lib/broccoli/ember-app") && !source.includes("@embroider/vite")
+    );
+  },
+
+  async check(project) {
+    let report = await checkApp(project);
+    let root = project.directory;
+
+    if (listFiles(root, "server").length > 0) {
+      report.todo.push({
+        title: "Dev server middleware in server/",
+        where: listFiles(root, "server"),
+        action: "Move proxies and mocks to `server` in vite.config.mjs. Vite does not run server/.",
+      });
+    }
+
+    let testem = changedTestemFlags(root, "testem.js", "app");
+
+    if (testem) report.todo.push(testem);
+
+    let config = await blueprintTsconfig(root);
+    let custom = Object.keys(config?.compilerOptions ?? {}).filter(
+      (option) => !BLUEPRINT_COMPILER_OPTIONS.has(option),
+    );
+
+    if (config && custom.length > 0) {
+      report.todo.push({
+        title: "Compiler options that the new tsconfig.json does not have",
+        where: custom.map((option) => `tsconfig.json: ${option}`),
+        action: "Add the options that you still need to tsconfig.json.",
+      });
+    }
+
+    return report;
+  },
+
+  async run(project, report) {
+    let root = project.directory;
+    let indexHtml = project.hasFile("app/index.html") ? "app/index.html" : "index.html";
+
+    // Glint 1 and @tsconfig/ember do not check .gts, so the base writes a new tsconfig.json
+    if (await blueprintTsconfig(root)) {
+      await remove(project, ["tsconfig.json"]);
+      await packageJson.removeDevDependencies(["@tsconfig/ember"], root);
+
+      let types = (await project.read("types/global.d.ts")) ?? "";
+
+      if (GLINT_ENVIRONMENT.test(types)) {
+        await remove(project, ["types/global.d.ts"]);
+      }
+
+      if (listFiles(root, "types").length === 0) {
+        await remove(project, ["types"]);
+      }
+    }
+
+    await migrateApp(project, report, { indexHtml });
+  },
+};
+
+/**
+ * @param {string} root
+ * @returns {Promise<Record<string, any> | undefined>} tsconfig.json, when it is the blueprint's
+ */
+async function blueprintTsconfig(root) {
+  if (!existsSync(join(root, "tsconfig.json"))) return;
+
+  let config = await tsconfig.read(join(root, "tsconfig.json")).catch(() => undefined);
+
+  if (config?.glint || String(config?.extends ?? "").startsWith("@tsconfig/ember")) {
+    return config;
+  }
+}

package/src/migration-from/babel.js

@@ -0,0 +1,207 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { parseProgram, propertyValue, sourceOf, stringValue, walk } from "./javascript.js";
+
+/**
+ * Babel plugins whose work ember-rolldown's defaults already do for a library:
+ * TypeScript, templates to `precompileTemplate`, and decorators.
+ */
+const COVERED_BY_EMBER_ROLLDOWN = new Set([
+  "@babel/plugin-transform-typescript",
+  "babel-plugin-ember-template-compilation",
+  "decorator-transforms",
+  "@babel/plugin-proposal-decorators",
+  "@babel/plugin-proposal-class-properties",
+  "@babel/plugin-transform-class-properties",
+  "@babel/plugin-transform-class-static-block",
+  "@babel/plugin-proposal-private-methods",
+  "@babel/plugin-transform-private-methods",
+  "@embroider/addon-dev/template-colocation-plugin",
+  "ember-template-imports/src/babel-plugin",
+]);
+
+/**
+ * Babel presets whose work ember-rolldown's defaults already do
+ */
+const PRESETS_COVERED_BY_EMBER_ROLLDOWN = new Set(["@babel/preset-typescript"]);
+
+/**
+ * @typedef {object} BabelConfig
+ * @property {string[]} plugins every plugin name that the config lists
+ * @property {boolean} hasCode whether plugins also come from code that cannot be read statically,
+ *   such as `...macros.babelMacros`
+ * @property {string[]} presets every preset name that the config lists
+ * @property {string[]} templateTransforms the source of each AST transform that the template compiler runs
+ */
+
+/**
+ * @param {string} root
+ * @param {string} file relative to `root`
+ * @returns {BabelConfig | undefined} undefined when the file is missing or does not parse
+ */
+export function readBabelConfig(root, file) {
+  let path = join(root, file);
+
+  if (!existsSync(path)) return;
+
+  let source = readFileSync(path, "utf-8");
+
+  if (file.endsWith(".json") || file.endsWith(".babelrc")) {
+    return fromJSON(source);
+  }
+
+  return fromJavaScript(source, file);
+}
+
+/**
+ * @param {string} source
+ * @returns {BabelConfig | undefined}
+ */
+function fromJSON(source) {
+  /** @type {any} */
+  let json;
+
+  try {
+    json = JSON.parse(source);
+  } catch {
+    return;
+  }
+
+  /** @type {string[]} */
+  let plugins = [];
+  /** @type {string[]} */
+  let templateTransforms = [];
+
+  for (let entry of json.plugins ?? []) {
+    let [name, options] = Array.isArray(entry) ? entry : [entry];
+
+    if (typeof name !== "string") continue;
+
+    plugins.push(name);
+
+    if (name === "babel-plugin-ember-template-compilation") {
+      for (let transform of options?.transforms ?? []) {
+        templateTransforms.push(JSON.stringify(transform));
+      }
+    }
+  }
+
+  /** @type {string[]} */
+  let presets = [];
+
+  for (let entry of json.presets ?? []) {
+    let [name] = Array.isArray(entry) ? entry : [entry];
+
+    if (typeof name === "string") presets.push(name);
+  }
+
+  return { plugins, presets, hasCode: false, templateTransforms };
+}
+
+/**
+ * @param {string} source
+ * @param {string} file
+ * @returns {BabelConfig | undefined}
+ */
+function fromJavaScript(source, file) {
+  let program = parseProgram(source, file);
+
+  if (!program) return;
+
+  /** @type {BabelConfig} */
+  let config = { plugins: [], presets: [], hasCode: false, templateTransforms: [] };
+
+  walk(program, (node) => {
+    if (node.type !== "ObjectExpression") return;
+
+    let plugins = withoutFilter(propertyValue(node, "plugins"));
+    let presets = propertyValue(node, "presets");
+
+    if (presets?.type === "ArrayExpression") {
+      for (let element of presets.elements ?? []) {
+        let entry = element?.type === "ArrayExpression" ? element.elements?.[0] : element;
+
+        config.presets.push(pluginName(entry) ?? "...");
+      }
+    }
+
+    if (plugins?.type !== "ArrayExpression") return;
+
+    for (let element of plugins.elements ?? []) {
+      let entry = element?.type === "ArrayExpression" ? element.elements?.[0] : element;
+      let name = pluginName(entry);
+
+      if (name === undefined) {
+        config.hasCode = true;
+        continue;
+      }
+
+      config.plugins.push(name);
+
+      let options = element?.type === "ArrayExpression" ? element.elements?.[1] : undefined;
+      let transforms = propertyValue(options, "transforms");
+
+      if (
+        name === "babel-plugin-ember-template-compilation" &&
+        transforms?.type === "ArrayExpression"
+      ) {
+        for (let transform of transforms.elements ?? []) {
+          if (transform) config.templateTransforms.push(sourceOf(source, transform));
+        }
+      }
+    }
+  });
+
+  if (config.plugins.length === 0 && /plugins\s*:/.test(source)) {
+    config.hasCode = true;
+  }
+
+  return config;
+}
+
+/**
+ * @param {import('./javascript.js').Node | undefined} node
+ * @returns {string | undefined} `x` for `"x"`, `require.resolve("x")`, and `import.meta.resolve("x")`
+ */
+function pluginName(node) {
+  let name = stringValue(node);
+
+  if (name !== undefined) return name;
+
+  if (node?.type === "CallExpression" && node.callee?.property?.name === "resolve") {
+    return stringValue(node.arguments?.[0]);
+  }
+}
+
+/**
+ * @param {import('./javascript.js').Node | undefined} node
+ * @returns {import('./javascript.js').Node | undefined} the array in `[...].filter(Boolean)`
+ */
+function withoutFilter(node) {
+  if (node?.type === "CallExpression" && node.callee?.type === "MemberExpression") {
+    return node.callee.object;
+  }
+
+  return node;
+}
+
+/**
+ * @param {BabelConfig} config
+ * @returns {string[]} what the config does beyond ember-rolldown's defaults
+ */
+export function beyondEmberRolldown(config) {
+  /** @type {string[]} */
+  let extra = [];
+
+  for (let plugin of config.plugins) {
+    if (!COVERED_BY_EMBER_ROLLDOWN.has(plugin.replace(/^module:/, ""))) extra.push(plugin);
+  }
+
+  for (let preset of config.presets) {
+    if (!PRESETS_COVERED_BY_EMBER_ROLLDOWN.has(preset)) extra.push(`preset ${preset}`);
+  }
+  if (config.templateTransforms.length > 0) extra.push("template transforms");
+  if (config.hasCode) extra.push("plugins from code");
+
+  return extra;
+}

package/src/migration-from/ember-cli-build.js

@@ -0,0 +1,238 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import {
+  importedNames,
+  parseProgram,
+  propertyNames,
+  propertyValue,
+  sourceOf,
+  walk,
+} from "./javascript.js";
+
+export const EMBER_CLI_BUILD = ["ember-cli-build.js", "ember-cli-build.mjs", "ember-cli-build.cjs"];
+
+/**
+ * Modules that an ember-cli-build imports to build the way the blueprints do
+ */
+const BLUEPRINT_IMPORTS = new Set([
+  "ember-cli/lib/broccoli/ember-app",
+  "ember-cli/lib/broccoli/ember-app.js",
+  "@embroider/compat",
+  "@embroider/vite",
+  "@embroider/webpack",
+  "@embroider/test-setup",
+  "@warp-drive/core/build-config",
+  "@warp-drive/build-config",
+  "@ember-data/private-build-infra",
+  "node:path",
+  "node:url",
+  "path",
+  "url",
+]);
+
+/**
+ * `new EmberApp(defaults, { ... })` options that only tune the ember-cli build.
+ * Vite does the same work by itself.
+ */
+const BUILD_ONLY_OPTIONS = new Set([
+  "ember-cli-babel",
+  "ember-cli-terser",
+  "ember-cli-uglify",
+  "ember-data",
+  "emberData",
+  "fingerprint",
+  "hinting",
+  "minifyCSS",
+  "minifyJS",
+  "sourcemaps",
+  "SRI",
+  "storeConfigInMeta",
+  "tests",
+]);
+
+/**
+ * `compatBuild(app, packager, { ... })` options that do nothing without `@embroider/compat`
+ */
+const COMPAT_ONLY_OPTIONS = new Set([
+  "allowUnsafeDynamicComponents",
+  "skipBabel",
+  "staticAddonTestSupportTrees",
+  "staticAddonTrees",
+  "staticComponents",
+  "staticEmberSource",
+  "staticHelpers",
+  "staticInvokables",
+  "staticModifiers",
+]);
+
+/**
+ * @typedef {object} EmberCliBuild
+ * @property {string} file
+ * @property {string[]} options `new EmberApp(...)` options that change what the app does
+ * @property {string[]} compatOptions `compatBuild(...)` options that change what the app does
+ * @property {string[]} imports modules beyond the ones that the blueprints import
+ * @property {string[]} appImports the source of each `app.import(...)` call
+ * @property {{ from: string, options: string } | undefined} warpDrive the `setConfig(app, dir, options)` call
+ * @property {boolean} usesVite whether the build runs through `@embroider/vite`
+ */
+
+/**
+ * @param {string} root
+ * @param {string} file relative to `root`
+ * @returns {EmberCliBuild | undefined} undefined when the file does not parse
+ */
+export function readEmberCliBuild(root, file) {
+  let source = readFileSync(join(root, file), "utf-8");
+  let program = parseProgram(source, file);
+
+  if (!program) return;
+
+  let imports = importedNames(program);
+  let modules = new Set(imports.values());
+
+  /** @type {EmberCliBuild} */
+  let build = {
+    file,
+    options: [],
+    compatOptions: [],
+    imports: [],
+    appImports: [],
+    warpDrive: undefined,
+    usesVite: modules.has("@embroider/vite"),
+  };
+
+  for (let module of modules) {
+    if (!BLUEPRINT_IMPORTS.has(module)) build.imports.push(module);
+  }
+
+  walk(program, (node) => {
+    if (node.type === "NewExpression" && node.callee?.type === "Identifier") {
+      let from = imports.get(node.callee.name) ?? "";
+
+      if (!from.startsWith("ember-cli/lib/broccoli/ember-app")) return;
+
+      for (let name of propertyNames(node.arguments?.[1])) {
+        if (!BUILD_ONLY_OPTIONS.has(name)) build.options.push(name);
+      }
+
+      return;
+    }
+
+    if (node.type !== "CallExpression") return;
+
+    let callee = node.callee;
+
+    if (callee?.type === "MemberExpression" && callee.property?.name === "import") {
+      build.appImports.push(sourceOf(source, node).replace(/\s+/g, " "));
+      return;
+    }
+
+    if (callee?.type !== "Identifier") return;
+
+    let from = imports.get(callee.name);
+
+    if (callee.name === "compatBuild") {
+      for (let name of propertyNames(node.arguments?.[2])) {
+        if (!COMPAT_ONLY_OPTIONS.has(name)) build.compatOptions.push(name);
+      }
+    }
+
+    if (callee.name === "setConfig" && from && /build-config|private-build-infra/.test(from)) {
+      let options = node.arguments?.[2];
+
+      build.warpDrive = {
+        from,
+        options: options ? sourceOf(source, options) : "{}",
+      };
+    }
+  });
+
+  return build;
+}
+
+/**
+ * @param {EmberCliBuild} build
+ * @returns {string[]} everything that `readEmberCliBuild` found which ember.nvp cannot carry over
+ */
+export function unsupportedIn(build) {
+  /** @type {string[]} */
+  let found = [];
+
+  for (let option of build.options) found.push(`${build.file}: new EmberApp option "${option}"`);
+  for (let option of build.compatOptions)
+    found.push(`${build.file}: compatBuild option "${option}"`);
+  for (let module of build.imports) found.push(`${build.file}: imports ${module}`);
+  for (let call of build.appImports) found.push(`${build.file}: ${call}`);
+
+  return found;
+}
+
+/**
+ * @param {string} root
+ * @param {string} file
+ * @returns {string[] | undefined} the paths below `ENV` that `config/environment.js` sets, such as `APP.rootElement`
+ */
+export function readEnvironmentKeys(root, file) {
+  let source = readFileSync(join(root, file), "utf-8");
+  let program = parseProgram(source, file);
+
+  if (!program) return;
+
+  /** @type {Set<string>} */
+  let keys = new Set();
+
+  walk(program, (node) => {
+    if (node.type === "VariableDeclarator" && node.id?.name === "ENV") {
+      collectKeys(node.init, "", keys);
+    }
+
+    if (node.type === "AssignmentExpression" && node.left?.type === "MemberExpression") {
+      let path = memberPath(node.left);
+
+      if (path?.startsWith("ENV.")) {
+        keys.add(path.slice("ENV.".length));
+        collectKeys(node.right, path.slice("ENV.".length) + ".", keys);
+      }
+    }
+  });
+
+  return Array.from(keys);
+}
+
+/**
+ * @param {import('./javascript.js').Node | undefined} node
+ * @param {string} prefix
+ * @param {Set<string>} keys
+ */
+function collectKeys(node, prefix, keys) {
+  if (node?.type !== "ObjectExpression") return;
+
+  for (let property of node.properties ?? []) {
+    let [name] = propertyNames({ type: "ObjectExpression", properties: [property] });
+
+    if (!name || name === "...") continue;
+
+    keys.add(prefix + name);
+    collectKeys(property.value, `${prefix}${name}.`, keys);
+  }
+}
+
+/**
+ * @param {import('./javascript.js').Node} node
+ * @returns {string | undefined} `ENV.APP.foo` for `ENV.APP.foo` and `ENV['APP'].foo`
+ */
+function memberPath(node) {
+  if (node.type === "Identifier") return node.name;
+  if (node.type !== "MemberExpression") return;
+
+  let object = memberPath(node.object);
+  let property = node.computed
+    ? node.property?.type === "Literal"
+      ? String(node.property.value)
+      : undefined
+    : node.property?.name;
+
+  if (!object || property === undefined) return;
+
+  return `${object}.${property}`;
+}

package/src/migration-from/files.js

@@ -0,0 +1,120 @@
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { mkdir, rename, rm } from "node:fs/promises";
+import { dirname, join, relative, sep } from "node:path";
+
+/**
+ * Never part of a project's own source
+ */
+const SKIPPED_DIRECTORIES = new Set(["node_modules", "dist", "declarations", ".git"]);
+
+/**
+ * @param {string} root the project directory
+ * @param {string} directory relative to `root`
+ * @returns {string[]} every file below `directory`, relative to `root`, sorted
+ */
+export function listFiles(root, directory) {
+  let absolute = join(root, directory);
+
+  if (!existsSync(absolute)) return [];
+
+  /** @type {string[]} */
+  let files = [];
+
+  collect(absolute, root, files);
+
+  return files.sort();
+}
+
+/**
+ * @param {string} directory
+ * @param {string} root
+ * @param {string[]} files
+ */
+function collect(directory, root, files) {
+  for (let entry of readdirSync(directory, { withFileTypes: true })) {
+    if (SKIPPED_DIRECTORIES.has(entry.name)) continue;
+
+    let path = join(directory, entry.name);
+
+    if (entry.isDirectory()) {
+      collect(path, root, files);
+    } else if (entry.isFile()) {
+      files.push(relative(root, path).split(sep).join("/"));
+    }
+  }
+}
+
+/**
+ * @param {string} root the project directory
+ * @param {string[]} directories relative to `root`
+ * @param {string[]} extensions such as `.hbs`
+ * @returns {string[]}
+ */
+export function filesWithExtension(root, directories, extensions) {
+  /** @type {string[]} */
+  let result = [];
+
+  for (let directory of directories) {
+    for (let file of listFiles(root, directory)) {
+      if (extensions.some((extension) => file.endsWith(extension))) {
+        result.push(file);
+      }
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Tests that render with `hbs` from ember-cli-htmlbars (or its older aliases).
+ *
+ * Those templates are loose mode:
+ * components are looked up by name at runtime,
+ * and the babel plugin that compiles them is part of ember-cli.
+ *
+ * @param {string} root the project directory
+ * @param {string[]} directories relative to `root`
+ * @returns {string[]}
+ */
+export function testsWithHbs(root, directories) {
+  let candidates = filesWithExtension(root, directories, [".js", ".ts"]);
+
+  return candidates.filter((file) => {
+    let source = readFileSync(join(root, file), "utf-8");
+
+    return /from\s+["'](ember-cli-htmlbars|htmlbars-inline-precompile|ember-cli-htmlbars-inline-precompile)["']/.test(
+      source,
+    );
+  });
+}
+
+/**
+ * The first of `names` that exists in `root`
+ *
+ * @param {string} root
+ * @param {string[]} names
+ * @returns {string | undefined}
+ */
+export function firstExisting(root, names) {
+  return names.find((name) => existsSync(join(root, name)));
+}
+
+/**
+ * @param {import('#utils/project.js').Project} project
+ * @param {string[]} paths files or directories, relative to the project
+ */
+export async function remove(project, paths) {
+  for (let path of paths) {
+    await rm(project.path(path), { recursive: true, force: true });
+  }
+}
+
+/**
+ * @param {import('#utils/project.js').Project} project
+ * @param {string} from relative to the project
+ * @param {string} to relative to the project
+ */
+export async function move(project, from, to) {
+  await mkdir(dirname(project.path(to)), { recursive: true });
+  await rename(project.path(from), project.path(to));
+}