ember.nvp 0.1.0 → 0.2.0

package/test/test-helpers/permutate.test.ts

@@ -0,0 +1,70 @@
+import { describe, it, expect } from "vitest";
+import { permutate } from "#test-helpers";
+
+describe("permutate", () => {
+  it("generates all permutations", () => {
+    const result = permutate(["a", "b", "c"]);
+
+    expect(result).toEqual([
+      ["a"],
+      ["a", "b"],
+      ["a", "b", "c"],
+      ["a", "c"],
+      ["b"],
+      ["b", "c"],
+      ["c"],
+    ]);
+  });
+
+  it("skips duplicate entries", () => {
+    const result = permutate(["a", "b", "b"]);
+
+    // Should not include ["a", "b"] twice
+    const count = result.filter((perm) => perm.join(",") === "a,b").length;
+    expect(count).toBe(1);
+  });
+
+  it("enforces mutual exclusivity for eslint-prefixed entries", () => {
+    const result = permutate([
+      "eslint-bundled-ember",
+      "eslint-bundled-nvp",
+      "eslint-ejected",
+      "other",
+    ]);
+
+    // Check that no permutation has more than one eslint-prefixed entry
+    for (const permutation of result) {
+      const eslintCount = permutation.filter((item) => item.startsWith("eslint-")).length;
+      expect(eslintCount).toBeLessThanOrEqual(1);
+    }
+  });
+
+  it("allows permutations with 0 or 1 eslint entry", () => {
+    const result = permutate(["eslint-bundled-ember", "eslint-bundled-nvp", "other"]);
+
+    const hasNoEslint = result.some((perm) => !perm.some((item) => item.startsWith("eslint-")));
+    const hasOneEslint = result.some(
+      (perm) => perm.filter((item) => item.startsWith("eslint-")).length === 1,
+    );
+
+    expect(hasNoEslint).toBe(true);
+    expect(hasOneEslint).toBe(true);
+  });
+
+  it("generates valid permutations with mixed items", () => {
+    const result = permutate(["a", "eslint-foo", "eslint-bar", "b"]);
+
+    // Verify all permutations contain at most 1 eslint entry
+    for (const permutation of result) {
+      const eslintCount = permutation.filter((item) => item.startsWith("eslint-")).length;
+      expect(eslintCount).toBeLessThanOrEqual(1);
+    }
+
+    // Should have permutations like: ["a"], ["a", "eslint-foo"], ["a", "b"], etc.
+    // but NOT ["a", "eslint-foo", "eslint-bar"]
+    const hasMultipleEslint = result.some(
+      (perm) => perm.filter((item) => item.startsWith("eslint-")).length > 1,
+    );
+    expect(hasMultipleEslint).toBe(false);
+  });
+});

package/test/test-helpers.ts

@@ -0,0 +1,175 @@
+import { execa } from "execa";
+import { join } from "node:path";
+import { styleText } from "node:util";
+import { Readable, Writable } from "node:stream";
+import { mkdtemp } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { generateProject, Project } from "ember.nvp";
+import { discoverLayers } from "#layers";
+import type { DiscoveredLayer } from "#types";
+import { expect } from "vitest";
+
+const minimalApp = "minimal-app";
+const minimalAddon = "minimal-library";
+
+export const bases = [minimalApp, minimalAddon];
+
+export const layers = await discoverLayers();
+
+export function permutate(toPermutate: string[]): string[][] {
+  const out: string[][] = [];
+
+  function backtrack(startIndex: number, prefix: string[], hasEslint: boolean) {
+    if (prefix.length > 0) out.push(prefix.slice());
+
+    for (let i = startIndex; i < toPermutate.length; i++) {
+      if (i > startIndex && toPermutate[i] === toPermutate[i - 1]) {
+        // skip duplicates (a,b,c == c,b,a)
+        continue;
+      }
+
+      let option = toPermutate[i];
+
+      // something has gone wrong if this is undefined
+      // (silly TS not understanding loop bounds)
+      if (!option) continue;
+
+      const isEslint = option.startsWith("eslint-");
+
+      // Skip this option if it's an eslint entry and we already have one
+      // (enforce mutual exclusivity for eslint-prefixed entries)
+      if (isEslint && hasEslint) continue;
+
+      prefix.push(option);
+      backtrack(i + 1, prefix, hasEslint || isEslint);
+      prefix.pop();
+    }
+  }
+
+  backtrack(0, [], false);
+  return out;
+}
+
+export async function mktemp(name = "ember.nvp_test-") {
+  return await mkdtemp(join(tmpdir(), `${name}-`));
+}
+
+export async function reapply(project: Project, layers: string[]) {
+  return await generate({
+    directory: project.directory,
+    layers,
+    name: project.name,
+    type: project.type,
+    packageManager: project.packageManager,
+  });
+}
+
+export async function generate({
+  layers: layerNames = [],
+  name = "my-app",
+  type = "app",
+  packageManager = "pnpm",
+  directory,
+}: {
+  directory?: string;
+  layers?: string[];
+  name?: string;
+  type?: "app" | "library";
+  packageManager?: "pnpm" | "npm";
+}): Promise<Project> {
+  const tempDir = directory ?? (await mktemp(name));
+
+  let selectedLayers = layers.filter((layer) => layerNames.includes(layer.name));
+  let project = new Project(tempDir, {
+    name,
+    type,
+    path: tempDir,
+    layers: selectedLayers,
+    packageManager,
+  });
+
+  await generateProject(project);
+
+  return project;
+}
+
+const cliPath = join(import.meta.dirname, "../src/cli/index.js");
+
+export function cli(args: string[] = []) {
+  let cmd = `node ${cliPath} ${args.join(" ")}`;
+
+  console.log(`Running '${styleText("cyan", cmd)}'`);
+
+  let output = new MockWritable();
+  let input = new MockReadable();
+
+  let execaPromise = execa("node", args, { shell: true, stdout: output, stdin: input });
+
+  return {
+    execaPromise,
+    output,
+    input,
+  };
+}
+
+export class MockWritable extends Writable {
+  public buffer: string[] = [];
+  public isTTY = false;
+  public columns = 80;
+  public rows = 20;
+
+  _write(
+    chunk: any,
+    _encoding: BufferEncoding,
+    callback: (error?: Error | null | undefined) => void,
+  ): void {
+    this.buffer.push(chunk.toString());
+    callback();
+  }
+}
+
+export class MockReadable extends Readable {
+  protected _buffer: unknown[] | null = [];
+
+  _read() {
+    if (this._buffer === null) {
+      this.push(null);
+      return;
+    }
+
+    for (const val of this._buffer) {
+      this.push(val);
+    }
+
+    this._buffer = [];
+  }
+
+  pushValue(val: unknown): void {
+    this._buffer?.push(val);
+  }
+
+  close(): void {
+    this._buffer = null;
+  }
+}
+
+export async function build(project: Project, mode = "development") {
+  return await execa("pnpm", ["vite", "build", "--mode", mode], {
+    cwd: project.directory,
+    env: {
+      NODE_ENV: mode,
+    },
+  });
+}
+
+export async function expectIsSetup(project: Project, layer: DiscoveredLayer) {
+  let result = await layer.isSetup(project, true);
+
+  if (typeof result === "object") {
+    expect(result.reasons, `${layer.name} is setup`).deep.equal([]);
+    expect(result.isSetup, `${layer.name} is setup`).toBe(true);
+    return;
+  }
+
+  expect(result, `${layer.name} is setup`).toBe(true);
+}

package/tsconfig.json

@@ -1,7 +1,15 @@
 {
   "extends": "@ember/library-tsconfig",
   "compilerOptions": {
-    "allowJs": true
+    "allowJs": true,
+    "checkJs": true
   },
-  "types": ["ember-source/types", "@glint/ember-tsc/types"]
+  "types": ["ember-source/types", "@glint/ember-tsc/types", "vite/client", "vitest/importMeta"],
+  "exclude": [
+    "node_modules",
+    "dist",
+    "src/**/layers/*/files/**",
+    "src/**/bases/*/files/**",
+    "my-app"
+  ]
 }

package/vitest.config.js

@@ -0,0 +1,9 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    testTimeout: 60_000,
+    hookTimeout: 60_000,
+    include: ["test/**/*.test.ts", "src/**/*.test.ts"],
+  },
+});

package/src/layers/eslint/index.js

@@ -1,42 +0,0 @@
-import { packageJson, files } from "ember-apply";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-
-/**
- * ESLint Layer
- *
- * Adds ESLint support with modern configuration
- */
-export default {
-  label: "ESLint",
-  description: "Code linting with ESLint",
-
-  async run({ targetDir }) {
-    // Apply config files
-    await files.applyFolder(join(__dirname, "files"), targetDir);
-
-    // Add devDependencies
-    await packageJson.addDevDependencies(
-      {
-        eslint: "^9.18.0",
-        "@typescript-eslint/eslint-plugin": "^8.19.1",
-        "@typescript-eslint/parser": "^8.19.1",
-        "eslint-config-prettier": "^10.0.1",
-        "eslint-plugin-ember": "^12.2.1",
-        globals: "^15.14.0",
-      },
-      targetDir,
-    );
-
-    // Add scripts
-    await packageJson.addScripts(
-      {
-        lint: "eslint . --cache",
-        "lint:fix": "eslint . --fix",
-      },
-      targetDir,
-    );
-  },
-};

package/src/layers/minimal/files/app/app.ts

@@ -1,10 +0,0 @@
-import Application from "@ember/application";
-import compatModules from "@embroider/virtual/compat-modules";
-import Resolver from "ember-resolver";
-import config from "./config.ts";
-
-export default class App extends Application {
-  modulePrefix = config.modulePrefix;
-  podModulePrefix = config.podModulePrefix;
-  Resolver = Resolver.withModules(compatModules);
-}

package/src/layers/minimal/files/app/config.ts

@@ -1,18 +0,0 @@
-const ENV = {
-  modulePrefix: "__PROJECT_NAME__",
-  environment: import.meta.env.DEV ? "development" : "production",
-  rootURL: "/",
-  locationType: "history",
-  EmberENV: {},
-  APP: {},
-} as {
-  environment: string;
-  modulePrefix: string;
-  podModulePrefix?: string;
-  rootURL: string;
-  locationType: "history" | "hash";
-  EmberENV: Record<string, unknown>;
-  APP: Record<string, unknown>;
-};
-
-export default ENV;

package/src/layers/minimal/files/app/router.ts

@@ -1,9 +0,0 @@
-import EmberRouter from "@ember/routing/router";
-import config from "#app/config.ts";
-
-export default class Router extends EmberRouter {
-  location = config.locationType;
-  rootURL = config.rootURL;
-}
-
-Router.map(function () {});

package/src/layers/minimal/files/app/templates/application.gts

@@ -1,7 +0,0 @@
-import { pageTitle } from 'ember-page-title';
-
-<template>
-  {{pageTitle "__PROJECT_NAME__"}}
-
-  {{outlet}}
-</template>

package/src/layers/minimal/files-js/babel.config.js

@@ -1,38 +0,0 @@
-import { dirname } from "node:path";
-import { fileURLToPath } from "node:url";
-import { buildMacros } from "@embroider/macros/babel";
-
-const macros = buildMacros();
-
-export default {
-  plugins: [
-    [
-      "babel-plugin-ember-template-compilation",
-      {
-        compilerPath: "ember-source/dist/ember-template-compiler.js",
-        transforms: [...macros.templateMacros],
-      },
-    ],
-    [
-      "module:decorator-transforms",
-      {
-        runtime: {
-          import: import.meta.resolve("decorator-transforms/runtime-esm"),
-        },
-      },
-    ],
-    [
-      "@babel/plugin-transform-runtime",
-      {
-        absoluteRuntime: dirname(fileURLToPath(import.meta.url)),
-        useESModules: true,
-        regenerator: false,
-      },
-    ],
-    ...macros.babelMacros,
-  ],
-
-  generatorOpts: {
-    compact: false,
-  },
-};

package/src/layers/minimal/index.js

@@ -1,89 +0,0 @@
-import { packageJson, files, js } from "ember-apply";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-import { readFile } from "node:fs/promises";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-
-/**
- * Minimal Layer
- *
- * Provides the absolute bare minimum for an Ember app:
- * - type: "module" in package.json
- * - No @embroider/compat (no-compat mode)
- * - No testing framework
- * - No linting or formatting
- * - No ember-welcome-page
- * - No warp-drive (opt-in if needed)
- */
-export default {
-  label: "Minimal Base",
-  description: "Bare minimum Ember app structure",
-
-  async run({ targetDir, projectName }) {
-    // Apply all files from the files directory
-    await files.applyFolder(join(__dirname, "files"), targetDir);
-
-    // Replace __PROJECT_NAME__ placeholders in specific files
-    const filesToUpdate = [
-      join(targetDir, "app", "config.ts"),
-      join(targetDir, "app", "templates", "application.gts"),
-      join(targetDir, "index.html"),
-    ];
-
-    for (const filePath of filesToUpdate) {
-      const content = await readFile(filePath, "utf-8");
-      const updated = content.replaceAll("__PROJECT_NAME__", projectName);
-      await files.copyFileTo(filePath, { content: updated });
-    }
-
-    // Add dependencies
-    await packageJson.addDependencies(
-      {
-        "@glimmer/component": "^1.1.2",
-        "@glimmer/tracking": "^1.1.2",
-        "@embroider/core": "^3.4.16",
-        "@embroider/macros": "^1.16.7",
-        "@embroider/router": "^2.1.8",
-        "@embroider/vite": "^6.0.2",
-        "@embroider/virtual": "^3.4.16",
-        "ember-page-title": "^8.2.4",
-        "ember-resolver": "^14.0.0",
-        "ember-source": "^6.0.1",
-        vite: "^6.0.3",
-      },
-      targetDir,
-    );
-
-    // Add devDependencies
-    await packageJson.addDevDependencies(
-      {
-        "@babel/core": "^7.26.0",
-        "@babel/plugin-transform-typescript": "^7.26.3",
-        "@rollup/plugin-babel": "^6.0.4",
-        "@tsconfig/ember": "^3.0.8",
-        typescript: "^5.7.3",
-      },
-      targetDir,
-    );
-
-    // Add scripts
-    await packageJson.addScripts(
-      {
-        start: "vite",
-        build: "vite build",
-        preview: "vite preview",
-      },
-      targetDir,
-    );
-
-    // Update package.json to set type: "module" and other metadata
-    await packageJson.modify((json) => {
-      json.name = projectName;
-      json.version = "0.0.0";
-      json.private = true;
-      json.type = "module";
-      return json;
-    }, targetDir);
-  },
-};

package/src/layers/prettier/files/.prettierrc.cjs

@@ -1,15 +0,0 @@
-module.exports = {
-  singleQuote: true,
-  trailingComma: 'es5',
-  printWidth: 100,
-  semi: true,
-  plugins: ['prettier-plugin-ember-template-tag'],
-  overrides: [
-    {
-      files: '*.{gjs,gts}',
-      options: {
-        parser: 'ember-template-tag',
-      },
-    },
-  ],
-};