@fluixi/ts-plugin 0.1.0-alpha.10 → 0.1.0-alpha.12

package/README.md

@@ -1,34 +1,49 @@
 # @fluixi/ts-plugin
 
-A TypeScript language-service plugin that teaches `tsserver` about Fluixi
-`` html`...` `` templates.
+A TypeScript language-service plugin that gives `` html`...` `` templates the same editor
+support JSX gets.
 
 ## The problem
 
-TypeScript sees a tagged template as an opaque string. A component referenced
-only by tag inside a template —
+TypeScript sees a tagged template as an opaque string. Everything inside it falls off the
+map: a component referenced only by tag is reported "declared but never used", a callback
+param is an implicit `any`, nothing completes, hover says nothing, and go-to-definition
+lands on the template literal instead of the component.
 
 ```ts
 function UserCard() { /* … */ }
 
 const app = html`<main><UserCard /></main>`;
+//                      ^ greyed out — TypeScript never counted this as a reference
 ```
 
-— is never counted as a reference, so `UserCard` is reported as **"declared but
-never used"** and greyed out, even though it's used.
+Authoring in `` html`` `` shouldn't cost you the editor.
 
-## The fix
+## What you get
 
-This plugin proxies the language service, reparses each `` html`` ``/`` svg`` ``
-template with [`@fluixi/template-parser`](../template-parser), collects the
-component tag names, and drops the "unused" diagnostics for those bindings — for
-both local declarations and imports.
+Reparse the template with [`@fluixi/template-parser`](../template-parser), map every tag and
+hole back to a real source position, and ask the program's own checker about it:
+
+- **Hover** — a component tag shows its signature, a prop shows its declared type, an
+  element attribute shows what it takes, and an inferred callback param (`each`, `event`,
+  `ref`, `use`, `Show`) shows the type it was inferred to.
+- **Completion** — component prop names inside a tag, element attributes on an intrinsic
+  tag, and members of an inferred param (`it.`, `el.`, `e.`).
+- **Navigation** — go-to-definition, find-all-references and rename work through tags.
+  Rename only adds tags when TypeScript's own rename succeeded, so you never get a
+  rewritten `<Tag>` with a stale `</Tag>`.
+- **Diagnostics** — a bare accessor in a template (`` html`<p>${count}</p>` ``) is flagged,
+  since it renders the function once and never updates; a property that doesn't exist on an
+  inferred param is reported.
+- **Quiet where it should be** — unused-component reports and implicit-`any` noise on params
+  the template can infer are dropped.
+- **Quick fixes** — "Call `count`" for a bare accessor, with a fix-all for the file.
 
 ## Enable it
 
-Add it to your project's `tsconfig.json` and use the **workspace** TypeScript
-version (VS Code: `TypeScript: Select TypeScript Version → Use Workspace
-Version`, since tsconfig plugins only load under the workspace TS):
+Add it to your project's `tsconfig.json` and use the **workspace** TypeScript version
+(VS Code: `TypeScript: Select TypeScript Version → Use Workspace Version` — tsconfig plugins
+only load under the workspace TS):
 
 ```jsonc
 {
@@ -38,6 +53,22 @@ Version`, since tsconfig plugins only load under the workspace TS):
 }
 ```
 
+Nothing else. JSX needs no plugin, and neither do the `$signal`-style intrinsics — those are
+typed by the `fluixi.d.ts` the compiler generates.
+
+## How it stays out of the way
+
+Everything is computed on the **existing** program's checker. The plugin creates no language
+service, adds no files, and never touches the host — it wraps the service it's handed, and
+every addition is wrapped so a failure costs the extra information, never the real answer.
+
+That restraint is deliberate. Two earlier designs for deep type-checking inside `${…}` holes
+both had to go: a second `ts.LanguageService` meant a second document registry, so lib.d.ts
+and node_modules were parsed twice; and shadow files added via `getScriptFileNames` re-entered
+host machinery on every project sync and crashed the language service outright. Hole
+diagnostics weren't worth either — a `${…}` hole is a real expression, so TypeScript already
+checks it.
+
 ## License
 
 MIT

package/dist/index.js

@@ -376,79 +376,6 @@ var N = class {
 function b(e, t = {}) {
   return new N(e, t).parse();
 }
-function I(e) {
-  let t = [], i2 = 0;
-  return e.forEach((n, r) => {
-    t.push({ kind: "static", text: n, start: i2 }), i2 += n.length, r < e.length - 1 && t.push({ kind: "hole", index: r, start: i2, end: i2 });
-  }), t;
-}
-function Q(e, t = {}) {
-  return b(I(e), t);
-}
-
-// src/collect.ts
-var UNUSED_CODES = /* @__PURE__ */ new Set([6133, 6196, 6198, 6199, 6205, 6138, 6192]);
-function isUnusedCode(code) {
-  return UNUSED_CODES.has(code);
-}
-function usedComponentTags(ts, sourceFile) {
-  const tags = /* @__PURE__ */ new Set();
-  const visit = (node) => {
-    if (ts.isTaggedTemplateExpression(node) && ts.isIdentifier(node.tag) && (node.tag.text === "html" || node.tag.text === "svg")) {
-      collectTags(Q(templateStatics(ts, node.template)).root.children, tags);
-    }
-    ts.forEachChild(node, visit);
-  };
-  visit(sourceFile);
-  return tags;
-}
-function templateStatics(ts, tpl) {
-  if (ts.isNoSubstitutionTemplateLiteral(tpl)) return [tpl.text];
-  const out = [tpl.head.text];
-  for (const span of tpl.templateSpans) out.push(span.literal.text);
-  return out;
-}
-function collectTags(nodes, out) {
-  for (const node of nodes) {
-    if (node.kind === "Component" && node.tag) out.add(node.tag.split(".")[0]);
-    if ("children" in node && node.children) collectTags(node.children, out);
-  }
-}
-function shouldSuppress(ts, sourceFile, diagnostic, used) {
-  if (diagnostic.start === void 0 || !isUnusedCode(diagnostic.code)) return false;
-  const spanText = sourceFile.text.substr(diagnostic.start, diagnostic.length ?? 0);
-  const decl = importDeclarationAt(ts, sourceFile, diagnostic.start);
-  if (decl) {
-    const names = importedNames(ts, decl);
-    if (names.includes(spanText)) return used.has(spanText);
-    return names.some((n) => used.has(n));
-  }
-  return used.has(spanText);
-}
-function importDeclarationAt(ts, sourceFile, pos) {
-  let found;
-  const visit = (node) => {
-    if (found) return;
-    if (ts.isImportDeclaration(node) && node.getStart(sourceFile) <= pos && node.getEnd() >= pos) {
-      found = node;
-      return;
-    }
-    ts.forEachChild(node, visit);
-  };
-  visit(sourceFile);
-  return found;
-}
-function importedNames(ts, decl) {
-  const bindings = decl.importClause?.namedBindings;
-  const names = [];
-  if (decl.importClause?.name) names.push(decl.importClause.name.text);
-  if (bindings && ts.isNamedImports(bindings)) {
-    for (const el of bindings.elements) names.push(el.name.text);
-  } else if (bindings && ts.isNamespaceImport(bindings)) {
-    names.push(bindings.name.text);
-  }
-  return names;
-}
 
 // src/pieces.ts
 function rawContent(ts, node, sf) {
@@ -491,9 +418,17 @@ function parseCached(ts, sf, tpl) {
   return result;
 }
 var templates = /* @__PURE__ */ new WeakMap();
+function mayHaveTemplate(text) {
+  return text.includes("html`") || text.includes("svg`");
+}
+var NONE = [];
 function templatesIn(ts, sf) {
   const hit = templates.get(sf);
   if (hit) return hit;
+  if (!mayHaveTemplate(sf.text)) {
+    templates.set(sf, NONE);
+    return NONE;
+  }
   const found = [];
   const visit = (node) => {
     if (ts.isTaggedTemplateExpression(node) && ts.isIdentifier(node.tag) && (node.tag.text === "html" || node.tag.text === "svg")) {
@@ -516,6 +451,64 @@ function templateAtCached(ts, sf, pos) {
   return match;
 }
 
+// src/collect.ts
+var UNUSED_CODES = /* @__PURE__ */ new Set([6133, 6196, 6198, 6199, 6205, 6138, 6192]);
+function isUnusedCode(code) {
+  return UNUSED_CODES.has(code);
+}
+var tagCache = /* @__PURE__ */ new WeakMap();
+function usedComponentTags(ts, sourceFile) {
+  const hit = tagCache.get(sourceFile);
+  if (hit) return hit;
+  const tags = /* @__PURE__ */ new Set();
+  for (const template of templatesIn(ts, sourceFile)) {
+    collectTags(parseCached(ts, sourceFile, template.template).root.children, tags);
+  }
+  tagCache.set(sourceFile, tags);
+  return tags;
+}
+function collectTags(nodes, out) {
+  for (const node of nodes) {
+    if (node.kind === "Component" && node.tag) out.add(node.tag.split(".")[0]);
+    if ("children" in node && node.children) collectTags(node.children, out);
+  }
+}
+function shouldSuppress(ts, sourceFile, diagnostic, used) {
+  if (diagnostic.start === void 0 || !isUnusedCode(diagnostic.code)) return false;
+  const spanText = sourceFile.text.substr(diagnostic.start, diagnostic.length ?? 0);
+  const decl = importDeclarationAt(ts, sourceFile, diagnostic.start);
+  if (decl) {
+    const names = importedNames(ts, decl);
+    if (names.includes(spanText)) return used.has(spanText);
+    return names.some((n) => used.has(n));
+  }
+  return used.has(spanText);
+}
+function importDeclarationAt(ts, sourceFile, pos) {
+  let found;
+  const visit = (node) => {
+    if (found) return;
+    if (ts.isImportDeclaration(node) && node.getStart(sourceFile) <= pos && node.getEnd() >= pos) {
+      found = node;
+      return;
+    }
+    ts.forEachChild(node, visit);
+  };
+  visit(sourceFile);
+  return found;
+}
+function importedNames(ts, decl) {
+  const bindings = decl.importClause?.namedBindings;
+  const names = [];
+  if (decl.importClause?.name) names.push(decl.importClause.name.text);
+  if (bindings && ts.isNamedImports(bindings)) {
+    for (const el of bindings.elements) names.push(el.name.text);
+  } else if (bindings && ts.isNamespaceImport(bindings)) {
+    names.push(bindings.name.text);
+  }
+  return names;
+}
+
 // ../compiler/dist/resolve/builtins.mjs
 var s = ["Show", "For", "Index", "Switch", "Match", "Portal", "Dynamic", "ErrorBoundary"];
 var i = ["Suspense", "SuspenseList", "Await"];

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@fluixi/ts-plugin",
-  "version": "0.1.0-alpha.10",
+  "version": "0.1.0-alpha.12",
   "license": "MIT",
   "private": false,
   "publishConfig": {
     "registry": "https://registry.npmjs.org/",
     "access": "public"
   },
-  "description": "TypeScript language-service plugin for Fluixi: teaches tsserver that component tags used inside html`` templates (e.g. <UserCard/>) count as references, so they aren't flagged as unused.",
+  "description": "gives html`` templates the editor support JSX already gets; a component used only as a tag is no longer reported as unused",
   "type": "commonjs",
   "files": [
     "dist",
@@ -16,8 +16,8 @@
   ],
   "main": "./dist/index.js",
   "dependencies": {
-    "@fluixi/template-parser": "0.1.0-alpha.3",
-    "@fluixi/compiler": "1.0.0-alpha.76"
+    "@fluixi/template-parser": "0.1.0-alpha.4",
+    "@fluixi/compiler": "1.0.0-alpha.78"
   },
   "devDependencies": {
     "esbuild": "^0.24.0",