zmod-ember 0.1.0

package/README.md

@@ -0,0 +1,139 @@
+# zmod-ember
+
+This repo provides an adapter for [zmod](https://github.com/NaamuKim/zmod) for ember's gjs and gts files via [ember-estree](https://github.com/NullVoxPopuli/ember-estree) as zmod's default parser is [oxc](https://github.com/oxc-project/oxc)-parser, which is ESTree-compatible.
+
+## Installation
+
+```bash
+pnpm add zmod-ember zmod
+```
+
+## Usage
+
+### With `z.withParser()`
+
+```ts
+import { z } from "zmod";
+import { emberParser } from "zmod-ember";
+
+const j = z.withParser(emberParser);
+
+const source = `import Component from '@glimmer/component';
+
+export default class OldComponent extends Component {
+  <template>
+    <h1>Hello {{@name}}</h1>
+  </template>
+}
+`;
+
+const root = j(source, { filePath: "my-component.gjs" });
+
+root.find(j.Identifier, { name: "OldComponent" }).replaceWith("NewComponent");
+
+console.log(root.toSource());
+```
+
+### As a transform module
+
+```ts
+import type { Transform } from "zmod";
+import { emberParser } from "zmod-ember";
+
+// Export the parser so zmod's `run()` uses it for all files
+export const parser = emberParser;
+
+const transform: Transform = ({ source, path }, { z }) => {
+  const root = z(source, { filePath: path });
+
+  root.find(z.Identifier, { name: "OldName" }).replaceWith("NewName");
+
+  return root.toSource();
+};
+
+export default transform;
+```
+
+### Operating on Glimmer nodes
+
+Glimmer template nodes are exposed as `Glimmer*`-prefixed types and can be found using string-based type queries:
+
+```ts
+import { z } from "zmod";
+import { emberParser } from "zmod-ember";
+
+const j = z.withParser(emberParser);
+
+const source = `<template>
+  <OldComponent @oldArg={{this.value}}>
+    <:header>Header</:header>
+  </OldComponent>
+</template>
+`;
+
+const root = j(source, { filePath: "component.gjs" });
+
+// Rename a component
+root.find("GlimmerElementNode", { tag: "OldComponent" }).forEach((path) => {
+  path.node.tag = "NewComponent";
+});
+
+// Rename an argument
+root.find("GlimmerAttrNode", { name: "@oldArg" }).replaceWith("@newArg={{this.value}}");
+
+// Rename a named block
+root.find("GlimmerElementNode", { tag: ":header" }).replaceWith("<:title>Header</:title>");
+
+console.log(root.toSource());
+```
+
+Other Glimmer node types you can query include `GlimmerMustacheStatement`, `GlimmerBlockStatement`, `GlimmerPathExpression`, `GlimmerTextNode`, `GlimmerElementModifierStatement`, `GlimmerSubExpression`, `GlimmerHashPair`, `GlimmerStringLiteral`, `GlimmerNumberLiteral`, and `GlimmerBlockParam`.
+
+### Running transforms
+
+```ts
+import { run } from "zmod";
+import transform from "./my-transform.js";
+
+const result = await run(transform, {
+  include: ["src/**/*.gjs", "src/**/*.gts"],
+});
+
+console.log(result.files);
+```
+
+## How it works
+
+The adapter wraps [ember-estree](https://github.com/NullVoxPopuli/ember-estree)'s `toTree()` to implement zmod's [`Parser` interface](https://github.com/NaamuKim/zmod/blob/main/packages/zmod/src/parser.ts):
+
+- **`parse(source, options)`** — Calls `toTree` and returns an ESTree-compatible AST with embedded Glimmer template nodes. All nodes are guaranteed to have `start`/`end` byte-offset properties required by zmod's span-based patching. Handles both top-level and class body `<template>` tags.
+- **`print(node)`** — Serializes AST nodes back to source code. Handles standard ESTree nodes and Glimmer template nodes (e.g., `GlimmerElementNode`, `GlimmerMustacheStatement`).
+
+Pass `{ filePath: 'name.gjs' }` or `{ filePath: 'name.gts' }` in the parse options to control the file type.
+
+> **Note:** Use zmod's default parser for plain `.js` and `.ts` files — `zmod-ember` is only needed for `.gjs` and `.gts` files that contain `<template>` tags. For codemods that target both standard JS/TS and Ember template files, use `zmod-ember` only for the `.gjs`/`.gts` files:
+>
+> ```ts
+> import { z, run } from "zmod";
+> import { emberParser } from "zmod-ember";
+>
+> // For .gjs/.gts files, use the ember parser
+> const gjsTransform = ({ source, path }, { z }) => {
+>   return z(source, { filePath: path })
+>     .find(z.Identifier, { name: "OldName" })
+>     .replaceWith("NewName")
+>     .toSource();
+> };
+> gjsTransform.parser = emberParser;
+>
+> // For .js/.ts files, use zmod's default parser (no parser export needed)
+> const jsTransform = ({ source }, { z }) => {
+>   return z(source).find(z.Identifier, { name: "OldName" }).replaceWith("NewName").toSource();
+> };
+> ```
+
+## Peer dependencies
+
+| Package | Required | Notes                |
+| ------- | -------- | -------------------- |
+| `zmod`  | Yes      | Core codemod toolkit |

package/dist/index.d.ts

@@ -0,0 +1,40 @@
+import type { Parser } from "zmod";
+/**
+ * A zmod `Parser` adapter for Ember's `.gjs` and `.gts` files.
+ *
+ * Uses `ember-estree` to parse files containing `<template>` tags
+ * into an ESTree-compatible AST with embedded Glimmer template nodes.
+ *
+ * @example
+ * ```ts
+ * import { z } from 'zmod';
+ * import { emberParser } from 'zmod-ember';
+ *
+ * const j = z.withParser(emberParser);
+ * const root = j(gjsSource, { filePath: 'my-component.gjs' });
+ *
+ * root.find(j.Identifier, { name: 'OldName' })
+ *     .replaceWith('NewName');
+ *
+ * console.log(root.toSource());
+ * ```
+ *
+ * @example
+ * ```ts
+ * // As a transform module export
+ * import type { Transform } from 'zmod';
+ * import { emberParser } from 'zmod-ember';
+ *
+ * export const parser = emberParser;
+ *
+ * const transform: Transform = ({ source }, { z }) => {
+ *   const root = z(source);
+ *   // ... transform logic
+ *   return root.toSource();
+ * };
+ *
+ * export default transform;
+ * ```
+ */
+export declare const emberParser: Parser;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAgB,MAAM,MAAM,CAAC;AAEjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,eAAO,MAAM,WAAW,EAAE,MAOzB,CAAC"}

package/dist/index.js

@@ -0,0 +1,46 @@
+import { toTree, print as emberPrint } from "ember-estree";
+/**
+ * A zmod `Parser` adapter for Ember's `.gjs` and `.gts` files.
+ *
+ * Uses `ember-estree` to parse files containing `<template>` tags
+ * into an ESTree-compatible AST with embedded Glimmer template nodes.
+ *
+ * @example
+ * ```ts
+ * import { z } from 'zmod';
+ * import { emberParser } from 'zmod-ember';
+ *
+ * const j = z.withParser(emberParser);
+ * const root = j(gjsSource, { filePath: 'my-component.gjs' });
+ *
+ * root.find(j.Identifier, { name: 'OldName' })
+ *     .replaceWith('NewName');
+ *
+ * console.log(root.toSource());
+ * ```
+ *
+ * @example
+ * ```ts
+ * // As a transform module export
+ * import type { Transform } from 'zmod';
+ * import { emberParser } from 'zmod-ember';
+ *
+ * export const parser = emberParser;
+ *
+ * const transform: Transform = ({ source }, { z }) => {
+ *   const root = z(source);
+ *   // ... transform logic
+ *   return root.toSource();
+ * };
+ *
+ * export default transform;
+ * ```
+ */
+export const emberParser = {
+    parse(source, options) {
+        return toTree(source, options);
+    },
+    print(node) {
+        return emberPrint(node);
+    },
+};

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "zmod-ember",
+  "version": "0.1.0",
+  "description": "zmod parser adapter for Ember's .gjs and .gts files via ember-estree",
+  "keywords": [
+    "codemod",
+    "ember",
+    "gjs",
+    "glimmer",
+    "gts",
+    "parser",
+    "zmod"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/NullVoxPopuli/zmod-ember.git"
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      }
+    }
+  },
+  "dependencies": {
+    "ember-estree": "^0.2.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.5.0",
+    "oxfmt": "^0.40.0",
+    "oxlint": "^1.55.0",
+    "release-plan": "^0.17.4",
+    "typescript": "^5.3.3",
+    "vitest": "^3.2.1",
+    "zmod": "^0.3.1"
+  },
+  "peerDependencies": {
+    "zmod": "^0.3.1"
+  },
+  "engines": {
+    "node": ">=20.19.0"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  },
+  "scripts": {
+    "format": "oxfmt",
+    "format:check": "oxfmt --check",
+    "lint": "oxlint && pnpm format:check",
+    "lint:fix": "oxlint --fix && oxfmt",
+    "test": "vitest run"
+  }
+}

package/src/index.ts

@@ -0,0 +1,48 @@
+import { toTree, print as emberPrint } from "ember-estree";
+import type { Parser, ParseOptions } from "zmod";
+
+/**
+ * A zmod `Parser` adapter for Ember's `.gjs` and `.gts` files.
+ *
+ * Uses `ember-estree` to parse files containing `<template>` tags
+ * into an ESTree-compatible AST with embedded Glimmer template nodes.
+ *
+ * @example
+ * ```ts
+ * import { z } from 'zmod';
+ * import { emberParser } from 'zmod-ember';
+ *
+ * const j = z.withParser(emberParser);
+ * const root = j(gjsSource, { filePath: 'my-component.gjs' });
+ *
+ * root.find(j.Identifier, { name: 'OldName' })
+ *     .replaceWith('NewName');
+ *
+ * console.log(root.toSource());
+ * ```
+ *
+ * @example
+ * ```ts
+ * // As a transform module export
+ * import type { Transform } from 'zmod';
+ * import { emberParser } from 'zmod-ember';
+ *
+ * export const parser = emberParser;
+ *
+ * const transform: Transform = ({ source }, { z }) => {
+ *   const root = z(source);
+ *   // ... transform logic
+ *   return root.toSource();
+ * };
+ *
+ * export default transform;
+ * ```
+ */
+export const emberParser: Parser = {
+  parse(source: string, options?: ParseOptions): any {
+    return toTree(source, options as any);
+  },
+  print(node: any): string {
+    return emberPrint(node);
+  },
+};