@azerothjs/compiler 0.3.0-alpha.3 → 0.4.0-beta.2

package/README.md

@@ -0,0 +1,163 @@
+# @azerothjs/compiler
+
+## Overview
+
+The `.azeroth` single-file-component compiler. A `.azeroth` file is a JavaScript
+or TypeScript module written with AzerothJS markup, a JSX-style syntax. The
+compiler locates the markup regions inside otherwise ordinary code and rewrites
+them into `h()` hyperscript calls with fine-grained reactive bindings, leaving
+the rest of the module byte-for-byte. For example:
+
+```
+<h1>Count: {count()}</h1>
+```
+
+compiles to:
+
+```js
+h('h1', {}, 'Count: ', () => (count()))
+```
+
+It has no runtime dependencies and is used both as a build-time tool (the Vite
+plugin) and as the shared language core that the editor tooling reuses.
+
+## Architecture
+
+The compiler does not have a type system, symbol table, or semantic analyzer. It
+treats a `.azeroth` file as code with embedded markup and only transforms the
+markup, which is why the rest of the module passes through unchanged. The
+pipeline, in the order it runs:
+
+1. Scanner: finds markup regions inside arbitrary JavaScript, correctly skipping
+   strings, template literals, comments, and regular expressions, and detecting
+   whether a `<` begins markup or is a comparison or generic.
+2. Parser: turns a markup region into an AST (`parseMarkup`).
+3. Codegen: turns the AST into `h()` and component-call source, adding the
+   reactive wrapping (`() => (...)`) around dynamic expressions.
+4. Compile: orchestrates scan, parse, codegen, and splice back into the module,
+   producing the output plus a source map.
+
+The scanner and parser are exported because the editor tooling
+(`@azerothjs/language-service`) reuses them as its single source of truth for
+markup behavior, rather than re-implementing a second parser that could drift.
+
+## Components
+
+| File | Role |
+| --- | --- |
+| `scanner.ts` | Markup-region detection and the low-level skip helpers. |
+| `parser.ts` | `parseMarkup` and `CompileError`. |
+| `codegen.ts` | `generate`, `walkComponentTags`, the `ExpressionCompiler` hook. |
+| `compile.ts` | `compile`: the end-to-end entry point and `CompileResult`. |
+| `sourcemap.ts` | Source-map construction (VLQ encoding, mappings). |
+| `vite.ts` | `azeroth`: the Vite plugin and its options. |
+| `types.ts` | The markup AST node types and `Span`. |
+
+### Public API
+
+- `compile(source, filename?)` returns the compiled module and its source map.
+- `parseMarkup(source, start)` parses one markup region to an AST node.
+- `generate(node, compileExpression)` emits source for a markup AST node.
+- `walkComponentTags(...)` visits component tags in a region.
+- The scanner helpers (`findMarkupStart`, `skipString`, `skipTemplate`,
+  `skipBalanced`, `skipRegex`, `isIdentStart`, `isIdentPart`, `isWhitespace`,
+  and the comment skippers) are exported for tooling that needs the same
+  scanning behavior.
+- `azeroth(options?)` is the Vite plugin.
+
+## Building
+
+```sh
+npm run build -w @azerothjs/compiler
+```
+
+Several other packages (the language service and server, and anything importing
+the AST or scanner) depend on the compiler being built first; the repository root
+`npm run build` builds in dependency order.
+
+## Testing
+
+```sh
+npx vitest run test/compiler
+```
+
+## Configuration
+
+The Vite plugin (`azeroth`) compiles `.azeroth` files as part of a Vite build.
+Add it to a project's `vite.config`:
+
+```ts
+import { azeroth } from '@azerothjs/compiler';
+
+export default {
+    plugins: [azeroth()]
+};
+```
+
+## Authoring idiom and reactivity rules
+
+A component is a plain function that returns markup; there is no
+`defineComponent` wrapper. Props are the function's first argument, read where
+they are used so they stay reactive:
+
+```
+function Greeting(props: { name: string })
+{
+    return <p>Hello {props.name}</p>;
+}
+```
+
+How the compiler emits each dynamic `{expr}` decides whether it is reactive:
+
+- An event handler (`onClick={…}`), a function literal, a bare reference
+  (`draft`, `props.x`), or an array/object literal is passed through verbatim.
+- Any other expression is wrapped in a getter, `() => (expr)`, so the runtime
+  re-applies it when the signals it reads change. `value={draft()}` becomes
+  `value: () => (draft())`.
+
+`classList()` and `styleMap()` (from `@azerothjs/core`) return a getter, so a
+`class={classList({ active: isActive })}` ends up wrapped as a
+getter-returning-a-getter. The renderer resolves a reactive value by calling
+through while it is still a function, so this works without special-casing in
+the compiler - see `DECISIONS.md` (entry 1) for why the fix lives in the
+renderer rather than here.
+
+An attribute-less, child-less component tag compiles to a zero-argument call,
+`<Comp/>` -> `Comp()`, so a prop-less component never has to declare an unused
+props parameter (`DECISIONS.md`, entry 2).
+
+## Type checking
+
+The compiler only transforms markup; it does not type-check. `tsc` cannot parse
+`.azeroth`, so use `azeroth-tsc` (from `@azerothjs/language-server`) to gate a
+build, the same way `vue-tsc` does for Vue:
+
+```sh
+npx azeroth-tsc            # check every .azeroth file under the cwd
+npx azeroth-tsc -p tsconfig.json
+```
+
+It compiles each file to its virtual TypeScript module, type-checks it against
+the project's tsconfig, and prints `tsc`-style diagnostics mapped back to the
+original `.azeroth` positions, exiting non-zero on the first error. In the
+editor, `@azerothjs/language-service` provides the same analysis live.
+
+## Examples
+
+`examples/Showcase.azeroth` is a single comprehensive `.azeroth` file (a function
+component and a class component) used to exercise both the compiler and the
+editor tooling. Compile a string directly:
+
+```ts
+import { compile } from '@azerothjs/compiler';
+
+const { code, map } = compile('export default () => <h1>Hi {name()}</h1>;', 'App.azeroth');
+```
+
+## Contributing
+
+The scanner is the trickiest part: it must distinguish markup from comparison and
+generic syntax and skip every JavaScript token kind, because a mistake there
+mis-compiles otherwise valid code. Keep its behavior covered by tests under
+`test/compiler`, and remember that the language service depends on the exported
+scanner and parser behaving exactly as the compiler uses them.

package/dist/codegen.d.ts

@@ -0,0 +1,45 @@
+import type { MarkupElement, MarkupFragment } from './types.ts';
+/**
+ * Recompiles arbitrary JS that may contain nested markup.
+ *
+ * @example
+ * ```ts
+ * // The identity compiler leaves plain expressions untouched.
+ * const identity: ExpressionCompiler = (code) => code;
+ * identity('count()'); // 'count()'
+ * ```
+ */
+export type ExpressionCompiler = (code: string) => string;
+/**
+ * Generates code for a markup element or fragment.
+ *
+ * @param node - The element/fragment AST node
+ * @param compileExpression - Recompiles nested-markup-bearing JS
+ *
+ * @returns A source string: `h(...)`, `Component({...})`, or for a fragment,
+ *          an array `[...]`.
+ *
+ * @example
+ * ```ts
+ * const id = (code: string) => code;
+ * const { node } = parseMarkup('<h1>Hi</h1>', 0);
+ * generate(node, id); // "h('h1', {  }, 'Hi')"
+ * ```
+ */
+export declare function generate(node: MarkupElement | MarkupFragment, compileExpression: ExpressionCompiler): string;
+/**
+ * Visits the markup element tree (not expression holes) and calls `visit`
+ * with the tag of every component (capitalised/dotted) element. Used by
+ * compile() to auto-import the built-in components a file references. Holes
+ * are handled by the caller's recursion.
+ *
+ * @example
+ * ```ts
+ * const { node } = parseMarkup('<Show><p>hi</p></Show>', 0);
+ * const tags: string[] = [];
+ * walkComponentTags(node, (tag) => tags.push(tag));
+ * tags; // ['Show'] (the lowercase <p> host element is skipped)
+ * ```
+ */
+export declare function walkComponentTags(node: MarkupElement | MarkupFragment, visit: (tag: string) => void): void;
+//# sourceMappingURL=codegen.d.ts.map

package/dist/codegen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codegen.d.ts","sourceRoot":"","sources":["../src/codegen.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EACR,aAAa,EACb,cAAc,EAGjB,MAAM,YAAY,CAAC;AAEpB;;;;;;;;;GASG;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;AA2P1D;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,aAAa,GAAG,cAAc,EAAE,iBAAiB,EAAE,kBAAkB,GAAG,MAAM,CA4B5G;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,aAAa,GAAG,cAAc,EAAE,KAAK,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,GAAG,IAAI,CAa1G"}

package/dist/codegen.js

@@ -0,0 +1,286 @@
+// Turns a markup AST node into an h() (or component-call) source string. The
+// reactivity rule for how each expression is emitted:
+//
+//   - Event handlers (on*): passed through verbatim.
+//   - Function / bare-identifier expressions: passed through verbatim - they
+//     are already a getter, handler, or component reference.
+//   - Any other dynamic expression: wrapped as `() => (expr)` so h() treats it
+//     as reactive.
+//   - Static "string" attributes: kept as string literals.
+//
+// Expression holes can contain nested markup; we recompile their source via
+// the `compileExpression` callback the caller passes in (which loops back to
+// compile.ts), so `{cond && <p/>}` works.
+/**
+ * True when `code` is an arrow/function literal - pass it through unwrapped.
+ *
+ * @example
+ * ```ts
+ * isFunctionLiteral('(item) => item.name'); // true
+ * isFunctionLiteral('count() + 1');         // false
+ * ```
+ */
+function isFunctionLiteral(code) {
+    const t = code.trim();
+    if (/^async\s+function\b/.test(t) || /^function\b/.test(t)) {
+        return true;
+    }
+    // Arrow: `x => ...`, `(...) => ...`, `async x => ...`, `async (...) => ...`.
+    return /^(async\s+)?(\([^]*?\)|[A-Za-z_$][\w$]*)\s*=>/.test(t);
+}
+/**
+ * True when `code` is a single bare identifier or dotted path (e.g. `draft`, `props.x`).
+ *
+ * @example
+ * ```ts
+ * isBareReference('props.value'); // true
+ * isBareReference('a + b');       // false
+ * ```
+ */
+function isBareReference(code) {
+    return /^[A-Za-z_$][\w$]*(\s*\.\s*[A-Za-z_$][\w$]*)*$/.test(code.trim());
+}
+/**
+ * True when `code` is an array or object literal (`[...]` / `{...}`).
+ *
+ * @example
+ * ```ts
+ * isCollectionLiteral('[resource]'); // true
+ * isCollectionLiteral('count()');    // false
+ * ```
+ */
+function isCollectionLiteral(code) {
+    const t = code.trim();
+    return t.startsWith('[') || t.startsWith('{');
+}
+/**
+ * Decides how a dynamic `{expr}` is emitted. Passed through verbatim when it's
+ * already the right shape for the runtime:
+ *   - an event handler,
+ *   - a function literal (handler / render fn / key fn),
+ *   - a bare reference (a signal getter, a component, props.x),
+ *   - an array/object literal (e.g. `on={[res]}`, a props bag).
+ * Everything else is a computed value, wrapped in a getter so h() (and
+ * reactive props like `when`/`each`) stay fine-grained.
+ *
+ * @example
+ * ```ts
+ * wrapDynamic('a + b', false);   // '() => (a + b)' (computed -> wrapped)
+ * wrapDynamic('count', false);   // 'count' (bare reference -> verbatim)
+ * wrapDynamic('save()', true);   // 'save()' (event handler -> verbatim)
+ * ```
+ */
+function wrapDynamic(code, isEventHandler) {
+    const compiled = code.trim();
+    if (isEventHandler ||
+        isFunctionLiteral(compiled) ||
+        isBareReference(compiled) ||
+        isCollectionLiteral(compiled)) {
+        return compiled;
+    }
+    return `() => (${compiled})`;
+}
+/**
+ * Quotes an object key when it isn't a valid bare identifier.
+ *
+ * @example
+ * ```ts
+ * objectKey('class');     // 'class' (bare identifier, unquoted)
+ * objectKey('data-id');   // "'data-id'" (hyphen -> quoted)
+ * ```
+ */
+function objectKey(name) {
+    return /^[A-Za-z_$][\w$]*$/.test(name) ? name : `'${name}'`;
+}
+/**
+ * True for an `on*` event attribute name (`on` + uppercase letter).
+ *
+ * @example
+ * ```ts
+ * isEventName('onClick'); // true
+ * isEventName('online');  // false (third char is lowercase)
+ * ```
+ */
+function isEventName(name) {
+    return name.length > 2 && name.startsWith('on') && name[2] === name[2].toUpperCase();
+}
+/**
+ * Escapes a literal string for emission inside single quotes.
+ *
+ * @example
+ * ```ts
+ * quoteString('a\'b'); // "'a\\'b'" (the inner quote is escaped)
+ * ```
+ */
+function quoteString(value) {
+    return `'${value.replace(/\\/g, '\\\\').replace(/'/g, '\\\'').replace(/\n/g, '\\n')}'`;
+}
+/**
+ * Emits one attribute as a `key: value` entry (or a spread).
+ *
+ * @example
+ * ```ts
+ * const id = (code: string) => code;
+ * generateAttribute(
+ *     { kind: 'attribute', name: 'id', value: { kind: 'static', value: 'app' }, spread: false },
+ *     id
+ * );
+ * // "id: 'app'"
+ * ```
+ */
+function generateAttribute(attr, compileExpression) {
+    if (attr.spread) {
+        return `...${compileExpression(attr.value.code)}`;
+    }
+    const name = attr.name;
+    const key = objectKey(name);
+    if (attr.value.kind === 'none') {
+        return `${key}: true`;
+    }
+    if (attr.value.kind === 'static') {
+        return `${key}: ${quoteString(attr.value.value)}`;
+    }
+    // Expression value.
+    const compiled = compileExpression(attr.value.code);
+    return `${key}: ${wrapDynamic(compiled, isEventName(name))}`;
+}
+/**
+ * Builds the props object literal for an element/component.
+ *
+ * @example
+ * ```ts
+ * const id = (code: string) => code;
+ * generateProps(
+ *     [{ kind: 'attribute', name: 'id', value: { kind: 'static', value: 'app' }, spread: false }],
+ *     id
+ * );
+ * // "{ id: 'app' }"
+ * ```
+ */
+function generateProps(attrs, compileExpression, extra) {
+    const parts = attrs.map(a => generateAttribute(a, compileExpression));
+    if (extra) {
+        parts.push(extra);
+    }
+    return `{ ${parts.join(', ')} }`;
+}
+/**
+ * Emits a single child as an argument to h() / an array element.
+ *
+ * @example
+ * ```ts
+ * const id = (code: string) => code;
+ * generateChild({ kind: 'text', value: 'Hi', start: 0, end: 2 }, id); // "'Hi'"
+ * generateChild({ kind: 'expression', code: 'a + b', start: 0, end: 5 }, id); // '() => (a + b)'
+ * ```
+ */
+function generateChild(child, compileExpression) {
+    if (child.kind === 'text') {
+        return quoteString(child.value);
+    }
+    if (child.kind === 'expression') {
+        const compiled = compileExpression(child.code);
+        return wrapDynamic(compiled, false);
+    }
+    return generate(child, compileExpression);
+}
+/**
+ * Generates the `children` entry for a component from its markup children. A
+ * lone function-hole child becomes the function itself (e.g.
+ * `<For>{(item) => ...}</For>`); anything else becomes a thunk returning the
+ * child (or an array of children).
+ *
+ * @example
+ * ```ts
+ * const id = (code: string) => code;
+ * // A lone function hole becomes the render function itself.
+ * generateComponentChildren([{ kind: 'expression', code: '(x) => x', start: 0, end: 8 }], id);
+ * // 'children: (x) => x'
+ * // Plain text becomes a thunk.
+ * generateComponentChildren([{ kind: 'text', value: 'Hi', start: 0, end: 2 }], id);
+ * // "children: () => 'Hi'"
+ * ```
+ */
+function generateComponentChildren(children, compileExpression) {
+    if (children.length === 0) {
+        return null;
+    }
+    if (children.length === 1) {
+        const only = children[0];
+        if (only.kind === 'expression') {
+            const compiled = compileExpression(only.code).trim();
+            // A function child IS the render function (For/Match/etc.).
+            if (isFunctionLiteral(compiled)) {
+                return `children: ${compiled}`;
+            }
+            return `children: () => (${compiled})`;
+        }
+        return `children: () => ${generateChild(only, compileExpression)}`;
+    }
+    const items = children.map(c => generateChild(c, compileExpression));
+    return `children: () => [${items.join(', ')}]`;
+}
+/**
+ * Generates code for a markup element or fragment.
+ *
+ * @param node - The element/fragment AST node
+ * @param compileExpression - Recompiles nested-markup-bearing JS
+ *
+ * @returns A source string: `h(...)`, `Component({...})`, or for a fragment,
+ *          an array `[...]`.
+ *
+ * @example
+ * ```ts
+ * const id = (code: string) => code;
+ * const { node } = parseMarkup('<h1>Hi</h1>', 0);
+ * generate(node, id); // "h('h1', {  }, 'Hi')"
+ * ```
+ */
+export function generate(node, compileExpression) {
+    if (node.kind === 'fragment') {
+        const items = node.children.map(c => generateChild(c, compileExpression));
+        return `[${items.join(', ')}]`;
+    }
+    if (node.isComponent) {
+        const childrenEntry = generateComponentChildren(node.children, compileExpression);
+        // No attributes and no children -> a zero-argument call. Emitting
+        // `Comp({  })` instead would force every prop-less component to declare
+        // a props parameter (and the language service would flag the call as
+        // "Expected 0 arguments, but got 1").
+        if (node.attributes.length === 0 && childrenEntry === null) {
+            return `${node.tag}()`;
+        }
+        const props = generateProps(node.attributes, compileExpression, childrenEntry ?? undefined);
+        return `${node.tag}(${props})`;
+    }
+    // Host element -> h('tag', props, ...children).
+    const props = generateProps(node.attributes, compileExpression);
+    const children = node.children.map(c => generateChild(c, compileExpression));
+    const args = [`'${node.tag}'`, props, ...children];
+    return `h(${args.join(', ')})`;
+}
+/**
+ * Visits the markup element tree (not expression holes) and calls `visit`
+ * with the tag of every component (capitalised/dotted) element. Used by
+ * compile() to auto-import the built-in components a file references. Holes
+ * are handled by the caller's recursion.
+ *
+ * @example
+ * ```ts
+ * const { node } = parseMarkup('<Show><p>hi</p></Show>', 0);
+ * const tags: string[] = [];
+ * walkComponentTags(node, (tag) => tags.push(tag));
+ * tags; // ['Show'] (the lowercase <p> host element is skipped)
+ * ```
+ */
+export function walkComponentTags(node, visit) {
+    if (node.kind === 'element' && node.isComponent) {
+        visit(node.tag);
+    }
+    for (const child of node.children) {
+        if (child.kind === 'element' || child.kind === 'fragment') {
+            walkComponentTags(child, visit);
+        }
+    }
+}
+//# sourceMappingURL=codegen.js.map

package/dist/codegen.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"codegen.js","sourceRoot":"","sources":["../src/codegen.ts"],"names":[],"mappings":"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"}

package/dist/compile.d.ts

@@ -0,0 +1,47 @@
+import { type SourceMapV3 } from './sourcemap.ts';
+/** Result of compiling a `.azeroth` source string. */
+export interface CompileResult {
+    /** The compiled JS/TS source. */
+    code: string;
+    /** Source map (original `.azeroth` -> compiled), or `null` when the file
+     *  contained no markup (output is identical to input). */
+    map: SourceMapV3 | null;
+}
+/**
+ * Compiles a `.azeroth` source string: markup -> h() calls, with the `h`
+ * import auto-injected when needed.
+ *
+ * @param source - The `.azeroth` module source
+ *
+ * @returns The compiled JS/TS and its source map
+ *
+ * Without compile: author UI as nested h() calls by hand, wrapping every
+ * dynamic hole in a getter yourself:
+ *
+ *     import { h } from '@azerothjs/core';
+ *     export default () =>
+ *         h('h1', {  }, 'Hello ', () => (name())); // hand-write h() + getters, easy to get wrong
+ *
+ * With compile: write the markup in a `.azeroth` file and compile() emits the
+ * equivalent h() calls (and the `h` import) for you:
+ *
+ *     const { code } = compile('export default () => <h1>Hello {name()}</h1>;');
+ *     // code -> import { h } from '@azerothjs/core'; ... h('h1', {  }, 'Hello ', () => (name()))
+ *     // write JSX-like markup; the getters and the import are generated
+ *
+ * @example
+ * ```ts
+ * const { code } = compile(`
+ *   export default function Hi() {
+ *     return <h1>Hello {name()}</h1>;
+ *   }
+ * `);
+ * // code becomes:
+ * //   import { h } from '@azerothjs/core';
+ * //   export default function Hi() {
+ * //     return h('h1', {  }, 'Hello ', () => (name()));
+ * //   }
+ * ```
+ */
+export declare function compile(source: string, filename?: string): CompileResult;
+//# sourceMappingURL=compile.d.ts.map

package/dist/compile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compile.d.ts","sourceRoot":"","sources":["../src/compile.ts"],"names":[],"mappings":"AAiBA,OAAO,EAIH,KAAK,WAAW,EAEnB,MAAM,gBAAgB,CAAC;AAexB,sDAAsD;AACtD,MAAM,WAAW,aAAa;IAE1B,iCAAiC;IACjC,IAAI,EAAE,MAAM,CAAC;IAEb;8DAC0D;IAC1D,GAAG,EAAE,WAAW,GAAG,IAAI,CAAC;CAC3B;AA8BD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAgB,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,SAAmB,GAAG,aAAa,CAmFlF"}