@azerothjs/language-service 0.4.0-beta.1

package/README.md

@@ -0,0 +1,259 @@
+# @azerothjs/language-service
+
+## Overview
+
+Compiler-aware language intelligence for `.azeroth` files, packaged so it can be
+driven by any editor frontend. The bundled LSP server
+(`@azerothjs/language-server`) is a thin adapter over this package; the test
+suite and any other host use it directly.
+
+```ts
+import { AzerothLanguageService } from '@azerothjs/language-service';
+
+const ls = new AzerothLanguageService(process.cwd());
+ls.didOpen('file:///App.azeroth', 'export default () => <h1>Hi {name()}</h1>;');
+ls.getHover('file:///App.azeroth', { line: 0, character: 32 }); // the type of name()
+```
+
+The package depends only on `typescript` and `@azerothjs/compiler`, so it runs
+(and is unit-tested) without an editor in the loop.
+
+## Architecture
+
+A `.azeroth` file is a TypeScript module whose markup regions are written in a
+JSX-style syntax. The AzerothJS compiler has no separate type system, symbol
+table, or semantic analyzer: it locates markup regions and rewrites them into
+`h(...)` calls, leaving everything else byte-for-byte. The authoritative
+semantic engine for the language is therefore TypeScript itself.
+
+That observation drives the whole design. Rather than re-implement type
+inference, scope resolution, or symbol tables, the service:
+
+1. Reuses the compiler (`scanner`, `parser`, AST, `walkComponentTags`) to locate
+   and understand markup.
+2. Compiles each `.azeroth` file to a virtual TypeScript module that matches
+   what the compiler ships, while recording a precise, bidirectional offset map
+   for every user-authored span.
+3. Runs a single `ts.LanguageService` over those virtual modules. Every
+   type-aware feature (inference, completion, hover, definitions, references,
+   rename, signatures, diagnostics) comes from the TypeScript compiler.
+4. Layers a markup model on top for the things TypeScript cannot know about:
+   HTML tags, attribute and event names, and built-in components.
+
+The dependency direction is one way. The facade (`service.ts`) owns the four
+foundational modules; the providers build on all of them:
+
+```
+service.ts (facade)
+  markup-model.ts    classify the caret; reuses scanner + parser
+  virtual-code.ts    .azeroth to virtual TS + CodeMapping; reuses scanner + parser
+  ts-project.ts      ts.LanguageService host over virtual files; cross-file resolve
+  language-data.ts   HTML/event vocabulary + built-in component data
+
+  providers/         one focused module per feature, built on the four above:
+    completion, hover, navigation, symbols, diagnostics, signature,
+    semantic-tokens, structure (folding/code-actions/format), editing,
+    inlay-hints, html-service, css-service
+```
+
+### Virtual code and offset mapping
+
+This is the keystone of the package. `<h1>Count: {count()}</h1>` compiles to
+`h('h1', {  }, 'Count: ', () => (count()))`. `virtual-code.ts` walks the same
+parser AST the compiler uses, emitting the same `h()` and component calls. Every
+user-authored slice (the script between markup, expression-hole bodies,
+attribute expressions, and component tag names) is copied byte-for-byte and
+registered as a `MappingSegment`. Generated scaffolding (`h('h1', {`, quotes,
+getters) is emitted but not mapped.
+
+Because those copied spans are equal length, an offset inside one translates by
+a simple additive shift. `CodeMapping` (`mapping.ts`) stores the segments sorted
+both ways and binary-searches them, so:
+
+- a request at an original offset is translated with `toGenerated`, then asked
+  of TypeScript;
+- each `TextSpan` TypeScript returns is translated back with `toOriginal` into
+  an editor range.
+
+The markup-bearing portion of a real `.azeroth` file is small relative to the
+surrounding TypeScript, so the majority of every file is copied 1:1. That is why
+the TypeScript-powered features behave consistently across the whole document.
+
+If the markup fails to parse mid-edit, `generateVirtualCode` copies the
+remainder verbatim instead of throwing, so completion and hover keep working
+while the user is still typing.
+
+### Where intelligence comes from
+
+There is no second language implementation. Intelligence is split along the seam
+the compiler already defines:
+
+- Everything that is TypeScript (variables, functions, classes, generics, types,
+  imports, scopes, visibility, the runtime API, and type inference) is answered
+  by the `ts.LanguageService` in `ts-project.ts`, queried at mapped offsets. The
+  runtime packages ship `.d.ts` and JSDoc, so this stays in sync with the
+  framework.
+- Host-element HTML (valid tags, attributes, attribute values, and MDN
+  documentation) is answered by `vscode-html-languageservice`, the same engine
+  VS Code's HTML support uses, applied to an embedded HTML view of the markup
+  (`html-source.ts` and `providers/html-service.ts`).
+- Inline `style="..."` values are answered by `vscode-css-languageservice`
+  (`providers/css-service.ts`).
+- Framework markup (the built-in components, their props, and the camelCase
+  `on*` events AzerothJS binds) is the AzerothJS layer, from `language-data.ts`
+  (transcribed from the runtime's own prop interfaces) and the TypeScript bridge
+  (for user components).
+- `markup-model.ts`, built on the compiler's parser, decides which of these
+  applies at the caret.
+
+`AzerothProject` presents each `Foo.azeroth` to TypeScript as a synthetic
+`Foo.azeroth.ts` whose contents are the virtual module. It resolves
+`import './Bar.azeroth'` to `Bar.azeroth.ts` (its virtual twin) so types and
+definitions flow across `.azeroth` files, reads every real file from disk, and
+honours the nearest `tsconfig.json` (including its `paths`), forcing only the
+options the virtual modules require.
+
+## Components
+
+| File | Role |
+| --- | --- |
+| `service.ts` | The `AzerothLanguageService` facade; one instance per workspace. |
+| `virtual-code.ts` | Compiles `.azeroth` to virtual TS with a `CodeMapping`. Reuses the compiler. |
+| `mapping.ts` | `CodeMapping`: binary-searched bidirectional offset translation. |
+| `markup-model.ts` | Caret classification and markup-node collection (reuses scanner/parser). |
+| `ts-project.ts` | `AzerothProject`: the `ts.LanguageService` host over virtual files. |
+| `language-data.ts` | HTML/event vocabulary and built-in component data. |
+| `html-source.ts` | Builds the embedded HTML view (non-markup blanked to spaces). |
+| `request.ts` | Per-request context plus offset/range translation helpers. |
+| `text.ts` | `LineIndex`: line/column to offset conversion. |
+| `uri.ts` | URI to filesystem path conversion. |
+| `protocol.ts` | LSP-shaped result types, kept independent of the server package. |
+| `providers/*.ts` | One focused module per editor feature. |
+
+The public API is the `AzerothLanguageService` facade. Its lifecycle methods are
+`didOpen`, `didChange`, and `didClose`; the rest are query methods named after
+the LSP request they serve (`getCompletions`, `resolveCompletion`, `getHover`,
+`getDefinition`, `getReferences`, `getRenameEdits`, `getDocumentSymbols`,
+`getDiagnostics`, `getSemanticTokens`, `getCodeActions`, and so on). Result types
+already mirror the LSP shapes, so the server adapter is close to a passthrough.
+
+### Completion (`providers/completion.ts`)
+
+Completion is context-first. `classifyPosition` (resilient to half-typed input)
+decides which vocabulary applies:
+
+| Caret context | Suggestions |
+| --- | --- |
+| Tag name (`<di`, `<Cou`) | HTML elements (with MDN docs) plus built-in components plus in-scope, non-ambient PascalCase identifiers (user components, via TypeScript). |
+| Attribute name (`<button cla`) | Host element: HTML attributes plus camelCase DOM events. Component: its documented props and events. |
+| Attribute value (`<input type="`) | Host element: HTML value enums and booleans from the HTML engine. Inline `style`: CSS property/value completion. |
+| Expression / script / text | Full type-aware TypeScript completion at the mapped offset, plus tag suggestions immediately after a `<`. |
+
+User-component candidates come from TypeScript completion entries filtered to
+PascalCase values that are not `declare`d ambients, so `<Cou` offers the imported
+`Counter` rather than the thousands of global DOM and JS types. TypeScript-sourced
+items carry a `data` payload so `resolveCompletion` can fetch detail and JSDoc
+lazily, and may attach an auto-import edit through `additionalTextEdits`. Snippet
+completions (for example `when={$0}`) are emitted for component props and events.
+Ranking is via `sortText`.
+
+### Hover (`providers/hover.ts`)
+
+For any mapped position (the script, an expression hole, an attribute expression,
+or a component tag name) hover is TypeScript's quick-info: signature plus JSDoc,
+rendered as Markdown. Host-element markup uses the HTML language service's
+MDN-backed hover, with a fallback table for common form attributes the standard
+HTML dataset ships without descriptions. Built-in components show their framework
+documentation. Context is decided before the offset map is consulted, so a host
+tag never shows a stray TypeScript result mid-edit.
+
+### Navigation and symbols (`providers/navigation.ts`, `providers/symbols.ts`)
+
+Definition, type-definition, references, and rename are TypeScript queries at the
+mapped offset. Results are document spans that may live in this file or another
+(`.azeroth` or `.ts`); `resolveLocation` maps a virtual-file span back through
+that file's `CodeMapping` and reports the `.azeroth` URI, while real files report
+directly. A declaration that contains markup straddles generated scaffolding, so
+its full span is not one contiguous mapping; document symbols map the two
+endpoints (which sit in verbatim script) independently to recover the source
+range. Workspace symbols use TypeScript's `getNavigateToItems`.
+
+### Diagnostics (`providers/diagnostics.ts`)
+
+Two sources, prioritised. First, markup parse errors: the compiler's own
+`parseMarkup` is run over each region and a `CompileError` is reported at its
+exact offset with `source: 'azeroth'`. A hard markup error means the virtual
+module is incomplete, so TypeScript diagnostics would be noise and are suppressed
+until the markup parses. Second, TypeScript syntactic and semantic diagnostics
+over the virtual module, mapped back to original ranges; diagnostics that land
+purely in generated scaffolding are dropped, so what surfaces are genuine errors
+in the user's expressions and script (`source: 'azeroth-ts'`).
+
+### Structure (`providers/structure.ts`)
+
+Quick fixes reuse TypeScript's `getCodeFixesAtPosition` for the diagnostics at a
+range, with the resulting edits mapped back to the source. Formatting runs
+TypeScript's formatter over the virtual module and keeps only the edits that fall
+inside mapped (user-authored) spans, tidying the script and expressions without
+disturbing the markup. This module also provides folding ranges, on-type
+formatting, and selection ranges.
+
+## Development
+
+The source is TypeScript with ESM `.ts`-extension imports, 4-space indentation,
+and Allman braces, matching the rest of the monorepo. Each module carries a
+header comment describing its responsibility, and exported symbols carry JSDoc.
+
+A good reading order follows the runtime pipeline: `virtual-code.ts` and
+`mapping.ts`, then `ts-project.ts`, then `markup-model.ts`, then the providers,
+then `service.ts`.
+
+## Building
+
+```sh
+npm run build -w @azerothjs/language-service
+```
+
+This runs `tsc -p tsconfig.build.json` and emits `dist/`. The build depends on
+`@azerothjs/compiler` being built first; the repository root `npm run build`
+builds the packages in dependency order.
+
+## Testing
+
+Tests live under `test/language-service/` at the repository root and run with
+Vitest:
+
+```sh
+npm test                       # whole repository
+npx vitest run test/language-service
+```
+
+`language-service.test.ts` exercises the public facade end to end (completion,
+hover, diagnostics, navigation) and `virtual-code.test.ts` checks the
+compilation and offset mapping directly. Because the package needs no editor, the
+tests construct an `AzerothLanguageService` over a temporary workspace and assert
+on its results.
+
+## Configuration
+
+The service reads the nearest `tsconfig.json` for each file (including `paths`)
+and forces only the options the virtual modules require (TypeScript source,
+bundler-style module resolution). Per-feature toggles are passed in by the caller
+through `CompletionOptions` and `InlayHintOptions`; the server maps editor
+settings onto these.
+
+## Examples
+
+`packages/compiler/examples/Showcase.azeroth` is a single comprehensive file
+(both a function component and a class component) used to exercise the features
+by hand in an editor.
+
+## Contributing
+
+Keep the seam intact: anything that is really TypeScript should be answered by
+the TypeScript bridge rather than re-implemented, and anything markup-specific
+belongs in `markup-model.ts` or `language-data.ts`. New features generally take
+the shape of a new module under `providers/` plus a method on the facade. Add or
+update tests under `test/language-service/`, and run the build with
+`--noUnusedLocals --noUnusedParameters` (the repository default) before sending a
+change.

package/dist/html-source.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Builds the embedded HTML view of `source`: markup preserved at its original
+ * offsets, everything else turned into whitespace.
+ *
+ * @example
+ * ```ts
+ * generateHtmlSource('const x = <a href="/">hi</a>;');
+ * //                  '          <a href="/">hi</a> '
+ * ```
+ */
+export declare function generateHtmlSource(source: string): string;
+//# sourceMappingURL=html-source.d.ts.map

package/dist/html-source.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"html-source.d.ts","sourceRoot":"","sources":["../src/html-source.ts"],"names":[],"mappings":"AAmBA;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CA2GzD"}

package/dist/html-source.js

@@ -0,0 +1,108 @@
+// Produces a *virtual HTML document* for the markup in a `.azeroth` file, so the
+// HTML language service (the engine behind VS Code's HTML support) can answer
+// tag/attribute/value completion and MDN-backed hover for host elements.
+//
+// The trick that keeps it cheap: the virtual document is the same length as the
+// source, with every non-markup character replaced by a space (newlines kept).
+// So a caret offset in the `.azeroth` file is the *same* offset in the HTML
+// document - no second mapping layer is needed. Markup is copied verbatim;
+// inside `{ ... }` holes and attribute expressions the JavaScript is blanked
+// (its braces kept), except for any markup nested in a hole, which is restored
+// so `{cond && <p class="x"/>}` still gets HTML intelligence on the `<p>`.
+//
+// Reuses the compiler's scanner (findMarkupStart) and parser (parseMarkup); a
+// half-typed tail is copied verbatim so completion keeps working mid-edit.
+import { findMarkupStart } from '@azerothjs/compiler';
+import { parseMarkup } from '@azerothjs/compiler';
+/**
+ * Builds the embedded HTML view of `source`: markup preserved at its original
+ * offsets, everything else turned into whitespace.
+ *
+ * @example
+ * ```ts
+ * generateHtmlSource('const x = <a href="/">hi</a>;');
+ * //                  '          <a href="/">hi</a> '
+ * ```
+ */
+export function generateHtmlSource(source) {
+    const chars = new Array(source.length);
+    for (let k = 0; k < source.length; k++) {
+        const c = source[k];
+        chars[k] = c === '\n' || c === '\r' ? c : ' ';
+    }
+    const copyVerbatim = (a, b) => {
+        for (let k = a; k < b && k < source.length; k++) {
+            const c = source[k];
+            if (c !== '\n' && c !== '\r') {
+                chars[k] = c;
+            }
+        }
+    };
+    const blank = (a, b) => {
+        for (let k = a; k < b && k < source.length; k++) {
+            const c = source[k];
+            if (c !== '\n' && c !== '\r') {
+                chars[k] = ' ';
+            }
+        }
+    };
+    const copyRegions = (lo, hi) => {
+        let i = lo;
+        for (;;) {
+            const s = findMarkupStart(source, i);
+            if (s === -1 || s >= hi) {
+                return;
+            }
+            let node;
+            let end;
+            try {
+                ({ node, end } = parseMarkup(source, s));
+            }
+            catch {
+                // Half-typed tail: copy it so the HTML service still sees the
+                // partial tag and offers completions while the author types.
+                copyVerbatim(s, hi);
+                return;
+            }
+            copyVerbatim(node.start, node.end);
+            blankHoles(node);
+            i = end;
+        }
+    };
+    const blankHoles = (node) => {
+        if (node.kind === 'element') {
+            for (const attr of node.attributes) {
+                const open = source.indexOf('{', attr.start);
+                const close = attr.end - 1;
+                if (open === -1 || close <= open) {
+                    continue;
+                }
+                if (attr.spread) {
+                    // `{...rest}` has no attribute name; drop it entirely so it
+                    // doesn't break the surrounding tag's attribute parsing.
+                    blank(open, close + 1);
+                }
+                else if (attr.value.kind === 'expression') {
+                    // Turn `name={expr}` into `name="   "`: a clean quoted value
+                    // keeps the HTML scanner's attribute boundaries intact, so
+                    // hover/completion still work on neighbouring attributes.
+                    chars[open] = '"';
+                    chars[close] = '"';
+                    blank(open + 1, close);
+                }
+            }
+        }
+        for (const child of node.children) {
+            if (child.kind === 'expression') {
+                blank(child.start + 1, child.end - 1);
+                copyRegions(child.start + 1, child.end - 1);
+            }
+            else if (child.kind === 'element' || child.kind === 'fragment') {
+                blankHoles(child);
+            }
+        }
+    };
+    copyRegions(0, source.length);
+    return chars.join('');
+}
+//# sourceMappingURL=html-source.js.map

package/dist/html-source.js.map

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

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+export { AzerothLanguageService } from './service.ts';
+export type { CompletionOptions } from './providers/completion.ts';
+export type { InlayHintOptions } from './providers/inlay-hints.ts';
+export { AzerothProject, isVirtualFile, toVirtualFile, toAzerothPath } from './ts-project.ts';
+export { generateVirtualCode, BUILTIN_COMPONENTS, type VirtualCode } from './virtual-code.ts';
+export { CodeMapping, type MappingSegment, type MappingKind } from './mapping.ts';
+export { classifyPosition, collectMarkupNodes, type PositionContext } from './markup-model.ts';
+export { BUILTIN_COMPONENT_MAP, DOM_EVENTS, type BuiltinComponent } from './language-data.ts';
+export { LineIndex } from './text.ts';
+export { uriToPath, pathToUri } from './uri.ts';
+export { CompletionItemKind, SymbolKind, DiagnosticSeverity, SEMANTIC_TOKEN_TYPES, type Position, type Range, type Location, type CompletionItem, type Hover, type SignatureHelp, type SignatureInformation, type TextEdit, type WorkspaceEdit, type DocumentSymbol, type DocumentHighlight, type WorkspaceSymbol, type Diagnostic, type FoldingRange, type InlayHint, type SelectionRange, type CodeAction, type SemanticTokens, type SemanticTokenType } from './protocol.ts';
+//# 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":"AAoBA,OAAO,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAC;AACtD,YAAY,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AACnE,YAAY,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAEnE,OAAO,EACH,cAAc,EACd,aAAa,EACb,aAAa,EACb,aAAa,EAChB,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EACH,mBAAmB,EACnB,kBAAkB,EAClB,KAAK,WAAW,EACnB,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EAAE,WAAW,EAAE,KAAK,cAAc,EAAE,KAAK,WAAW,EAAE,MAAM,cAAc,CAAC;AAElF,OAAO,EACH,gBAAgB,EAChB,kBAAkB,EAClB,KAAK,eAAe,EACvB,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EACH,qBAAqB,EACrB,UAAU,EACV,KAAK,gBAAgB,EACxB,MAAM,oBAAoB,CAAC;AAE5B,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AACtC,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAEhD,OAAO,EACH,kBAAkB,EAClB,UAAU,EACV,kBAAkB,EAClB,oBAAoB,EACpB,KAAK,QAAQ,EACb,KAAK,KAAK,EACV,KAAK,QAAQ,EACb,KAAK,cAAc,EACnB,KAAK,KAAK,EACV,KAAK,aAAa,EAClB,KAAK,oBAAoB,EACzB,KAAK,QAAQ,EACb,KAAK,aAAa,EAClB,KAAK,cAAc,EACnB,KAAK,iBAAiB,EACtB,KAAK,eAAe,EACpB,KAAK,UAAU,EACf,KAAK,YAAY,EACjB,KAAK,SAAS,EACd,KAAK,cAAc,EACnB,KAAK,UAAU,EACf,KAAK,cAAc,EACnB,KAAK,iBAAiB,EACzB,MAAM,eAAe,CAAC"}

package/dist/index.js

@@ -0,0 +1,29 @@
+// @azerothjs/language-service
+//
+// Compiler-aware language intelligence for `.azeroth` files, packaged for any
+// editor frontend (the bundled LSP server in @azerothjs/language-server, a
+// test harness, or a browser playground).
+//
+// The pipeline, in the order it runs (and a good order to read it in):
+//   virtual-code - reuse the compiler's scanner + parser to compile a
+//                  `.azeroth` file into a virtual TypeScript module, recording a
+//                  precise offset mapping for every user-authored span
+//   ts-project   - run a single ts.LanguageService over those virtual modules
+//                  (the engine for type inference, completion, hover, etc.)
+//   markup-model - classify the caret (tag name / attribute / expression / …)
+//                  so the providers know which vocabulary to offer
+//   providers    - one focused module per editor feature
+//   service      - the AzerothLanguageService facade that ties them together
+//
+// The core depends only on `typescript` and `@azerothjs/compiler`, so it runs
+// (and is tested) without an editor in the loop.
+export { AzerothLanguageService } from "./service.js";
+export { AzerothProject, isVirtualFile, toVirtualFile, toAzerothPath } from "./ts-project.js";
+export { generateVirtualCode, BUILTIN_COMPONENTS } from "./virtual-code.js";
+export { CodeMapping } from "./mapping.js";
+export { classifyPosition, collectMarkupNodes } from "./markup-model.js";
+export { BUILTIN_COMPONENT_MAP, DOM_EVENTS } from "./language-data.js";
+export { LineIndex } from "./text.js";
+export { uriToPath, pathToUri } from "./uri.js";
+export { CompletionItemKind, SymbolKind, DiagnosticSeverity, SEMANTIC_TOKEN_TYPES } from "./protocol.js";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,8BAA8B;AAC9B,EAAE;AACF,8EAA8E;AAC9E,2EAA2E;AAC3E,0CAA0C;AAC1C,EAAE;AACF,uEAAuE;AACvE,sEAAsE;AACtE,iFAAiF;AACjF,uEAAuE;AACvE,8EAA8E;AAC9E,4EAA4E;AAC5E,8EAA8E;AAC9E,mEAAmE;AACnE,yDAAyD;AACzD,6EAA6E;AAC7E,EAAE;AACF,8EAA8E;AAC9E,iDAAiD;AAEjD,OAAO,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAC;AAItD,OAAO,EACH,cAAc,EACd,aAAa,EACb,aAAa,EACb,aAAa,EAChB,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EACH,mBAAmB,EACnB,kBAAkB,EAErB,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EAAE,WAAW,EAAyC,MAAM,cAAc,CAAC;AAElF,OAAO,EACH,gBAAgB,EAChB,kBAAkB,EAErB,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EACH,qBAAqB,EACrB,UAAU,EAEb,MAAM,oBAAoB,CAAC;AAE5B,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AACtC,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAEhD,OAAO,EACH,kBAAkB,EAClB,UAAU,EACV,kBAAkB,EAClB,oBAAoB,EAoBvB,MAAM,eAAe,CAAC"}

package/dist/language-data.d.ts

@@ -0,0 +1,41 @@
+/** A completion-ready description of a built-in component. */
+export interface BuiltinComponent {
+    name: string;
+    /** Short signature-like detail shown beside the name. */
+    detail: string;
+    /** Markdown documentation. */
+    doc: string;
+    /** Known prop names with one-line docs, for attribute completion. */
+    props: {
+        name: string;
+        doc: string;
+        required: boolean;
+    }[];
+}
+/**
+ * The components the compiler auto-imports from `@azerothjs/core` when markup
+ * uses them. Mirrors @azerothjs/compiler's BUILTIN_COMPONENTS, with prop data
+ * taken from the renderer/component prop interfaces.
+ */
+export declare const BUILTIN_COMPONENTS: BuiltinComponent[];
+/** Fast lookup of built-in component data by name. */
+export declare const BUILTIN_COMPONENT_MAP: Map<string, BuiltinComponent>;
+/**
+ * DOM event handler attribute names. AzerothJS binds any `on<Event>` prop as a
+ * listener (camelCase) and passes the handler through verbatim (see the
+ * compiler's codegen) - this differs from HTML's lowercase `onclick`, so it is
+ * supplied here rather than by the HTML service.
+ */
+export declare const DOM_EVENTS: string[];
+/**
+ * Concise documentation for common element attributes that the standard HTML
+ * dataset ships *without* a description (form/input attributes especially), so
+ * `type`, `placeholder`, `value`, … aren't left blank on hover/completion.
+ * Global attributes (`class`, `id`, `title`, `style`, `aria-*`) and many tag
+ * attributes already carry MDN docs straight from the HTML engine; this only
+ * fills the gaps.
+ */
+export declare const ATTRIBUTE_DOCS: Record<string, string>;
+/** Fallback documentation for a common element attribute, or undefined. */
+export declare function attributeDocumentation(name: string): string | undefined;
+//# sourceMappingURL=language-data.d.ts.map

package/dist/language-data.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"language-data.d.ts","sourceRoot":"","sources":["../src/language-data.ts"],"names":[],"mappings":"AAWA,8DAA8D;AAC9D,MAAM,WAAW,gBAAgB;IAE7B,IAAI,EAAE,MAAM,CAAC;IACb,yDAAyD;IACzD,MAAM,EAAE,MAAM,CAAC;IACf,8BAA8B;IAC9B,GAAG,EAAE,MAAM,CAAC;IACZ,qEAAqE;IACrE,KAAK,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,OAAO,CAAA;KAAE,EAAE,CAAC;CAC7D;AAED;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,EAAE,gBAAgB,EAsFhD,CAAC;AAEF,sDAAsD;AACtD,eAAO,MAAM,qBAAqB,+BAA4E,CAAC;AAQ/G;;;;;GAKG;AACH,eAAO,MAAM,UAAU,EAAE,MAAM,EAW9B,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CA0BjD,CAAC;AAEF,2EAA2E;AAC3E,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAGvE"}

package/dist/language-data.js

@@ -0,0 +1,164 @@
+// Static language knowledge that isn't derivable from a single `.azeroth`
+// file: the HTML vocabulary markup targets (tags, global attributes, DOM
+// events) and the framework's built-in components.
+//
+// The built-in component data here is transcribed directly from the runtime's
+// own prop interfaces (@azerothjs/renderer, @azerothjs/component, the compiler's
+// auto-import set) - it is not invented. Deep type detail (exact prop types,
+// generics) still flows from TypeScript at hover/signature time; this table
+// exists so completion can *offer* the components and their props with a useful
+// one-line summary before the type bridge fills in the rest.
+/**
+ * The components the compiler auto-imports from `@azerothjs/core` when markup
+ * uses them. Mirrors @azerothjs/compiler's BUILTIN_COMPONENTS, with prop data
+ * taken from the renderer/component prop interfaces.
+ */
+export const BUILTIN_COMPONENTS = [
+    {
+        name: 'Show',
+        detail: '<Show when={…} fallback={…}>…</Show>',
+        doc: 'Conditionally renders its children when `when` is truthy, otherwise the optional `fallback`. Swaps automatically when the reactive condition changes.',
+        props: [
+            { name: 'when', doc: 'Reactive condition. Children show while truthy.', required: true },
+            { name: 'fallback', doc: 'Rendered when `when` is false. Optional.', required: false }
+        ]
+    },
+    {
+        name: 'For',
+        detail: '<For each={…} key={…}>{(item, i) => …}</For>',
+        doc: 'Keyed list rendering. Re-uses DOM elements across updates by `key`, so only changed rows touch the DOM. The child is a render function `(item, index) => element`.',
+        props: [
+            { name: 'each', doc: 'Reactive getter returning the array of items.', required: true },
+            { name: 'key', doc: 'Returns a stable unique key per item: `(item, index) => string | number`.', required: true }
+        ]
+    },
+    {
+        name: 'Switch',
+        detail: '<Switch fallback={…}><Match/>…</Switch>',
+        doc: 'Renders the first `<Match>` whose `when` is truthy (priority order). Optional `fallback` when none match.',
+        props: [
+            { name: 'fallback', doc: 'Rendered when no `<Match>` matches. Optional.', required: false }
+        ]
+    },
+    {
+        name: 'Match',
+        detail: '<Match when={…}>…</Match>',
+        doc: 'A single case inside `<Switch>`. Rendered when its `when` condition is the first truthy one.',
+        props: [
+            { name: 'when', doc: 'Reactive condition for this case.', required: true }
+        ]
+    },
+    {
+        name: 'Portal',
+        detail: '<Portal target={…}>…</Portal>',
+        doc: 'Renders its children into a different DOM node (defaults to `document.body`). Useful for modals, tooltips, and overlays.',
+        props: [
+            { name: 'target', doc: 'Destination element. Defaults to `document.body`.', required: false }
+        ]
+    },
+    {
+        name: 'Dynamic',
+        detail: '<Dynamic component={…} props={…} />',
+        doc: 'Renders a component chosen at runtime. When the `component` getter changes, the old one is removed and the new one mounted.',
+        props: [
+            { name: 'component', doc: 'Reactive getter returning the component to render (or null).', required: true },
+            { name: 'props', doc: 'Optional reactive getter returning props for the component.', required: false }
+        ]
+    },
+    {
+        name: 'Suspense',
+        detail: '<Suspense on={[…]} fallback={…}>…</Suspense>',
+        doc: 'Shows `fallback` while any watched resource is loading, then reveals children once all have settled.',
+        props: [
+            { name: 'on', doc: 'Array of resources to watch (captured once, not reactive to array mutation).', required: true },
+            { name: 'fallback', doc: 'Rendered while any watched resource is loading.', required: true }
+        ]
+    },
+    {
+        name: 'Transition',
+        detail: '<Transition when={…} name="…">…</Transition>',
+        doc: 'Animated show/hide. With a `name`, auto-generates the 6-class enter/leave family; without one, falls back to an instant swap.',
+        props: [
+            { name: 'when', doc: 'Reactive boolean: true to show, false to hide.', required: true },
+            { name: 'name', doc: 'Class-name prefix for the enter/leave transition classes.', required: false },
+            { name: 'duration', doc: 'Fallback transition timeout in ms. Default 1000.', required: false }
+        ]
+    },
+    {
+        name: 'ErrorBoundary',
+        detail: '<ErrorBoundary fallback={(err, reset) => …}>…</ErrorBoundary>',
+        doc: 'Catches errors thrown while rendering its subtree and shows `fallback(error, reset)` instead. Call `reset` to retry.',
+        props: [
+            { name: 'fallback', doc: 'Renders the error UI: `(error, reset) => element`.', required: true }
+        ]
+    },
+    {
+        name: 'Outlet',
+        detail: '<Outlet />',
+        doc: 'Renders nested-route content inside a layout component. Provided automatically by `<Routes>`.',
+        props: []
+    }
+];
+/** Fast lookup of built-in component data by name. */
+export const BUILTIN_COMPONENT_MAP = new Map(BUILTIN_COMPONENTS.map(component => [component.name, component]));
+// Host-element vocabulary (HTML tags, attributes, and attribute values, with
+// MDN documentation) is provided by `vscode-html-languageservice` - the same
+// engine VS Code's HTML support uses - via providers/html-service.ts, so it is
+// complete and stays current without a hand-maintained list here. What remains
+// below is genuinely AzerothJS-specific.
+/**
+ * DOM event handler attribute names. AzerothJS binds any `on<Event>` prop as a
+ * listener (camelCase) and passes the handler through verbatim (see the
+ * compiler's codegen) - this differs from HTML's lowercase `onclick`, so it is
+ * supplied here rather than by the HTML service.
+ */
+export const DOM_EVENTS = [
+    'onClick', 'onDblClick', 'onMouseDown', 'onMouseUp', 'onMouseEnter', 'onMouseLeave',
+    'onMouseMove', 'onMouseOver', 'onMouseOut', 'onContextMenu',
+    'onInput', 'onChange', 'onSubmit', 'onReset', 'onFocus', 'onBlur', 'onFocusIn', 'onFocusOut',
+    'onKeyDown', 'onKeyUp', 'onKeyPress',
+    'onPointerDown', 'onPointerUp', 'onPointerMove', 'onPointerEnter', 'onPointerLeave',
+    'onTouchStart', 'onTouchEnd', 'onTouchMove',
+    'onScroll', 'onWheel', 'onDrag', 'onDragStart', 'onDragEnd', 'onDragOver', 'onDrop',
+    'onCopy', 'onCut', 'onPaste',
+    'onLoad', 'onError', 'onAnimationEnd', 'onTransitionEnd'
+];
+/**
+ * Concise documentation for common element attributes that the standard HTML
+ * dataset ships *without* a description (form/input attributes especially), so
+ * `type`, `placeholder`, `value`, … aren't left blank on hover/completion.
+ * Global attributes (`class`, `id`, `title`, `style`, `aria-*`) and many tag
+ * attributes already carry MDN docs straight from the HTML engine; this only
+ * fills the gaps.
+ */
+export const ATTRIBUTE_DOCS = {
+    type: 'The kind of control to render (e.g. `text`, `checkbox`, `email`, `number`, `password`).',
+    value: 'The control’s current value. In AzerothJS, bind it reactively: `value={signal()}`.',
+    placeholder: 'Hint text shown while the field is empty.',
+    checked: 'Whether a checkbox/radio is selected. Bind reactively: `checked={done()}`.',
+    disabled: 'When present, the control is non-interactive.',
+    readonly: 'When present, the value can’t be edited (but is still submitted).',
+    required: 'Marks the field as required for form submission.',
+    name: 'The control name, submitted with the form data.',
+    min: 'Minimum allowed value (numeric/date inputs).',
+    max: 'Maximum allowed value (numeric/date inputs).',
+    step: 'Granularity of allowed values (numeric/date inputs).',
+    pattern: 'A regular expression the value must match.',
+    autocomplete: 'Hint for the browser’s autofill behaviour.',
+    selected: 'Marks an `<option>` as initially selected.',
+    multiple: 'Allows selecting or entering multiple values.',
+    rows: 'Visible number of text rows in a `<textarea>`.',
+    cols: 'Visible width, in characters, of a `<textarea>`.',
+    src: 'The URL of the resource (image, script, media, …).',
+    alt: 'Alternative text describing an image.',
+    for: 'Associates a `<label>` with a control by its `id`.',
+    action: 'The URL that processes the form submission.',
+    method: 'The HTTP method used to submit the form (`get` / `post`).',
+    colspan: 'Number of columns a table cell spans.',
+    rowspan: 'Number of rows a table cell spans.'
+};
+/** Fallback documentation for a common element attribute, or undefined. */
+export function attributeDocumentation(name) {
+    return ATTRIBUTE_DOCS[name.toLowerCase()];
+}
+//# sourceMappingURL=language-data.js.map