ts-gem-lsp 0.0.1 → 0.1.0

package/dist/bin.js

@@ -12883,6 +12883,19 @@ var defaultConfiguration = {
   elementDefineRules: {}
 };
 
+// ../gem/lib/server.js
+var { get, set, has, deleteProperty, defineProperty, getOwnPropertyDescriptor, ownKeys } = Reflect;
+var getRequestScope = globalThis.__GEM_SSR__;
+
+// ../gem/lib/utils.js
+var { assign, fromEntries, entries, keys, defineProperty: defineProperty2, hasOwn } = Object;
+function camelToKebabCase(str) {
+  return str.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+}
+function kebabToCamelCase(str) {
+  return str.replace(/-(.)/g, (_substr, $1) => $1.toUpperCase());
+}
+
 // ../../node_modules/.pnpm/@mantou+vscode-html-languageservice@5.3.6/node_modules/@mantou/vscode-html-languageservice/lib/esm/parser/htmlScanner.js
 var l10n = __toESM(require_main2());
 
@@ -28857,15 +28870,6 @@ function getDefaultHTMLDataProvider() {
   return newHTMLDataProvider("default", htmlData);
 }
 
-// ../gem/lib/utils.js
-var { assign, fromEntries, entries, keys } = Object;
-function camelToKebabCase(str) {
-  return str.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
-}
-function kebabToCamelCase(str) {
-  return str.replace(/-(.)/g, (_substr, $1) => $1.toUpperCase());
-}
-
 // src/ts.ts
 var ts;
 async function loadTsModules(loader) {
@@ -28928,27 +28932,45 @@ function findElementRefs(file, rules) {
 }
 var ElementIndex = class {
   #getRules;
-  #cache = /* @__PURE__ */ new Map();
+  #rules;
+  #projects = /* @__PURE__ */ new Map();
   constructor(getRules) {
     this.#getRules = getRules;
   }
-  async get(project) {
-    let entry = this.#cache.get(project.id);
-    if (!entry) this.#cache.set(project.id, entry = {});
-    const current = entry;
-    current.refreshing ??= this.#scan(project).then((elements) => current.elements = elements).finally(() => current.refreshing = void 0);
-    return current.elements ?? current.refreshing;
+  /** 不传 URI 时全部重新扫描 */
+  invalidate(uri) {
+    if (uri === void 0) return this.#projects.clear();
+    for (const state of this.#projects.values()) state.changed.add(uri);
   }
-  async #scan(project) {
-    const fileNames = (await project.program.getSourceFileNames()).filter((name) => !isLibFile(name));
-    const files = await Promise.all(fileNames.map((name) => project.program.getSourceFile(name)));
+  get(project) {
     const rules = this.#getRules();
-    const elements = /* @__PURE__ */ new Map();
-    for (const file of files) {
-      if (!file) continue;
-      for (const ref of findElementRefs(file, rules)) elements.set(ref.tag, ref);
+    if (rules !== this.#rules) {
+      this.#rules = rules;
+      this.#projects.clear();
     }
-    return elements;
+    let state = this.#projects.get(project.id);
+    if (!state) {
+      state = { files: /* @__PURE__ */ new Map(), elements: /* @__PURE__ */ new Map(), changed: /* @__PURE__ */ new Set(), queue: Promise.resolve() };
+      this.#projects.set(project.id, state);
+    }
+    const result = state.queue.then(() => this.#update(project, state, rules));
+    state.queue = result.catch(() => {
+    });
+    return result;
+  }
+  async #update(project, state, rules) {
+    const changed = new Set([...state.changed].map((uri) => ts.api.documentURIToFileName(uri)));
+    state.changed.clear();
+    const fileNames = (await project.program.getSourceFileNames()).filter((name) => !isLibFile(name));
+    const current = new Set(fileNames);
+    const removed = [...state.files.keys()].filter((name) => !current.has(name));
+    const stale = fileNames.filter((name) => !state.files.has(name) || changed.has(name));
+    if (!removed.length && !stale.length) return state.elements;
+    for (const name of removed) state.files.delete(name);
+    const files = await Promise.all(stale.map((name) => project.program.getSourceFile(name)));
+    stale.forEach((name, i) => state.files.set(name, files[i] ? findElementRefs(files[i], rules) : []));
+    state.elements = new Map([...state.files.values()].flat().map((ref) => [ref.tag, ref]));
+    return state.elements;
   }
 };
 async function getUnionValues(type) {
@@ -29062,6 +29084,12 @@ function toPosition(text, offset) {
   for (let i = text.indexOf("\n"); i !== -1 && i < lineStart; i = text.indexOf("\n", i + 1)) line++;
   return { line, character: offset - lineStart };
 }
+function getTouchingToken(file, offset) {
+  const token = ts.ast.getTokenAtPosition(file, offset);
+  if (offset === 0 || token.getStart(file) !== offset) return token;
+  const previous = ts.ast.getTokenAtPosition(file, offset - 1);
+  return previous.end === offset ? previous : token;
+}
 function findAncestor(node, test) {
   for (let n = node; n; n = n.parent) if (test(n)) return n;
 }
@@ -29316,7 +29344,7 @@ function findClassNameAt(file, offset) {
     const element2 = findAncestor(template.node, isElementClass);
     return ref && element2 && { name: ref.name, range: ref.range, element: element2 };
   }
-  const token = ts.ast.getTokenAtPosition(file, offset);
+  const token = getTouchingToken(file, offset);
   if (!ts.ast.isIdentifier(token) && !ts.ast.isStringLiteral(token)) return;
   const isKey = getClassMapKeyNodes(file).includes(token);
   const element = findAncestor(token, isElementClass);
@@ -74763,8 +74791,8 @@ var HtmlService = class {
     if (!tag || startTagEnd === void 0 || vOffset > startTagEnd) return null;
     const tagStart = node.start + 1;
     if (vOffset <= tagStart + tag.length) {
-      const elementType2 = await resolveElementType(project, template.file, await this.#index.get(project), tag);
-      const declaration2 = await elementType2?.symbol?.declarations[0]?.resolve(project);
+      const elementType = await resolveElementType(project, template.file, await this.#index.get(project), tag);
+      const declaration2 = await elementType?.symbol?.declarations[0]?.resolve(project);
       if (!declaration2) return null;
       return [toLocationLink(template.toRangeFromOffsets(tagStart, tagStart + tag.length), declaration2)];
     }
@@ -74787,11 +74815,32 @@ var HtmlService = class {
         }
       ];
     }
+    const declaration = await this.#getPropDeclaration(project, template, tag, attrName);
+    return declaration ? [toLocationLink(origin, declaration)] : null;
+  }
+  /** 光标所在的元素特性及其对应的属性声明 */
+  async attributeAt(project, template, offset) {
+    const vOffset = template.toVirtualOffset(offset);
+    const node = this.#ls.parseHTMLDocument(template.doc).findNodeAt(vOffset);
+    const { tag, startTagEnd } = node;
+    if (!tag || startTagEnd === void 0 || vOffset > startTagEnd) return;
+    const attrEntry = [...node.attributesMap].find(([, { start, end: end2 }]) => vOffset >= start && vOffset <= end2);
+    if (!attrEntry) return;
+    const [attrName, { end }] = attrEntry;
+    const attr = getAttrName(attrName);
+    const declaration = await this.#getPropDeclaration(project, template, tag, attrName);
+    return declaration && {
+      name: attr,
+      /** `.prop` 使用属性名，其他使用特性名 */
+      isProperty: attrName.startsWith("."),
+      range: template.toRangeFromOffsets(end - attr.length, end),
+      declaration
+    };
+  }
+  async #getPropDeclaration(project, template, tag, attrName) {
     const elementType = await resolveElementType(project, template.file, await this.#index.get(project), tag);
-    const prop = await elementType?.type.getProperty(kebabToCamelCase(attr));
-    const declaration = await prop?.declarations[0]?.resolve(project);
-    if (!declaration) return null;
-    return [toLocationLink(origin, declaration)];
+    const prop = await elementType?.type.getProperty(kebabToCamelCase(getAttrName(attrName)));
+    return prop?.declarations[0]?.resolve(project);
   }
   /** 匹配的开始和结束标签 */
   highlights(template, offset) {
@@ -74820,6 +74869,9 @@ var HtmlService = class {
 
 // src/tags.ts
 var htmlLs3 = getLanguageService();
+var cssLs = getCSSLanguageService();
+var REGISTRY_METHODS = /* @__PURE__ */ new Set(["get", "whenDefined"]);
+var SELECTOR_METHODS = /* @__PURE__ */ new Set(["querySelector", "querySelectorAll", "closest", "matches"]);
 function getTagRanges(template, node) {
   const tag = node.tag;
   const ranges = [template.toRangeFromOffsets(node.start + 1, node.start + 1 + tag.length)];
@@ -74849,10 +74901,45 @@ function getCustomElementArg(node) {
   }
 }
 function findDefinedTag(file, offset) {
-  const node = ts.ast.getTokenAtPosition(file, offset);
+  const node = getTouchingToken(file, offset);
   if (!ts.ast.isStringLiteral(node) || !isCustomElementCall(node.parent)) return;
   return { tag: node.text, range: stringContentRange2(file, node), isDefinition: true };
 }
+function getSelectorTags(selector) {
+  const result = [];
+  const visit3 = (node) => {
+    if (node.type === NodeType.ElementNameSelector)
+      result.push({ tag: node.getText(), start: node.offset, end: node.end });
+    node.getChildren().forEach(visit3);
+  };
+  visit3(cssLs.parseStylesheet(TextDocument2.create("gem-selector://", "css", 0, `${selector}{}`)));
+  return result;
+}
+function getCallTags(node) {
+  if (!ts.ast.isCallExpression(node) || !ts.ast.isPropertyAccessExpression(node.expression)) return;
+  const [arg] = node.arguments;
+  if (!arg || !(ts.ast.isStringLiteral(arg) || ts.ast.isNoSubstitutionTemplateLiteral(arg))) return;
+  const { name, expression } = node.expression;
+  const isRegistry = ts.ast.isIdentifier(expression) && expression.text === "customElements";
+  if (name.text === "createElement" || isRegistry && REGISTRY_METHODS.has(name.text)) {
+    return { arg, tags: [{ tag: arg.text, start: 0, end: arg.text.length }] };
+  }
+  if (SELECTOR_METHODS.has(name.text)) return { arg, tags: getSelectorTags(arg.text) };
+}
+function stringTagRange(file, arg, start, end) {
+  const contentStart = arg.getStart(file) + 1;
+  return { start: toPosition(file.text, contentStart + start), end: toPosition(file.text, contentStart + end) };
+}
+function findCallTag(file, offset) {
+  const token = getTouchingToken(file, offset);
+  const call = token.parent && getCallTags(token.parent);
+  if (call?.arg !== token) return;
+  const contentStart = token.getStart(file) + 1;
+  const found = call.tags.find(({ start, end }) => offset >= contentStart + start && offset <= contentStart + end);
+  if (!found) return;
+  const range = stringTagRange(file, token, found.start, found.end);
+  return { tag: found.tag, range, isDefinition: false, tagRanges: [range] };
+}
 function findTemplateTag(file, offset) {
   const template = findTemplate(file, offset);
   if (template?.kind !== "html") return;
@@ -74868,7 +74955,7 @@ function findTemplateTag(file, offset) {
   return { tag: node.tag, range: tagRanges[0], isDefinition: false, tagRanges };
 }
 function findTagAt(file, offset) {
-  return findDefinedTag(file, offset) ?? findTemplateTag(file, offset);
+  return findDefinedTag(file, offset) ?? findCallTag(file, offset) ?? findTemplateTag(file, offset);
 }
 async function getProjectFiles(project) {
   const fileNames = (await project.program.getSourceFileNames()).filter((name) => !isDepFile(name));
@@ -74897,6 +74984,13 @@ async function findTagLocations(project, tag, css) {
       const arg = ts.ast.isClassDeclaration(node) ? getCustomElementArg(node) : void 0;
       if (arg?.text === tag) locations.push({ uri, range: stringContentRange2(file, arg) });
     }
+    file.forEachChild(function visit3(node) {
+      const call = getCallTags(node);
+      for (const found of call?.tags ?? []) {
+        if (found.tag === tag) locations.push({ uri, range: stringTagRange(file, call.arg, found.start, found.end) });
+      }
+      node.forEachChild(visit3);
+    });
   }
   return locations;
 }
@@ -74908,73 +75002,142 @@ function toTextEdits(locations, newText) {
 
 // src/props.ts
 var htmlLs4 = getLanguageService();
-var ATTRIBUTE_DECORATORS = ["attribute", "numattribute", "boolattribute", "property"];
+var ATTRIBUTE_DECORATORS = ["attribute", "numattribute", "boolattribute"];
+var PROPERTY_DECORATORS = ["property"];
 var EMITTER_DECORATORS = ["emitter", "globalemitter"];
-function getAttrForms(name, decorators) {
-  const kebab = camelToKebabCase(name);
-  if (decorators.some((d) => EMITTER_DECORATORS.includes(d))) return [["@", kebab]];
-  if (decorators.some((d) => ATTRIBUTE_DECORATORS.includes(d))) {
-    return [
-      ["", kebab],
-      ["?", kebab],
-      [".", name]
-    ];
-  }
-  return [];
+var ATTRIBUTE_METHODS = /* @__PURE__ */ new Set([
+  "getAttribute",
+  "setAttribute",
+  "hasAttribute",
+  "removeAttribute",
+  "toggleAttribute"
+]);
+var EVENT_METHODS = /* @__PURE__ */ new Set(["addEventListener", "removeEventListener"]);
+var asKebab = (name) => camelToKebabCase(name);
+var asCamel = (name) => name;
+function getPropKind(decorators) {
+  if (decorators.some((d) => EMITTER_DECORATORS.includes(d))) return "event";
+  if (decorators.some((d) => ATTRIBUTE_DECORATORS.includes(d))) return "attribute";
+  if (decorators.some((d) => PROPERTY_DECORATORS.includes(d))) return "property";
+}
+function getAttrForms({ name, kind }) {
+  const kebab = camelToKebabCase(name.text);
+  if (kind === "event") return [["@", kebab, asKebab]];
+  return [
+    ["", kebab, asKebab],
+    ["?", kebab, asKebab],
+    [".", name.text, asCamel]
+  ];
 }
 function findElementProp(file, offset) {
-  const token = ts.ast.getTokenAtPosition(file, offset);
+  const token = getTouchingToken(file, offset);
   const decl = token.parent;
   if (!ts.ast.isIdentifier(token) || !decl || !ts.ast.isPropertyDeclaration(decl) || decl.name !== token) return;
   const element = decl.parent;
   if (!ts.ast.isClassDeclaration(element) || !getTagFromDecorator(element)) return;
-  const forms = getAttrForms(token.text, getDecoratorNames(decl));
-  return forms.length ? { name: token, element, forms } : void 0;
+  const kind = getPropKind(getDecoratorNames(decl));
+  return kind && { name: token, element, kind };
 }
-async function getElementTags(project, element, index) {
-  const { checker } = project;
-  const file = element.getSourceFile();
-  const elementType = await checker.getTypeAtLocation(element.name ?? element);
-  const elements = await index.get(project);
-  const tags = await Promise.all(
-    [...elements.keys()].map(async (tag) => {
-      const type = await resolveElementType(project, file, elements, tag);
-      return type && await checker.isTypeAssignableTo(type.type, elementType) ? tag : void 0;
-    })
-  );
-  return new Set(tags.filter((tag) => tag !== void 0));
+async function getRelatedPropTest(project, prop) {
+  const file = prop.name.getSourceFile();
+  const entries2 = await project.languageService.getReferencedSymbolsForNode(prop.name, prop.name.getStart(file));
+  const declarations = new Set(entries2.flatMap(({ symbol }) => symbol?.declarations.map(declarationKey) ?? []));
+  return async (type) => {
+    const symbol = await type.getProperty(prop.name.text);
+    return !!symbol?.declarations.some((handle) => declarations.has(declarationKey(handle)));
+  };
 }
+var declarationKey = ({ path: path2, index }) => `${path2}:${index}`;
 function forEachHtmlNode3(nodes, fn) {
   for (const node of nodes) {
     fn(node);
     forEachHtmlNode3(node.children, fn);
   }
 }
-async function findPropAttributes(project, prop, index) {
-  const tags = await getElementTags(project, prop.element, index);
+function forEachNode(root, fn) {
+  root.forEachChild(function visit3(node) {
+    fn(node);
+    node.forEachChild(visit3);
+  });
+}
+function isStringArg(node) {
+  return !!node && (ts.ast.isStringLiteral(node) || ts.ast.isNoSubstitutionTemplateLiteral(node));
+}
+function nodeRange2(file, node, quote = 0) {
+  const start = node.getStart(file) + quote;
+  return { start: toPosition(file.text, start), end: toPosition(file.text, node.end - quote) };
+}
+function forEachSpreadObject(template, fn) {
+  if (!ts.ast.isTemplateExpression(template.node)) return;
+  const html = htmlLs4.parseHTMLDocument(template.doc);
+  const text = template.doc.getText();
+  for (const { expression } of template.node.templateSpans) {
+    if (!ts.ast.isObjectLiteralExpression(expression)) continue;
+    const vOffset = template.toVirtualOffset(expression.getStart(template.file)) - 2;
+    const node = html.findNodeAt(vOffset);
+    if (!node.tag || node.startTagEnd === void 0 || vOffset > node.startTagEnd) continue;
+    if (/=\s*["']?\s*$/.test(text.slice(node.start, vOffset))) continue;
+    fn(node.tag, expression);
+  }
+}
+async function findPropReferences(project, prop, index) {
+  const isRelated = await getRelatedPropTest(project, prop);
+  const elements = await index.get(project);
+  const elementFile = prop.element.getSourceFile();
+  const tags = /* @__PURE__ */ new Set();
+  await Promise.all(
+    [...elements.keys()].map(async (tag) => {
+      const type = await resolveElementType(project, elementFile, elements, tag);
+      if (type && await isRelated(type.type)) tags.add(tag);
+    })
+  );
+  const name = prop.name.text;
+  const kebab = camelToKebabCase(name);
+  const forms = getAttrForms(prop);
+  const methods = prop.kind === "event" ? EVENT_METHODS : prop.kind === "attribute" ? ATTRIBUTE_METHODS : void 0;
   const result = [];
+  const calls = [];
   for (const file of await getProjectFiles(project)) {
     const uri = ts.api.fileNameToDocumentURI(file.fileName);
     for (const template of findTemplates(file, "html")) {
       forEachHtmlNode3(htmlLs4.parseHTMLDocument(template.doc).roots, (node) => {
         if (!node.tag || !tags.has(node.tag)) return;
-        for (const form of prop.forms) {
-          const [decorate, name] = form;
-          const info = node.attributesMap.get(decorate + name);
+        for (const [decorate, attr, newText] of forms) {
+          const info = node.attributesMap.get(decorate + attr);
           if (!info) continue;
-          result.push({ uri, form, range: template.toRangeFromOffsets(info.start + decorate.length, info.end) });
+          result.push({ uri, range: template.toRangeFromOffsets(info.start + decorate.length, info.end), newText });
+        }
+      });
+      if (prop.kind === "event") continue;
+      forEachSpreadObject(template, (tag, obj) => {
+        if (!tags.has(tag)) return;
+        for (const p of obj.properties) {
+          const key = ts.ast.isSpreadAssignment(p) ? void 0 : p.name;
+          if (!key || !(ts.ast.isIdentifier(key) || ts.ast.isStringLiteral(key)) || key.text !== name) continue;
+          const newText = ts.ast.isShorthandPropertyAssignment(p) ? (n) => `${n}: ${name}` : asCamel;
+          result.push({ uri, range: nodeRange2(file, key, ts.ast.isStringLiteral(key) ? 1 : 0), newText });
         }
       });
     }
+    if (!methods) continue;
+    forEachNode(file, (node) => {
+      if (!ts.ast.isCallExpression(node) || !ts.ast.isPropertyAccessExpression(node.expression)) return;
+      const [arg] = node.arguments;
+      if (!methods.has(node.expression.name.text) || !isStringArg(arg) || arg.text !== kebab) return;
+      calls.push({ uri, file, receiver: node.expression.expression, arg });
+    });
   }
+  const matched = await Promise.all(
+    calls.map(async ({ receiver }) => isRelated(await project.checker.getTypeAtLocation(receiver)))
+  );
+  calls.forEach(({ uri, file, arg }, i) => {
+    if (matched[i]) result.push({ uri, range: nodeRange2(file, arg, 1), newText: asKebab });
+  });
   return result;
 }
-function getPropRenameEdits(attributes, newName) {
+function getPropRenameEdits(references, newName) {
   const changes = {};
-  for (const { uri, range, form } of attributes) {
-    const newText = form[0] === "." ? newName : camelToKebabCase(newName);
-    (changes[uri] ??= []).push({ range, newText });
-  }
+  for (const { uri, range, newText } of references) (changes[uri] ??= []).push({ range, newText: newText(newName) });
   return changes;
 }
 
@@ -75046,7 +75209,7 @@ function mergeWorkspaceEdit(edit, changes) {
   for (const [uri, edits] of Object.entries(changes)) merged[uri] = [...merged[uri] ?? [], ...edits];
   return { ...edit, changes: merged };
 }
-function createGemMiddleware(getApi, getConfig = () => defaultConfiguration) {
+function createGemMiddleware(getApi, getConfig = () => defaultConfiguration, renameDeclaration) {
   let rules;
   const getRules = () => {
     const config = getConfig().elementDefineRules;
@@ -75075,7 +75238,18 @@ function createGemMiddleware(getApi, getConfig = () => defaultConfiguration) {
     const offset = toOffset(file.text, position);
     const keys2 = await getClassMapKeys(project, file, offset, css) ?? await getThemeKeys(project, file, offset);
     if (keys2?.length) {
-      return { isIncomplete: false, items: keys2.map((label) => ({ label, kind: ENUM_MEMBER_KIND, sortText: "" })) };
+      const items2 = keys2.map((label) => ({
+        label,
+        kind: ENUM_MEMBER_KIND,
+        sortText: "",
+        data: {
+          fileName: file.fileName,
+          position: offset,
+          name: `gem:${label}`,
+          gem: true
+        }
+      }));
+      return { isIncomplete: false, items: items2 };
     }
     const items = Array.isArray(result) ? result : result?.items;
     const never = items?.length ? await getNeverMembers(project, file, offset) : void 0;
@@ -75109,6 +75283,17 @@ function createGemMiddleware(getApi, getConfig = () => defaultConfiguration) {
       targetSelectionRange: range
     }));
   }
+  async function getStringTagDefinition(uri, position) {
+    const ctx = await getFileContext(uri);
+    if (!ctx) return;
+    const { project, file } = ctx;
+    const offset = toOffset(file.text, position);
+    const tag = !findTemplate(file, offset) && findTagAt(file, offset);
+    if (!tag || tag.isDefinition) return;
+    const elementType = await resolveElementType(project, file, await index.get(project), tag.tag);
+    const declaration = await elementType?.symbol?.declarations[0]?.resolve(project);
+    return declaration ? [toLocationLink(tag.range, declaration)] : [];
+  }
   async function getCssReferences(uri, position) {
     const ctx = await getCssContext(uri, position);
     if (!ctx) return;
@@ -75125,6 +75310,23 @@ function createGemMiddleware(getApi, getConfig = () => defaultConfiguration) {
     const prop = ctx && findElementProp(ctx.file, toOffset(ctx.file.text, position));
     return prop && { ...ctx, prop };
   }
+  async function getAttributeContext(uri, position) {
+    if (!renameDeclaration) return;
+    const ctx = await getTemplateContext(uri, position);
+    if (ctx?.template.kind !== "html") return;
+    const attr = await html.attributeAt(ctx.project, ctx.template, ctx.offset);
+    if (!attr || !ts.ast.isPropertyDeclaration(attr.declaration)) return;
+    const file = attr.declaration.getSourceFile();
+    if (isDepFile(file.fileName)) return;
+    const nameStart = attr.declaration.name.getStart(file);
+    const prop = findElementProp(file, nameStart);
+    if (!prop) return;
+    const declaration = {
+      textDocument: { uri: ts.api.fileNameToDocumentURI(file.fileName) },
+      position: toPosition(file.text, nameStart)
+    };
+    return { ...ctx, attr, prop, declaration };
+  }
   async function getClassNameReferences(uri, position) {
     const ctx = await getFileContext(uri);
     if (!ctx) return;
@@ -75155,7 +75357,7 @@ function createGemMiddleware(getApi, getConfig = () => defaultConfiguration) {
     const template = findTemplate(file, offset);
     return template && { project, template, offset };
   }
-  return {
+  const middleware = {
     "textDocument/hover": async (result, { params }) => {
       const ctx = await getTemplateContext(params.textDocument.uri, params.position);
       if (!ctx) return result;
@@ -75205,6 +75407,8 @@ function createGemMiddleware(getApi, getConfig = () => defaultConfiguration) {
           targetSelectionRange: range
         }));
       }
+      const stringTagDefinition = await getStringTagDefinition(params.textDocument.uri, params.position);
+      if (stringTagDefinition) return stringTagDefinition;
       const cssDefinition = await getCssDefinition(params.textDocument.uri, params.position);
       if (cssDefinition) return cssDefinition;
       const ctx = await getTemplateContext(params.textDocument.uri, params.position);
@@ -75216,8 +75420,8 @@ function createGemMiddleware(getApi, getConfig = () => defaultConfiguration) {
       if (ctx) return findTagLocations(ctx.project, ctx.info.tag, css);
       const propCtx = await getPropContext(params.textDocument.uri, params.position);
       if (propCtx) {
-        const attributes = await findPropAttributes(propCtx.project, propCtx.prop, index);
-        return [...result ?? [], ...attributes.map(({ uri, range }) => ({ uri, range }))];
+        const references = await findPropReferences(propCtx.project, propCtx.prop, index);
+        return [...result ?? [], ...references.map(({ uri, range }) => ({ uri, range }))];
       }
       return await getCssReferences(params.textDocument.uri, params.position) ?? await getClassNameReferences(params.textDocument.uri, params.position) ?? result;
     },
@@ -75226,7 +75430,9 @@ function createGemMiddleware(getApi, getConfig = () => defaultConfiguration) {
       if (ctx) return { range: ctx.info.range, placeholder: ctx.info.tag };
       const cssCtx = await getCssContext(params.textDocument.uri, params.position);
       const prop = cssCtx && css.customPropertyAt(cssCtx.vDoc, cssCtx.offset);
-      return prop ? { range: prop.range, placeholder: prop.name } : result;
+      if (prop) return { range: prop.range, placeholder: prop.name };
+      const attrCtx = await getAttributeContext(params.textDocument.uri, params.position);
+      return attrCtx ? { range: attrCtx.attr.range, placeholder: attrCtx.attr.name } : result;
     },
     // 在定义处重命名所有使用的地方，在模板中只重命名当前元素的开始和结束标签
     "textDocument/rename": async (result, { params }) => {
@@ -75240,11 +75446,19 @@ function createGemMiddleware(getApi, getConfig = () => defaultConfiguration) {
         const locations2 = [...declarations, ...references].map((range) => ({ uri: textDocument.uri, range }));
         return { changes: toTextEdits(locations2, name) };
       }
+      const attrCtx = !ctx && await getAttributeContext(textDocument.uri, position);
+      if (attrCtx) {
+        const { project, attr, prop, declaration } = attrCtx;
+        const propName = attr.isProperty ? newName : kebabToCamelCase(newName);
+        const edit = await renameDeclaration({ ...declaration, newName: propName });
+        const references = await findPropReferences(project, prop, index);
+        return mergeWorkspaceEdit(edit ?? { changes: {} }, getPropRenameEdits(references, propName));
+      }
       if (!ctx) {
         const propCtx = await getPropContext(textDocument.uri, position);
         if (!propCtx || !result) return result;
-        const attributes = await findPropAttributes(propCtx.project, propCtx.prop, index);
-        return mergeWorkspaceEdit(result, getPropRenameEdits(attributes, newName));
+        const references = await findPropReferences(propCtx.project, propCtx.prop, index);
+        return mergeWorkspaceEdit(result, getPropRenameEdits(references, newName));
       }
       const { info } = ctx;
       const locations = info.isDefinition ? await findTagLocations(ctx.project, info.tag, css) : info.tagRanges.map((range) => ({ uri: textDocument.uri, range }));
@@ -75284,6 +75498,7 @@ function createGemMiddleware(getApi, getConfig = () => defaultConfiguration) {
       return fixes.length ? [...result ?? [], ...fixes] : result;
     }
   };
+  return { middleware, invalidate: (uri) => index.invalidate(uri) };
 }
 
 // src/bin.ts
@@ -75305,6 +75520,17 @@ function startNoopServer(clientReader2, clientWriter2) {
     }
   });
 }
+function getChangedFiles({ method, params }) {
+  switch (method) {
+    case "textDocument/didChange":
+    case "textDocument/didClose":
+      return [params.textDocument.uri];
+    case "workspace/didChangeWatchedFiles":
+      return params.changes.map(({ uri }) => uri);
+    default:
+      return [];
+  }
+}
 async function startProxy(tsDir2, clientReader2, clientWriter2) {
   const modules = await loadTsModules(createTypeScriptModuleLoader(path.join(tsDir2, "package.json")));
   const { default: getExePath } = await import(pathToFileURL2(path.join(tsDir2, "lib/getExePath.js")).href);
@@ -75325,9 +75551,10 @@ async function startProxy(tsDir2, clientReader2, clientWriter2) {
   const updateConfig = (gem) => {
     if (gem) config = { ...defaultConfiguration, ...gem };
   };
-  const middleware = createGemMiddleware(
+  const { middleware, invalidate } = createGemMiddleware(
     () => api,
-    () => config
+    () => config,
+    (params) => request("textDocument/rename", params)
   );
   const pendingRequests = /* @__PURE__ */ new Map();
   clientReader2.listen(async (msg) => {
@@ -75337,6 +75564,7 @@ async function startProxy(tsDir2, clientReader2, clientWriter2) {
     if (import_node.Message.isNotification(msg) && msg.method === "workspace/didChangeConfiguration") {
       updateConfig(msg.params.settings?.gem);
     }
+    if (import_node.Message.isNotification(msg)) for (const uri of getChangedFiles(msg)) invalidate(uri);
     if (import_node.Message.isRequest(msg) && msg.method in middleware) pendingRequests.set(msg.id, msg);
     serverWriter.write(msg);
     if (import_node.Message.isNotification(msg) && msg.method === "initialized") {