ember.nvp 0.5.0 → 0.7.0

package/packages/rolldown/src/transform.ts

@@ -0,0 +1,162 @@
+import { Preprocessor } from "content-tag";
+import { existsSync } from "node:fs";
+import { readFile, writeFile, readdir } from "node:fs/promises";
+import path from "node:path";
+import type { Plugin } from "rolldown";
+
+const processor = new Preprocessor();
+
+/**
+ * `.d.ts` files emitted for `.gts` source reference the original `.gts`
+ * specifiers. Consumers can't resolve those, so we rewrite them back to
+ * extension-less specifiers.
+ */
+function fixDeclarationImports(content: string): string {
+  return content
+    .replace(/from\s+'([^']+)\.gts'/g, "from '$1'")
+    .replace(/from\s+"([^"]+)\.gts"/g, 'from "$1"')
+    .replace(/import\("([^"]+)\.gts"\)/g, 'import("$1")')
+    .replace(/import\('([^']+)\.gts'\)/g, "import('$1')");
+}
+
+async function fixDtsExtensionsInDir(dir: string): Promise<void> {
+  const entries = await readdir(dir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+
+    if (entry.isDirectory()) {
+      await fixDtsExtensionsInDir(fullPath);
+    } else if (entry.name.endsWith(".d.ts")) {
+      const content = await readFile(fullPath, { encoding: "utf8" });
+      const fixed = fixDeclarationImports(content);
+
+      if (fixed !== content) {
+        await writeFile(fullPath, fixed);
+      }
+    }
+  }
+}
+
+/**
+ * Maps `.gts` -> `.ts` and `.gjs` -> `.js` (so rolldown can identify them as
+ * ts/js) and preprocesses `<template>` via content-tag.
+ */
+export function emberTransform(): Plugin {
+  const virtualFiles = new Set<string>();
+
+  return {
+    name: "ember:transform",
+
+    resolveId: {
+      order: "pre",
+      handler(id, importer) {
+        if (!importer) return null;
+
+        const fileName = path.join(path.dirname(importer), id);
+
+        if (id.endsWith(".gts") && !importer.endsWith(".d.ts")) {
+          virtualFiles.add(fileName);
+          return {
+            id: fileName.replace(/\.gts$/, ".ts"),
+            meta: { fileName },
+          };
+        }
+
+        if (id.endsWith(".gjs") && !importer.endsWith(".d.ts")) {
+          virtualFiles.add(fileName);
+          return {
+            id: fileName.replace(/\.gjs$/, ".js"),
+            meta: { fileName },
+          };
+        }
+
+        if (id.endsWith(".d.ts") && importer.endsWith(".d.ts")) {
+          const gtsFile = fileName.replace(".d.ts", ".gts");
+          if (virtualFiles.has(gtsFile)) {
+            return fileName;
+          }
+        }
+
+        if (id.endsWith(".ts") && !importer.endsWith(".d.ts")) {
+          const gtsFileName = fileName.replace(/\.ts$/, ".gts");
+          if (existsSync(gtsFileName) && !existsSync(fileName)) {
+            virtualFiles.add(gtsFileName);
+            return { id: fileName, meta: { fileName: gtsFileName } };
+          }
+        }
+
+        if (id.endsWith(".js") && !importer.endsWith(".d.ts")) {
+          const gjsFileName = fileName.replace(/\.js$/, ".gjs");
+          if (existsSync(gjsFileName) && !existsSync(fileName)) {
+            virtualFiles.add(gjsFileName);
+            return { id: fileName, meta: { fileName: gjsFileName } };
+          }
+        }
+
+        return null;
+      },
+    },
+
+    load: {
+      order: "pre",
+      filter: {
+        id: /\.(ts|js)$/,
+      },
+      async handler(id) {
+        const meta = this.getModuleInfo(id)?.meta ?? {};
+        const fileName = meta?.fileName;
+
+        if (fileName) {
+          this.addWatchFile(fileName);
+          const source = await readFile(fileName, { encoding: "utf8" });
+
+          if (source.includes("<template>")) {
+            const { code, map } = processor.process(source, {
+              filename: fileName,
+            });
+            return { code, map };
+          }
+
+          return source;
+        }
+
+        return null;
+      },
+    },
+
+    transform: {
+      order: "pre",
+      filter: {
+        code: /\.gts/,
+        id: /\.(js|ts)$/,
+      },
+      handler(input, id) {
+        if (input.includes(".gts") && id.endsWith(".d.ts")) {
+          return input.replace(
+            /(['"`])((?:\.\.?\/|\/|@|[A-Za-z0-9_\-])[^'"]*?\.gts)\1/g,
+            (_m, q, p) => `${q}${p.replace(/\.gts$/, ".d.ts")}${q}`,
+          );
+        }
+
+        if (input.includes(".gts") && !id.endsWith(".d.ts")) {
+          return input.replace(
+            /(['"`])((?:\.\.?\/|\/|@|[A-Za-z0-9_\-])[^'"]*?\.gts)\1/g,
+            (_m, q, p) => `${q}${p.replace(/\.gts$/, ".ts")}${q}`,
+          );
+        }
+
+        return input;
+      },
+    },
+
+    writeBundle: {
+      async handler(options) {
+        const outDir = (options as { dir?: string }).dir;
+        if (outDir) {
+          await fixDtsExtensionsInDir(path.resolve(outDir));
+        }
+      },
+    },
+  };
+}

package/packages/vite/README.md

@@ -8,7 +8,9 @@ A speed-optimized default meta-config for ember projects.
 npm add @nullvoxpopuli/ember-vite
 ```
 
-Requires node 24+
+Requires node 24+, and — since these packages ship TypeScript source — a
+modern TypeScript when type-checking: 6+ with `lib` covering `es2025` (e.g.
+`esnext`).
 
 ## Usage
 
@@ -43,34 +45,18 @@ The `ember()` plugin takes the following options:
 
 ```ts
 ember({
-  // optional production configs
   production: {
-    // optional configuration of codeSplitting.groups
-    // in the vite config.
-    //
-    // Docs here:
-    // https://rolldown.rs/reference/OutputOptions.codeSplitting#groups
     codeSplittingGroups: [
-      /* ... */
+      /* https://rolldown.rs/reference/OutputOptions.codeSplitting#groups */
     ],
   },
-  // optional babel config
   babel: {
-    // defaults to true.
-    // when babel runs, do so in parallel across many cores.
     parallel: false,
-    // optional way to configure when babel is activateed.
-    // by default, all transforming is oxc, except when babel is needed
-    // (for things not currently implemented in oxc)
     include: {
-      // if a file imports from anything in this array, use babel instead of
-      // oxc for that file.
-      //
-      // For example: ['ember-concurrency', 'ember-intl/format-message'],
-      whenImporting: [
-        /* ... */
-      ],
+      whenImporting: ["ember-concurrency", "ember-intl/format-message"],
     },
   },
 });
 ```
+
+Each option is documented on its type.

package/packages/vite/index.ts

@@ -1,2 +1,2 @@
 export { ember } from "./src/ember.ts";
-export { maybeBabel } from "./src/maybe-babel.ts";
+export { maybeBabel } from "@nullvoxpopuli/ember-build-tooling-utils";

package/packages/vite/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nullvoxpopuli/ember-vite",
-  "version": "1.0.3",
+  "version": "1.1.0",
   "description": "Meta plugin for ember projects focusing on speed.",
   "type": "module",
   "main": "index.ts",
@@ -27,18 +27,16 @@
   "dependencies": {
     "@babel/core": "^7.28.10",
     "@embroider/core": "^4.4.2",
+    "@embroider/macros": "^1.20.3",
     "@embroider/vite": "^1.5.0",
-    "@rollup/plugin-babel": "^7.1.0",
-    "oxc-parser": "^0.132.0",
-    "oxc-transform": "^0.132.0",
-    "zimmerframe": "^1.1.4"
+    "@nullvoxpopuli/ember-build-tooling-utils": "workspace:*"
   },
   "engines": {
     "node": ">= 24"
   },
   "devDependencies": {
     "rolldown": "^1.1.2",
-    "typescript": "^5.9.3",
+    "typescript": "^6.0.3",
     "vite": "^8.0.14"
   }
 }

package/packages/vite/src/ember.ts

@@ -1,9 +1,12 @@
+import { buildMacros } from "@embroider/macros/babel";
 import { ember as embroiderEmber, extensions, resolver, templateTag } from "@embroider/vite";
 import { existsSync } from "node:fs";
 import { join, resolve } from "node:path";
 import type { ConfigEnv, ResolvedConfig } from "vite";
 
-import { maybeBabel } from "./maybe-babel.ts";
+import { maybeBabel } from "@nullvoxpopuli/ember-build-tooling-utils";
+
+import { testHtml } from "./test-html.ts";
 
 const emberConfig = embroiderEmber()[3]!;
 
@@ -12,6 +15,92 @@ function absolutePath(relativePath: string) {
   return join(cwd, relativePath);
 }
 
+/**
+ * Everything a project without its own babel config needs:
+ *
+ * - TypeScript stripping
+ * - template compilation (wire format: vite serves/bundles for the
+ *   project's own ember-source, so the final compile happens here)
+ * - build macros, evaluated at build time
+ * - decorator-transforms, with its runtime left as a bare specifier so it
+ *   resolves from the project (which depends on `decorator-transforms`)
+ *
+ * The plugins are named, not imported: babel resolves them from the
+ * project, which carries them as its own dependencies.
+ */
+function defaultBabelPlugins() {
+  const macros = buildMacros();
+
+  return [
+    [
+      "@babel/plugin-transform-typescript",
+      {
+        allExtensions: true,
+        onlyRemoveTypeImports: true,
+        allowDeclareFields: true,
+      },
+    ],
+    ["babel-plugin-ember-template-compilation", { transforms: [...macros.templateMacros] }],
+    ["module:decorator-transforms", { runtime: { import: "decorator-transforms/runtime-esm" } }],
+    ...macros.babelMacros,
+  ];
+}
+
+type BabelOptions =
+  | { configFile: string }
+  | {
+      configFile: false;
+      babelrc: false;
+      babelHelpers: "inline";
+      plugins: ReturnType<typeof defaultBabelPlugins>;
+    };
+
+/**
+ * The project's babel config wins when it exists -- `babel.configFile`
+ * selects which one (e.g. a test-only `config/test/babel.config.js`).
+ * Without one (libraries), `defaultBabelPlugins` covers TypeScript,
+ * templates, macros, and decorators, so no config file is required --
+ * helpers are inlined because projects without a babel config don't
+ * carry `@babel/runtime`.
+ */
+function babelOptions(nvpConfig: Config): BabelOptions {
+  const configFile = resolve(
+    join(process.cwd(), nvpConfig.babel?.configFile ?? "./babel.config.js"),
+  );
+
+  if (existsSync(configFile)) {
+    return { configFile };
+  }
+
+  return {
+    configFile: false,
+    babelrc: false,
+    babelHelpers: "inline",
+    plugins: defaultBabelPlugins(),
+  };
+}
+
+/**
+ * Additional opt-ins beyond maybeBabel's built-in list.
+ *
+ * These libraries ship code that still needs babel (ember-concurrency's
+ * decorators, ember-scoped-css transforms, ember-intl's formatMessage macro),
+ * and the `initializeRuntimeMacrosConfig` runtime call must be compiled away.
+ */
+function babelFilter(nvpConfig: Config) {
+  return {
+    include: {
+      imports: [
+        "ember-concurrency",
+        "ember-scoped-css",
+        "ember-intl/helpers/format-message",
+        ...(nvpConfig.babel?.include?.whenImporting ?? []),
+      ],
+      code: [/\bintl\.formatMessage\b/, "initializeRuntimeMacrosConfig"] as (string | RegExp)[],
+    },
+  };
+}
+
 interface Config {
   babel?: {
     /**
@@ -20,6 +109,16 @@ interface Config {
      */
     parallel?: false;
 
+    /**
+     * which babel config file to use for this build, relative to the
+     * project root. defaults to "./babel.config.js".
+     *
+     * useful when the root babel config belongs to another pipeline
+     * (e.g. a library's publish build) and the vite build needs its own,
+     * such as "./config/test/babel.config.js".
+     */
+    configFile?: string;
+
     /**
      * optional way to configure when babel is activateed.
      * by default, all transforming is oxc, except when babel is needed
@@ -51,8 +150,8 @@ interface Config {
 }
 
 export function ember(nvpConfig: Config = {}) {
-  const babelConfigFile = resolve(join(process.cwd(), "./babel.config.js"));
-  const defaultEnv = { mode: process.env.NODE_ENV || "development" };
+  const babel = babelOptions(nvpConfig);
+  const filter = babelFilter(nvpConfig);
 
   /*
    * Plugins must be returned as top-level array entries — NOT pushed into
@@ -98,16 +197,21 @@ export function ember(nvpConfig: Config = {}) {
           // Libraries will have precompileTemplate and macros, etc,
           // and we need to compile that away using this app's
           // template compiler
-          maybeBabel({ env, parallel: nvpConfig.babel?.parallel, configFile: babelConfigFile }),
+          maybeBabel({
+            ...babel,
+            parallel: nvpConfig.babel?.parallel,
+            filter,
+          }),
         ];
       },
     },
     resolver({ rolldown: true }),
     templateTag(),
+    testHtml(),
     maybeBabel({
-      env: defaultEnv,
+      ...babel,
       parallel: nvpConfig.babel?.parallel,
-      configFile: babelConfigFile,
+      filter,
     }),
   ];
 }
@@ -146,13 +250,10 @@ function dev(viteConfig: ResolvedConfig, nvpConfig: Config) {
   viteConfig.build.rolldownOptions.input ||= {};
   viteConfig.build.rolldownOptions.output ||= {};
 
-  Object.assign(viteConfig.build.rolldownOptions.input, {
-    main: absolutePath("./index.html"),
-  });
-
-  if (existsSync("./tests.html")) {
+  // libraries don't, by default, have a "demo app" entrypoint
+  if (existsSync("./index.html")) {
     Object.assign(viteConfig.build.rolldownOptions.input, {
-      tests: absolutePath("./tests.html"),
+      main: absolutePath("./index.html"),
     });
   }
 
@@ -160,6 +261,16 @@ function dev(viteConfig: ResolvedConfig, nvpConfig: Config) {
     Object.assign(viteConfig.build.rolldownOptions.input, {
       tests: absolutePath("./tests/index.html"),
     });
+  } else if (existsSync("./tests.html")) {
+    Object.assign(viteConfig.build.rolldownOptions.input, {
+      tests: absolutePath("./tests.html"),
+    });
+  } else if (existsSync("./tests")) {
+    // no html of its own: the default-test-html plugin answers for
+    // tests/index.html
+    Object.assign(viteConfig.build.rolldownOptions.input, {
+      tests: absolutePath("./tests/index.html"),
+    });
   }
 
   Object.assign(viteConfig.build.rolldownOptions.output, {
@@ -203,9 +314,12 @@ function prod(viteConfig: ResolvedConfig, nvpConfig: Config) {
   viteConfig.build.rolldownOptions.optimization ||= {};
   viteConfig.build.rolldownOptions.output ||= {};
 
-  Object.assign(viteConfig.build.rolldownOptions.input, {
-    main: absolutePath("./index.html"),
-  });
+  // libraries don't, by default, have a "demo app" entrypoint
+  if (existsSync("./index.html")) {
+    Object.assign(viteConfig.build.rolldownOptions.input, {
+      main: absolutePath("./index.html"),
+    });
+  }
 
   Object.assign(viteConfig.build.rolldownOptions.optimization, {
     inlineConst: {

package/packages/vite/src/test-html.ts

@@ -0,0 +1,86 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import type { ViteDevServer } from "vite";
+
+/**
+ * Everything a QUnit + testem run needs, with no project-specific
+ * references: root-relative specifiers keep it independent of where the
+ * project keeps its files, and the globs pick up tests/** as well as
+ * co-located `*-test` modules under src/**.
+ */
+const DEFAULT_TEST_HTML = `<!doctype html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <title>Tests</title>
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+  </head>
+  <body>
+    <div id="qunit"></div>
+    <div id="qunit-fixture">
+      <div id="ember-testing-container">
+        <div id="ember-testing"></div>
+      </div>
+    </div>
+
+    <script src="/testem.js" integrity="" data-embroider-ignore></script>
+    <script type="module">
+      import "ember-testing";
+    </script>
+
+    <script type="module">
+      import { start } from "/tests/test-helper";
+      import.meta.glob("/tests/**/*.{js,ts,gjs,gts}", { eager: true });
+      import.meta.glob("/src/**/*-test.{js,ts,gjs,gts}", { eager: true });
+      start();
+    </script>
+  </body>
+</html>
+`;
+
+/**
+ * Lets a project run its tests without maintaining a tests/index.html:
+ * whenever that file is absent, this plugin answers for it -- `load`
+ * supplies the html to the build (so `tests/index.html` still lands in
+ * dist for testem), and the dev-server middleware serves it (through
+ * `transformIndexHtml`, so the html goes through the same pipeline as an
+ * on-disk file).
+ *
+ * A tests/index.html on disk always wins; every hook here defers to it.
+ */
+export function testHtml() {
+  const htmlPath = join(process.cwd(), "tests", "index.html");
+
+  return {
+    name: "ember:default-test-html",
+
+    resolveId(id: string) {
+      if (id === htmlPath && !existsSync(htmlPath)) {
+        return id;
+      }
+    },
+
+    load(id: string) {
+      if (id === htmlPath && !existsSync(htmlPath)) {
+        return DEFAULT_TEST_HTML;
+      }
+    },
+
+    configureServer(server: ViteDevServer) {
+      server.middlewares.use(async (req, res, next) => {
+        if (existsSync(htmlPath)) return next();
+
+        const url = (req.url ?? "").split("?")[0];
+
+        if (url !== "/tests" && url !== "/tests/" && url !== "/tests/index.html") {
+          return next();
+        }
+
+        const html = await server.transformIndexHtml("/tests/index.html", DEFAULT_TEST_HTML);
+
+        res.setHeader("Content-Type", "text/html");
+        res.end(html);
+      });
+    },
+  };
+}

package/src/bases/minimal-app/files/app/router.ts

@@ -1,4 +1,5 @@
 import EmbroiderRouter from "@embroider/router";
+
 import config from "#config";
 
 export default class Router extends EmbroiderRouter {

package/src/bases/minimal-app/files/tsconfig.json

@@ -2,6 +2,7 @@
   "extends": "@ember/app-tsconfig",
   "compilerOptions": {
     "allowJs": true,
+    "lib": ["esnext", "dom", "dom.iterable"],
     "types": [
       "ember-source/types",
       "@embroider/core/virtual",

package/src/bases/minimal-app/index.js

@@ -1,6 +1,6 @@
 import { packageJson, js } from "ember-apply";
+import { join } from "node:path";
 import { getLatest } from "#utils/npm.js";
-import { fileURLToPath } from "node:url";
 import { applyFolderTo } from "#utils/fs.js";
 import { removeConfiguredPlugin } from "#utils/babel.js";
 
@@ -49,7 +49,7 @@ async function updateBabelConfig(project) {
  * @param {import('#utils/project.js').Project} project
  */
 async function applyFiles(project) {
-  let filePath = fileURLToPath(new URL("files", import.meta.url));
+  let filePath = join(import.meta.dirname, "files");
 
   await applyFolderTo(filePath, project);
 }

package/src/bases/minimal-library/files/README.md

@@ -0,0 +1,41 @@
+# minimal-library
+
+An Ember v2 library (addon) built with
+[`@nullvoxpopuli/ember-rolldown`](https://github.com/NullVoxPopuli/ember.nvp/tree/main/packages/rolldown)
+and [tsdown](https://tsdown.dev/).
+
+## Development
+
+```bash
+pnpm install
+```
+
+Build the distributable (JS + `.d.ts` into `dist/`):
+
+```bash
+pnpm build
+```
+
+Rebuild on change while developing:
+
+```bash
+pnpm start
+```
+
+## Structure
+
+- `src/` — your library source. Author components in `.gts`/`.gjs`
+  (template-tag) and plain modules in `.ts`/`.js`.
+- `src/index.ts` — the public entry point. Everything a consumer can import
+  must be re-exported from here (or added as an entry in `tsdown.config.js`).
+- `dist/` — the built output that gets published (git-ignored).
+
+Declarations are emitted with
+[isolated declarations](https://www.typescriptlang.org/tsconfig/#isolatedDeclarations),
+so every exported value needs an explicit type annotation — in particular,
+annotate exported template-only components with `TOC<...>`.
+
+## Publishing
+
+`dist/` is built automatically on `prepack`, so `npm publish` ships the
+compiled output plus your `src/`.

package/src/bases/minimal-library/files/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "minimal-library",
+  "version": "0.0.0",
+  "private": true,
+  "description": "Your Ember library's description here",
+  "license": "MIT",
+  "author": "",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./*": {
+      "types": "./dist/*.d.ts",
+      "default": "./dist/*.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "scripts": {
+    "build": "tsdown",
+    "prepack": "tsdown",
+    "start": "tsdown --watch"
+  },
+  "dependencies": {
+    "decorator-transforms": "^2.3.2"
+  },
+  "peerDependencies": {
+    "@glimmer/component": "^2.0.0",
+    "ember-source": ">= 6.0.0"
+  },
+  "devDependencies": {
+    "@ember/library-tsconfig": "^2.0.0",
+    "@glimmer/component": "^2.1.1",
+    "@nullvoxpopuli/ember-rolldown": "workspace:*",
+    "ember-source": "~7.0.0",
+    "tsdown": "^0.22.7",
+    "typescript": "^6.0.3"
+  },
+  "engines": {
+    "node": ">= 24"
+  },
+  "ember": {
+    "edition": "octane"
+  }
+}

package/src/bases/minimal-library/files/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "extends": "@ember/library-tsconfig",
+  "include": ["src"],
+  "compilerOptions": {
+    "rootDir": "./src",
+    "lib": ["esnext", "dom", "dom.iterable"],
+    "isolatedDeclarations": true,
+    "types": ["ember-source/types", "@glint/ember-tsc/types"]
+  }
+}

package/src/bases/minimal-library/files/tsdown.config.js

@@ -0,0 +1,6 @@
+import { defineConfig, ember } from "@nullvoxpopuli/ember-rolldown";
+
+export default defineConfig({
+  entry: ["./src/index.ts"],
+  plugins: [ember()],
+});