@azerothjs/typescript-plugin 0.4.0-beta.3

package/README.md

@@ -0,0 +1,88 @@
+# @azerothjs/typescript-plugin
+
+## Overview
+
+A TypeScript language-service plugin that teaches `tsserver` (the engine behind
+VS Code's built-in TypeScript support, and any editor that uses it) to resolve
+`.azeroth` imports from `.ts`/`.tsx` files with their REAL exported types -
+default, named, and type exports. It is the AzerothJS counterpart to
+`@vue/typescript-plugin`.
+
+With the plugin installed a consuming app can delete its hand-written
+`declare module '*.azeroth'` shims: a barrel like
+
+```ts
+export { default as Breadcrumb } from './breadcrumb.component.azeroth';
+export type { BreadcrumbCrumb } from './breadcrumb.component.azeroth';
+```
+
+type-checks against the component's actual signature instead of `any`.
+
+## Install
+
+```sh
+npm i -D @azerothjs/typescript-plugin
+```
+
+Register it in the consuming project's `tsconfig.json`:
+
+```json
+{
+    "compilerOptions": {
+        "plugins": [{ "name": "@azerothjs/typescript-plugin" }]
+    }
+}
+```
+
+In VS Code, also select **"Use Workspace Version"** of TypeScript (or rely on
+the AzerothJS VS Code extension, which contributes the plugin automatically), so
+the editor's TypeScript server loads the plugin.
+
+## How it works
+
+The plugin reuses the same virtual-code pipeline as the editor language server
+(`@azerothjs/language-service`): a `.azeroth` file is compiled to a virtual
+TypeScript module whose markup is rewritten to `h()` calls and whose surrounding
+code - every `export` included - is preserved verbatim. The plugin decorates the
+host so that:
+
+- an `import './x.azeroth'` specifier resolves to a synthetic `x.azeroth.ts`;
+- loading that synthetic file returns the compiled virtual module.
+
+Because the virtual module carries the file's real exported declarations,
+TypeScript infers real types across the `.ts` -> `.azeroth` boundary.
+
+## Scope: editors, not `tsc`
+
+TypeScript language-service plugins run **only inside `tsserver`** (editors), not
+inside the command-line `tsc`. This is a TypeScript limitation, not a choice
+here - it is also why `vue-tsc` exists. So:
+
+- In the editor, this plugin gives real `.azeroth` types with no shim.
+- For a command-line type-check gate over `.azeroth` files, use `azeroth-tsc`
+  (from `@azerothjs/language-server`).
+
+A single combined `.ts` + `.azeroth` command-line checker (the `vue-tsc`
+equivalent) is tracked as a follow-up.
+
+## Building
+
+```sh
+npm run build -w @azerothjs/typescript-plugin
+```
+
+`tsserver` loads plugins with `require()`, so the entry must be CommonJS; the
+AzerothJS packages it reuses are ESM. `esbuild` bundles `src/index.ts` and those
+ESM dependencies into a single self-contained `dist/index.js` (with `typescript`
+left external - `tsserver` passes its own copy to the plugin factory).
+
+## Testing
+
+```sh
+npx vitest run test/typescript-plugin
+```
+
+The test drives the plugin's host decoration through a constructed
+`ts.LanguageService` (what `tsserver` builds) over a fixture with no `.azeroth`
+shim, asserting default/named/type imports resolve and that a genuine type error
+still surfaces.

package/dist/index.js

@@ -0,0 +1,1132 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/decorate.ts
+var import_node_path = __toESM(require("node:path"));
+
+// ../language-service/src/ts-project.ts
+var import_typescript = __toESM(require("typescript"), 1);
+
+// ../compiler/src/scanner.ts
+function isWhitespace(ch) {
+  return ch === " " || ch === "	" || ch === "\n" || ch === "\r" || ch === "\f" || ch === "\v";
+}
+function isIdentStart(ch) {
+  return ch >= "a" && ch <= "z" || ch >= "A" && ch <= "Z" || ch === "_" || ch === "$";
+}
+function isIdentPart(ch) {
+  return isIdentStart(ch) || ch >= "0" && ch <= "9";
+}
+function skipLineComment(src, i) {
+  i += 2;
+  while (i < src.length && src[i] !== "\n") {
+    i++;
+  }
+  return i;
+}
+function skipBlockComment(src, i) {
+  i += 2;
+  while (i < src.length && !(src[i] === "*" && src[i + 1] === "/")) {
+    i++;
+  }
+  return Math.min(i + 2, src.length);
+}
+function skipString(src, i) {
+  const quote = src[i];
+  i++;
+  while (i < src.length) {
+    const ch = src[i];
+    if (ch === "\\") {
+      i += 2;
+      continue;
+    }
+    if (ch === quote) {
+      return i + 1;
+    }
+    i++;
+  }
+  return i;
+}
+function skipTemplate(src, i) {
+  i++;
+  while (i < src.length) {
+    const ch = src[i];
+    if (ch === "\\") {
+      i += 2;
+      continue;
+    }
+    if (ch === "`") {
+      return i + 1;
+    }
+    if (ch === "$" && src[i + 1] === "{") {
+      i = skipBalanced(src, i + 1);
+      continue;
+    }
+    i++;
+  }
+  return i;
+}
+function skipRegex(src, i) {
+  i++;
+  let inClass = false;
+  while (i < src.length) {
+    const ch = src[i];
+    if (ch === "\\") {
+      i += 2;
+      continue;
+    }
+    if (ch === "[") {
+      inClass = true;
+    } else if (ch === "]") {
+      inClass = false;
+    } else if (ch === "/" && !inClass) {
+      i++;
+      break;
+    } else if (ch === "\n") {
+      break;
+    }
+    i++;
+  }
+  while (i < src.length && isIdentPart(src[i])) {
+    i++;
+  }
+  return i;
+}
+function skipBalanced(src, openIndex) {
+  const open = src[openIndex];
+  const close = open === "(" ? ")" : open === "[" ? "]" : "}";
+  let depth = 0;
+  let i = openIndex;
+  while (i < src.length) {
+    const ch = src[i];
+    if (ch === "/" && src[i + 1] === "/") {
+      i = skipLineComment(src, i);
+      continue;
+    }
+    if (ch === "/" && src[i + 1] === "*") {
+      i = skipBlockComment(src, i);
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      i = skipString(src, i);
+      continue;
+    }
+    if (ch === "`") {
+      i = skipTemplate(src, i);
+      continue;
+    }
+    if (ch === open) {
+      depth++;
+      i++;
+      continue;
+    }
+    if (ch === close) {
+      depth--;
+      i++;
+      if (depth === 0) {
+        return i;
+      }
+      continue;
+    }
+    i++;
+  }
+  return i;
+}
+var EXPR_KEYWORDS = /* @__PURE__ */ new Set([
+  "return",
+  "typeof",
+  "instanceof",
+  "in",
+  "of",
+  "do",
+  "else",
+  "yield",
+  "await",
+  "case",
+  "delete",
+  "void",
+  "new"
+]);
+var EXPR_CHARS = /* @__PURE__ */ new Set([
+  "",
+  "(",
+  "{",
+  "[",
+  ",",
+  ";",
+  ":",
+  "?",
+  "=",
+  ">",
+  "<",
+  "&",
+  "|",
+  "!",
+  "~",
+  "+",
+  "-",
+  "*",
+  "/",
+  "%",
+  "^",
+  "\n"
+]);
+function isExpressionPosition(prevChar, prevWord) {
+  if (prevWord !== "") {
+    return EXPR_KEYWORDS.has(prevWord);
+  }
+  return EXPR_CHARS.has(prevChar);
+}
+function scanTypeParams(src, openIndex) {
+  let depth = 0;
+  let i = openIndex;
+  while (i < src.length) {
+    const ch = src[i];
+    if (ch === "/" && src[i + 1] === "/") {
+      i = skipLineComment(src, i);
+      continue;
+    }
+    if (ch === "/" && src[i + 1] === "*") {
+      i = skipBlockComment(src, i);
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      i = skipString(src, i);
+      continue;
+    }
+    if (ch === "`") {
+      i = skipTemplate(src, i);
+      continue;
+    }
+    if (ch === "(" || ch === "[" || ch === "{") {
+      i = skipBalanced(src, i);
+      continue;
+    }
+    if (ch === "=" && src[i + 1] === ">") {
+      i += 2;
+      continue;
+    }
+    if (ch === "<") {
+      depth++;
+      i++;
+      continue;
+    }
+    if (ch === ">") {
+      depth--;
+      i++;
+      if (depth === 0) {
+        return i;
+      }
+      continue;
+    }
+    i++;
+  }
+  return -1;
+}
+function tryGenericArrow(src, i) {
+  const afterAngles = scanTypeParams(src, i);
+  if (afterAngles === -1) {
+    return -1;
+  }
+  let k = afterAngles;
+  while (k < src.length && isWhitespace(src[k])) {
+    k++;
+  }
+  if (src[k] !== "(") {
+    return -1;
+  }
+  let m = skipBalanced(src, k);
+  while (m < src.length && isWhitespace(src[m])) {
+    m++;
+  }
+  if (src[m] === ":" || src[m] === "=" && src[m + 1] === ">") {
+    return afterAngles;
+  }
+  return -1;
+}
+function findMarkupStart(src, from) {
+  let i = from;
+  let prevChar = "";
+  let prevWord = "";
+  while (i < src.length) {
+    const ch = src[i];
+    if (ch === "/" && src[i + 1] === "/") {
+      i = skipLineComment(src, i);
+      continue;
+    }
+    if (ch === "/" && src[i + 1] === "*") {
+      i = skipBlockComment(src, i);
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      i = skipString(src, i);
+      prevChar = '"';
+      prevWord = "";
+      continue;
+    }
+    if (ch === "`") {
+      i = skipTemplate(src, i);
+      prevChar = "`";
+      prevWord = "";
+      continue;
+    }
+    if (ch === "/" && isExpressionPosition(prevChar, prevWord)) {
+      i = skipRegex(src, i);
+      prevChar = "/";
+      prevWord = "";
+      continue;
+    }
+    if (isWhitespace(ch)) {
+      if (ch === "\n") {
+      }
+      i++;
+      continue;
+    }
+    if (ch === "<") {
+      const next = src[i + 1];
+      if (isExpressionPosition(prevChar, prevWord) && (next === ">" || isIdentStart(next))) {
+        if (next !== ">") {
+          const past = tryGenericArrow(src, i);
+          if (past !== -1) {
+            prevChar = ">";
+            prevWord = "";
+            i = past;
+            continue;
+          }
+        }
+        return i;
+      }
+      prevChar = "<";
+      prevWord = "";
+      i++;
+      continue;
+    }
+    if (isIdentStart(ch)) {
+      let j = i + 1;
+      while (j < src.length && isIdentPart(src[j])) {
+        j++;
+      }
+      prevWord = src.slice(i, j);
+      prevChar = src[j - 1];
+      i = j;
+      continue;
+    }
+    prevChar = ch;
+    prevWord = "";
+    i++;
+  }
+  return -1;
+}
+
+// ../compiler/src/parser.ts
+var CompileError = class extends Error {
+  constructor(message, offset) {
+    super(message);
+    this.offset = offset;
+    this.name = "CompileError";
+  }
+  offset;
+};
+var MarkupParser = class _MarkupParser {
+  constructor(src, pos) {
+    this.src = src;
+    this.pos = pos;
+  }
+  src;
+  pos;
+  /** Entry point; `pos` must be at the opening `<`. */
+  parse() {
+    return this.parseElement();
+  }
+  peek(offset = 0) {
+    return this.src[this.pos + offset] ?? "";
+  }
+  skipWs() {
+    while (this.pos < this.src.length && isWhitespace(this.src[this.pos])) {
+      this.pos++;
+    }
+  }
+  expect(ch) {
+    if (this.peek() !== ch) {
+      throw new CompileError(
+        `Expected '${ch}' but found '${this.peek() || "EOF"}'`,
+        this.pos
+      );
+    }
+    this.pos++;
+  }
+  /** `pos` at `<`. Parses an element or `<>...</>` fragment. */
+  parseElement() {
+    const start = this.pos;
+    this.expect("<");
+    if (this.peek() === ">") {
+      this.pos++;
+      const children2 = this.parseChildren();
+      this.expectClosingTag("");
+      return { kind: "fragment", children: children2, start, end: this.pos };
+    }
+    if (this.peek() !== "/" && !isIdentStart(this.peek())) {
+      throw new CompileError(
+        "Unexpected '<' in markup; write a literal '<' as {'<'} or &lt;",
+        start
+      );
+    }
+    const tag = this.readTagName();
+    const attributes = this.parseAttributes();
+    this.skipWs();
+    if (this.peek() === "/") {
+      this.pos++;
+      this.expect(">");
+      return {
+        kind: "element",
+        tag,
+        isComponent: _MarkupParser.isComponentTag(tag),
+        attributes,
+        children: [],
+        start,
+        end: this.pos
+      };
+    }
+    this.expect(">");
+    const children = this.parseChildren();
+    this.expectClosingTag(tag);
+    return {
+      kind: "element",
+      tag,
+      isComponent: _MarkupParser.isComponentTag(tag),
+      attributes,
+      children,
+      start,
+      end: this.pos
+    };
+  }
+  static isComponentTag(tag) {
+    return /[A-Z]/.test(tag[0] ?? "") || tag.includes(".");
+  }
+  /** Reads a tag name: identifiers plus `.` (`Foo.Bar`) and `-` (custom elements). */
+  readTagName() {
+    const start = this.pos;
+    if (!isIdentStart(this.peek())) {
+      throw new CompileError("Expected a tag name", this.pos);
+    }
+    this.pos++;
+    while (this.pos < this.src.length) {
+      const ch = this.src[this.pos];
+      if (isIdentPart(ch) || ch === "." || ch === "-") {
+        this.pos++;
+      } else {
+        break;
+      }
+    }
+    return this.src.slice(start, this.pos);
+  }
+  parseAttributes() {
+    const attrs = [];
+    for (; ; ) {
+      this.skipWs();
+      const ch = this.peek();
+      if (ch === ">" || ch === "/" || ch === "") {
+        break;
+      }
+      const attrStart = this.pos;
+      if (ch === "{") {
+        const end = skipBalanced(this.src, this.pos);
+        const inner = this.src.slice(this.pos + 1, end - 1).trim();
+        this.pos = end;
+        const code = inner.startsWith("...") ? inner.slice(3).trim() : inner;
+        attrs.push({
+          kind: "attribute",
+          name: null,
+          value: { kind: "expression", code },
+          spread: true,
+          start: attrStart,
+          end
+        });
+        continue;
+      }
+      const name = this.readAttributeName();
+      this.skipWs();
+      if (this.peek() !== "=") {
+        attrs.push({
+          kind: "attribute",
+          name,
+          value: { kind: "none" },
+          spread: false,
+          start: attrStart,
+          end: this.pos
+        });
+        continue;
+      }
+      this.pos++;
+      this.skipWs();
+      const valueChar = this.peek();
+      if (valueChar === "{") {
+        const end = skipBalanced(this.src, this.pos);
+        const code = this.src.slice(this.pos + 1, end - 1).trim();
+        this.pos = end;
+        attrs.push({
+          kind: "attribute",
+          name,
+          value: { kind: "expression", code },
+          spread: false,
+          start: attrStart,
+          end
+        });
+      } else if (valueChar === '"' || valueChar === "'") {
+        const end = skipString(this.src, this.pos);
+        const value = this.src.slice(this.pos + 1, end - 1);
+        this.pos = end;
+        attrs.push({
+          kind: "attribute",
+          name,
+          value: { kind: "static", value },
+          spread: false,
+          start: attrStart,
+          end
+        });
+      } else {
+        throw new CompileError(
+          `Expected a value for attribute '${name}'`,
+          this.pos
+        );
+      }
+    }
+    return attrs;
+  }
+  /** Attribute names: identifiers plus `-` and `:` (`data-x`, `aria-label`). */
+  readAttributeName() {
+    const start = this.pos;
+    while (this.pos < this.src.length) {
+      const ch = this.src[this.pos];
+      if (isIdentPart(ch) || ch === "-" || ch === ":") {
+        this.pos++;
+      } else {
+        break;
+      }
+    }
+    if (this.pos === start) {
+      throw new CompileError("Expected an attribute name", this.pos);
+    }
+    return this.src.slice(start, this.pos);
+  }
+  parseChildren() {
+    const children = [];
+    while (this.pos < this.src.length) {
+      if (this.peek() === "<" && this.peek(1) === "/") {
+        break;
+      }
+      if (this.peek() === "<") {
+        children.push(this.parseElement());
+        continue;
+      }
+      if (this.peek() === "{") {
+        const start = this.pos;
+        const end = skipBalanced(this.src, this.pos);
+        const code = this.src.slice(this.pos + 1, end - 1);
+        this.pos = end;
+        if (!_MarkupParser.isEmptyExpression(code)) {
+          children.push({ kind: "expression", code, start, end });
+        }
+        continue;
+      }
+      const text = this.readText();
+      if (text) {
+        children.push(text);
+      }
+    }
+    return children;
+  }
+  /** Reads raw text up to the next `<` or `{`, normalised JSX-style. */
+  readText() {
+    const start = this.pos;
+    while (this.pos < this.src.length && this.peek() !== "<" && this.peek() !== "{") {
+      this.pos++;
+    }
+    const raw = this.src.slice(start, this.pos);
+    const lead = raw.length - raw.trimStart().length;
+    if (raw.slice(lead).startsWith("//")) {
+      throw new CompileError(
+        "Line comments (//) are not allowed in markup; use {/* ... */} instead",
+        start + lead
+      );
+    }
+    const value = _MarkupParser.normalizeText(raw);
+    if (value === "") {
+      return null;
+    }
+    return { kind: "text", value, start, end: this.pos };
+  }
+  /**
+   * JSX-style whitespace handling: collapse runs that are purely formatting
+   * (whitespace containing a newline) to a single space, and preserve
+   * meaningful same-line spacing like `Count: `.
+   */
+  static normalizeText(raw) {
+    if (/^\s*$/.test(raw)) {
+      return "";
+    }
+    return raw.replace(/\s*\n\s*/g, " ");
+  }
+  /** True when a `{ ... }` hole has no actual expression (only comments/space). */
+  static isEmptyExpression(code) {
+    const stripped = code.replace(/\/\*[\s\S]*?\*\//g, "").replace(/\/\/[^\n]*/g, "").trim();
+    return stripped === "";
+  }
+  /** Consumes `</tag>` (or `</>` when `tag === ''`). */
+  expectClosingTag(tag) {
+    this.expect("<");
+    this.expect("/");
+    this.skipWs();
+    if (tag !== "") {
+      const closing = this.readTagName();
+      if (closing !== tag) {
+        throw new CompileError(
+          `Mismatched closing tag: expected </${tag}> but found </${closing}>`,
+          this.pos
+        );
+      }
+    }
+    this.skipWs();
+    this.expect(">");
+  }
+};
+function parseMarkup(src, start) {
+  const parser = new MarkupParser(src, start);
+  const node = parser.parse();
+  return { node, end: parser.pos };
+}
+
+// ../compiler/src/codegen.ts
+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);
+    }
+  }
+}
+
+// ../language-service/src/mapping.ts
+var CodeMapping = class _CodeMapping {
+  /** Segments sorted by `sourceStart` (for original -> generated). */
+  bySource;
+  /** Segments sorted by `generatedStart` (for generated -> original). */
+  byGenerated;
+  constructor(segments) {
+    this.bySource = [...segments].sort((a, b) => a.sourceStart - b.sourceStart);
+    this.byGenerated = [...segments].sort((a, b) => a.generatedStart - b.generatedStart);
+  }
+  /**
+   * Maps an offset in the original source to the virtual module, or `null`
+   * when it falls in non-mapped generated scaffolding. A position touching a
+   * segment's exclusive end still maps (so a caret right after an identifier
+   * resolves), preferring the segment that actually contains it.
+   */
+  toGenerated(sourceOffset) {
+    const seg = _CodeMapping.find(this.bySource, sourceOffset, (segment) => segment.sourceStart, (segment) => segment.sourceEnd);
+    if (seg === null) {
+      return null;
+    }
+    return seg.generatedStart + (sourceOffset - seg.sourceStart);
+  }
+  /**
+   * Maps an offset in the virtual module back to the original source, or
+   * `null` when it lands in generated scaffolding with no original origin.
+   */
+  toOriginal(generatedOffset) {
+    const seg = _CodeMapping.find(this.byGenerated, generatedOffset, (segment) => segment.generatedStart, (segment) => segment.generatedEnd);
+    if (seg === null) {
+      return null;
+    }
+    return seg.sourceStart + (generatedOffset - seg.generatedStart);
+  }
+  /**
+   * Maps an original `[start, end)` range to the virtual module. Returns
+   * `null` unless both ends land in the *same* segment, which guarantees the
+   * translated range is contiguous and meaningful (e.g. a rename edit).
+   */
+  toGeneratedRange(sourceStart, sourceEnd) {
+    const seg = _CodeMapping.find(this.bySource, sourceStart, (segment) => segment.sourceStart, (segment) => segment.sourceEnd);
+    if (seg === null || sourceEnd > seg.sourceEnd) {
+      return null;
+    }
+    return {
+      start: seg.generatedStart + (sourceStart - seg.sourceStart),
+      end: seg.generatedStart + (sourceEnd - seg.sourceStart)
+    };
+  }
+  /**
+   * Maps a virtual `[start, end)` range back to the original source. Both
+   * ends must share a segment; otherwise the range straddles generated
+   * scaffolding and has no faithful original counterpart.
+   */
+  toOriginalRange(generatedStart, generatedEnd) {
+    const seg = _CodeMapping.find(this.byGenerated, generatedStart, (segment) => segment.generatedStart, (segment) => segment.generatedEnd);
+    if (seg === null || generatedEnd > seg.generatedEnd) {
+      return null;
+    }
+    return {
+      start: seg.sourceStart + (generatedStart - seg.generatedStart),
+      end: seg.sourceStart + (generatedEnd - seg.generatedStart)
+    };
+  }
+  /**
+   * Binary-searches `segments` (sorted by `start`) for the one whose
+   * `[start, end]` span contains `offset`, preferring a span that strictly
+   * contains it over one it only touches at the end.
+   */
+  static find(segments, offset, start, end) {
+    let lo = 0;
+    let hi = segments.length - 1;
+    let touch = null;
+    while (lo <= hi) {
+      const mid = lo + hi >> 1;
+      const seg = segments[mid];
+      if (offset < start(seg)) {
+        hi = mid - 1;
+      } else if (offset > end(seg)) {
+        lo = mid + 1;
+      } else {
+        if (offset < end(seg)) {
+          return seg;
+        }
+        touch = seg;
+        hi = mid - 1;
+      }
+    }
+    return touch;
+  }
+};
+
+// ../language-service/src/virtual-code.ts
+var RUNTIME_MODULE = "@azerothjs/core";
+var BUILTIN_COMPONENTS = [
+  "Show",
+  "For",
+  "Switch",
+  "Match",
+  "Portal",
+  "Dynamic",
+  "Suspense",
+  "ErrorBoundary",
+  "Transition",
+  "Outlet"
+];
+var BUILTIN_SET = new Set(BUILTIN_COMPONENTS);
+var Builder = class {
+  constructor(src) {
+    this.src = src;
+  }
+  src;
+  out = "";
+  segments = [];
+  /** Appends generated scaffolding that has no original counterpart. */
+  emit(text) {
+    this.out += text;
+  }
+  /** Copies `[start, end)` from the source verbatim and records a mapping. */
+  copy(start, end, kind) {
+    if (end <= start) {
+      return;
+    }
+    const generatedStart = this.out.length;
+    this.out += this.src.slice(start, end);
+    this.segments.push({
+      sourceStart: start,
+      sourceEnd: end,
+      generatedStart,
+      generatedEnd: this.out.length,
+      kind
+    });
+  }
+};
+function generateVirtualCode(source) {
+  const builder = new Builder(source);
+  const usedBuiltins = /* @__PURE__ */ new Set();
+  const collect = (node) => walkComponentTags(node, (tag) => {
+    if (BUILTIN_SET.has(tag)) {
+      usedBuiltins.add(tag);
+    }
+  });
+  const emitExpression = (start, end, kind) => {
+    let j = start;
+    for (; ; ) {
+      const m = findMarkupStart(source, j);
+      if (m === -1 || m >= end) {
+        builder.copy(j, end, kind);
+        break;
+      }
+      builder.copy(j, m, kind);
+      let parsed;
+      try {
+        parsed = parseMarkup(source, m);
+      } catch {
+        builder.copy(m, end, kind);
+        break;
+      }
+      collect(parsed.node);
+      emitNode(parsed.node);
+      j = parsed.end;
+    }
+  };
+  const emitDynamic = (span, isEventHandler, kind) => {
+    const code = source.slice(span.start, span.end).trim();
+    if (isEventHandler || isFunctionLiteral(code) || isBareReference(code) || isCollectionLiteral(code)) {
+      emitExpression(span.start, span.end, kind);
+      return;
+    }
+    builder.emit("() => (");
+    emitExpression(span.start, span.end, kind);
+    builder.emit(")");
+  };
+  const emitAttribute = (attr, isHost) => {
+    if (attr.spread) {
+      builder.emit("...");
+      emitExpression(spreadSpan(source, attr).start, spreadSpan(source, attr).end, "attribute");
+      return;
+    }
+    const name = attr.name;
+    builder.emit(`${objectKey(name)}: `);
+    if (attr.value.kind === "none") {
+      builder.emit("true");
+      return;
+    }
+    if (attr.value.kind === "static") {
+      builder.emit(quoteString(attr.value.value));
+      return;
+    }
+    const span = attrExprSpan(source, attr);
+    if (isHost && isEventName(name) && isFunctionLiteral(source.slice(span.start, span.end).trim())) {
+      builder.emit("(");
+      emitExpression(span.start, span.end, "attribute");
+      builder.emit(`) satisfies AzerothHandler<'${name}'>`);
+      return;
+    }
+    emitDynamic(span, isEventName(name), "attribute");
+  };
+  const emitProps = (attrs, childrenEntry, isHost) => {
+    builder.emit("{ ");
+    attrs.forEach((attr, index) => {
+      if (index > 0) {
+        builder.emit(", ");
+      }
+      emitAttribute(attr, isHost);
+    });
+    if (childrenEntry) {
+      if (attrs.length > 0) {
+        builder.emit(", ");
+      }
+      childrenEntry();
+    }
+    builder.emit(" }");
+  };
+  const emitChild = (child) => {
+    if (child.kind === "text") {
+      builder.emit(quoteString(child.value));
+      return;
+    }
+    if (child.kind === "expression") {
+      emitDynamic({ start: child.start + 1, end: child.end - 1 }, false, "expression");
+      return;
+    }
+    emitNode(child);
+  };
+  const emitComponentChildren = (children) => {
+    if (children.length === 0) {
+      return null;
+    }
+    return () => {
+      builder.emit("children: ");
+      if (children.length === 1) {
+        const only = children[0];
+        if (only.kind === "expression") {
+          const span = { start: only.start + 1, end: only.end - 1 };
+          const code = source.slice(span.start, span.end).trim();
+          if (isFunctionLiteral(code)) {
+            emitExpression(span.start, span.end, "expression");
+          } else {
+            builder.emit("() => (");
+            emitExpression(span.start, span.end, "expression");
+            builder.emit(")");
+          }
+          return;
+        }
+        builder.emit("() => ");
+        emitChild(only);
+        return;
+      }
+      builder.emit("() => [");
+      children.forEach((child, index) => {
+        if (index > 0) {
+          builder.emit(", ");
+        }
+        emitChild(child);
+      });
+      builder.emit("]");
+    };
+  };
+  function emitNode(node) {
+    if (node.kind === "fragment") {
+      builder.emit("[");
+      node.children.forEach((child, index) => {
+        if (index > 0) {
+          builder.emit(", ");
+        }
+        emitChild(child);
+      });
+      builder.emit("]");
+      return;
+    }
+    if (node.isComponent) {
+      const tagStart = node.start + 1;
+      builder.copy(tagStart, tagStart + node.tag.length, "tag");
+      builder.emit("(");
+      emitProps(node.attributes, emitComponentChildren(node.children), false);
+      builder.emit(")");
+      return;
+    }
+    builder.emit(`h(${quoteString(node.tag)}, `);
+    emitProps(node.attributes, null, true);
+    for (const child of node.children) {
+      builder.emit(", ");
+      emitChild(child);
+    }
+    builder.emit(")");
+  }
+  let i = 0;
+  for (; ; ) {
+    const start = findMarkupStart(source, i);
+    if (start === -1) {
+      builder.copy(i, source.length, "script");
+      break;
+    }
+    builder.copy(i, start, "script");
+    let parsed;
+    try {
+      parsed = parseMarkup(source, start);
+    } catch {
+      builder.copy(start, source.length, "script");
+      break;
+    }
+    collect(parsed.node);
+    emitNode(parsed.node);
+    i = parsed.end;
+  }
+  return finalize(builder, source, usedBuiltins);
+}
+function finalize(builder, source, usedBuiltins) {
+  const hasMarkup = builder.segments.some((segment) => segment.kind !== "script") || builder.out !== source;
+  if (!hasMarkup) {
+    return { code: builder.out, mapping: new CodeMapping(builder.segments) };
+  }
+  const names = ["h", ...usedBuiltins].filter((name) => !alreadyImports(source, name));
+  const prefix = names.length > 0 ? `import { ${names.join(", ")} } from '${RUNTIME_MODULE}';
+` : "";
+  const shift = prefix.length;
+  const segments = builder.segments.map((segment) => ({
+    ...segment,
+    generatedStart: segment.generatedStart + shift,
+    generatedEnd: segment.generatedEnd + shift
+  }));
+  return { code: prefix + builder.out, mapping: new CodeMapping(segments) };
+}
+function alreadyImports(source, name) {
+  return new RegExp(`import\\s*\\{[^}]*\\b${name}\\b[^}]*\\}\\s*from`).test(source);
+}
+function attrExprSpan(source, attr) {
+  const open = source.indexOf("{", attr.start);
+  return trimSpan(source, open + 1, attr.end - 1);
+}
+function spreadSpan(source, attr) {
+  const open = source.indexOf("{", attr.start);
+  const close = skipBalanced(source, open);
+  const inner = trimSpan(source, open + 1, close - 1);
+  if (source.startsWith("...", inner.start)) {
+    return trimSpan(source, inner.start + 3, inner.end);
+  }
+  return inner;
+}
+function trimSpan(source, start, end) {
+  let s = start;
+  let e = end;
+  while (s < e && isWhitespace(source[s])) {
+    s++;
+  }
+  while (e > s && isWhitespace(source[e - 1])) {
+    e--;
+  }
+  return { start: s, end: e };
+}
+function isFunctionLiteral(code) {
+  const t = code.trim();
+  if (/^async\s+function\b/.test(t) || /^function\b/.test(t)) {
+    return true;
+  }
+  return /^(async\s+)?(\([^]*?\)|[A-Za-z_$][\w$]*)\s*=>/.test(t);
+}
+function isBareReference(code) {
+  return /^[A-Za-z_$][\w$]*(\s*\.\s*[A-Za-z_$][\w$]*)*$/.test(code.trim());
+}
+function isCollectionLiteral(code) {
+  const t = code.trim();
+  return t.startsWith("[") || t.startsWith("{");
+}
+function isEventName(name) {
+  return name.length > 2 && name.startsWith("on") && name[2] === name[2].toUpperCase();
+}
+function objectKey(name) {
+  return /^[A-Za-z_$][\w$]*$/.test(name) ? name : `'${name}'`;
+}
+function quoteString(value) {
+  return `'${value.replace(/\\/g, "\\\\").replace(/'/g, "\\'").replace(/\n/g, "\\n")}'`;
+}
+
+// ../language-service/src/ts-project.ts
+var VIRTUAL_SUFFIX = ".azeroth.ts";
+function isVirtualFile(fileName) {
+  return fileName.endsWith(VIRTUAL_SUFFIX);
+}
+function toVirtualFile(azerothPath) {
+  return `${azerothPath}.ts`;
+}
+function toAzerothPath(virtualFile) {
+  return virtualFile.slice(0, -3);
+}
+
+// src/decorate.ts
+var AZEROTH_EXT = ".azeroth";
+function isAzerothSpecifier(text) {
+  return text.endsWith(AZEROTH_EXT) && (text.startsWith(".") || text.startsWith("/"));
+}
+function scriptKindFromName(ts2, fileName) {
+  if (fileName.endsWith(".tsx")) {
+    return ts2.ScriptKind.TSX;
+  }
+  if (fileName.endsWith(".jsx")) {
+    return ts2.ScriptKind.JSX;
+  }
+  if (fileName.endsWith(".json")) {
+    return ts2.ScriptKind.JSON;
+  }
+  if (/\.(?:m|c)?js$/.test(fileName)) {
+    return ts2.ScriptKind.JS;
+  }
+  return ts2.ScriptKind.TS;
+}
+function resolveSibling(containingFile, specifier) {
+  return import_node_path.default.resolve(import_node_path.default.dirname(containingFile), specifier).replace(/\\/g, "/");
+}
+function decorateLanguageServiceHost(ts2, host, options = {}) {
+  const read = options.readAzeroth ?? ((azerothPath) => ts2.sys.readFile(azerothPath));
+  const cache = /* @__PURE__ */ new Map();
+  const virtualCodeFor = (azerothPath) => {
+    const source = read(azerothPath);
+    if (source === void 0) {
+      return void 0;
+    }
+    const cached = cache.get(azerothPath);
+    if (cached && cached.source === source) {
+      return cached.code;
+    }
+    const code = generateVirtualCode(source).code;
+    cache.set(azerothPath, { source, code });
+    return code;
+  };
+  const origSnapshot = host.getScriptSnapshot?.bind(host);
+  host.getScriptSnapshot = (fileName) => {
+    if (isVirtualFile(fileName)) {
+      const code = virtualCodeFor(toAzerothPath(fileName));
+      return code === void 0 ? void 0 : ts2.ScriptSnapshot.fromString(code);
+    }
+    return origSnapshot ? origSnapshot(fileName) : void 0;
+  };
+  const origKind = host.getScriptKind?.bind(host);
+  host.getScriptKind = (fileName) => {
+    if (isVirtualFile(fileName)) {
+      return ts2.ScriptKind.TS;
+    }
+    return origKind ? origKind(fileName) : scriptKindFromName(ts2, fileName);
+  };
+  const origVersion = host.getScriptVersion.bind(host);
+  host.getScriptVersion = (fileName) => {
+    if (isVirtualFile(fileName)) {
+      const azerothPath = toAzerothPath(fileName);
+      const mtime = ts2.sys.getModifiedTime?.(azerothPath)?.getTime() ?? 0;
+      return `azeroth:${mtime}`;
+    }
+    return origVersion(fileName);
+  };
+  const origExists = host.fileExists?.bind(host);
+  host.fileExists = (fileName) => {
+    if (isVirtualFile(fileName)) {
+      return read(toAzerothPath(fileName)) !== void 0;
+    }
+    return origExists ? origExists(fileName) : ts2.sys.fileExists(fileName);
+  };
+  const origReadFile = host.readFile?.bind(host);
+  host.readFile = (fileName, encoding) => {
+    if (isVirtualFile(fileName)) {
+      return virtualCodeFor(toAzerothPath(fileName));
+    }
+    return origReadFile ? origReadFile(fileName, encoding) : ts2.sys.readFile(fileName, encoding);
+  };
+  const origResolve = host.resolveModuleNameLiterals?.bind(host);
+  host.resolveModuleNameLiterals = (literals, containingFile, redirectedReference, compilerOptions, containingSourceFile, reusedNames) => {
+    const base = origResolve ? origResolve(literals, containingFile, redirectedReference, compilerOptions, containingSourceFile, reusedNames) : literals.map((literal) => ts2.resolveModuleName(literal.text, containingFile, compilerOptions, host));
+    return literals.map((literal, index) => {
+      if (isAzerothSpecifier(literal.text)) {
+        const azerothPath = resolveSibling(containingFile, literal.text);
+        if (read(azerothPath) !== void 0) {
+          return {
+            resolvedModule: {
+              resolvedFileName: toVirtualFile(azerothPath),
+              extension: ts2.Extension.Ts,
+              isExternalLibraryImport: false
+            },
+            failedLookupLocations: []
+          };
+        }
+      }
+      return base[index];
+    });
+  };
+}
+
+// src/index.ts
+function init(modules) {
+  const ts2 = modules.typescript;
+  return {
+    create(info) {
+      decorateLanguageServiceHost(ts2, info.languageServiceHost);
+      info.project.projectService.logger.info("[azerothjs] typescript-plugin: .azeroth module resolution enabled");
+      return info.languageService;
+    },
+    getExternalFiles(project) {
+      return project.getFileNames().filter((fileName) => fileName.endsWith(".azeroth"));
+    }
+  };
+}
+module.exports = init;

package/package.json

@@ -0,0 +1,54 @@
+{
+    "name": "@azerothjs/typescript-plugin",
+    "version": "0.4.0-beta.3",
+    "description": "AzerothJS TypeScript language-service plugin — resolves .azeroth imports with real types in tsserver/editors",
+    "main": "./dist/index.js",
+    "files":
+    [
+        "dist"
+    ],
+    "scripts":
+    {
+        "build": "node esbuild.mjs",
+        "prepublishOnly": "npm run build"
+    },
+    "keywords":
+    [
+        "azeroth",
+        "typescript",
+        "typescript-plugin",
+        "tsserver",
+        "language-service"
+    ],
+    "devDependencies":
+    {
+        "@azerothjs/language-service": "0.4.0-beta.3",
+        "esbuild": "^0.28.0"
+    },
+    "peerDependencies":
+    {
+        "typescript": ">=5"
+    },
+    "publishConfig":
+    {
+        "access": "public"
+    },
+    "author":
+    {
+        "name": "IntelligentQuantum",
+        "email": "IntelligentQuantum@Gmail.Com",
+        "url": "https://IntelligentQuantum.Dev/"
+    },
+    "license": "MIT",
+    "repository":
+    {
+        "type": "git",
+        "url": "git+https://github.com/IntelligentQuantum-Dev/AzerothJS.git",
+        "directory": "packages/typescript-plugin"
+    },
+    "homepage": "https://github.com/IntelligentQuantum-Dev/AzerothJS/tree/main/packages/typescript-plugin",
+    "bugs":
+    {
+        "url": "https://github.com/IntelligentQuantum-Dev/AzerothJS/issues"
+    }
+}