@fluixi/ts-plugin 0.1.0-alpha.1 → 0.1.0-alpha.2

package/dist/index.js

@@ -423,26 +423,54 @@ function templatePieces(ts, tpl, sf) {
   });
   return pieces;
 }
-function templateAt(ts, sf, pos) {
-  let found;
+
+// src/cache.ts
+var parsed = /* @__PURE__ */ new WeakMap();
+function parseCached(ts, sf, tpl) {
+  let byTemplate = parsed.get(sf);
+  if (!byTemplate) {
+    byTemplate = /* @__PURE__ */ new Map();
+    parsed.set(sf, byTemplate);
+  }
+  const key = tpl.getStart(sf);
+  const hit = byTemplate.get(key);
+  if (hit) return hit;
+  const result = k(templatePieces(ts, tpl, sf));
+  byTemplate.set(key, result);
+  return result;
+}
+var templates = /* @__PURE__ */ new WeakMap();
+function templatesIn(ts, sf) {
+  const hit = templates.get(sf);
+  if (hit) return hit;
+  const found = [];
   const visit = (node) => {
-    if (found) return;
-    if (ts.isTaggedTemplateExpression(node) && ts.isIdentifier(node.tag) && (node.tag.text === "html" || node.tag.text === "svg") && pos >= node.template.getStart(sf) && pos <= node.template.getEnd()) {
-      found = node;
-      return;
+    if (ts.isTaggedTemplateExpression(node) && ts.isIdentifier(node.tag) && (node.tag.text === "html" || node.tag.text === "svg")) {
+      found.push(node);
     }
     ts.forEachChild(node, visit);
   };
   visit(sf);
+  found.sort((a, b2) => a.getStart(sf) - b2.getStart(sf));
+  templates.set(sf, found);
   return found;
 }
+function templateAtCached(ts, sf, pos) {
+  let match;
+  for (const tpl of templatesIn(ts, sf)) {
+    const start = tpl.template.getStart(sf);
+    if (start > pos) break;
+    if (pos <= tpl.template.getEnd()) match = tpl;
+  }
+  return match;
+}
 
 // src/hover.ts
 function componentQuickInfo(ts, ls, fileName, position) {
   const program = ls.getProgram();
   const sf = program?.getSourceFile(fileName);
   if (!program || !sf) return void 0;
-  const template = templateAt(ts, sf, position);
+  const template = templateAtCached(ts, sf, position);
   if (!template) return void 0;
   const hit = componentTagAt(template, sf, position, ts);
   if (!hit) return void 0;
@@ -457,7 +485,7 @@ function componentQuickInfo(ts, ls, fileName, position) {
   return { ...info, textSpan: { start: hit.start, length: hit.name.length } };
 }
 function componentTagAt(template, sf, position, ts) {
-  const { root } = k(templatePieces(ts, template.template, sf));
+  const { root } = parseCached(ts, sf, template.template);
   let hit;
   const walk = (nodes) => {
     for (const node of nodes) {
@@ -621,14 +649,14 @@ function resolveElementType(ts, checker, location, tag) {
   return t ?? resolveGlobalType(ts, checker, location, "HTMLElement");
 }
 function inferParamAt(ts, program, sf, position) {
-  const template = templateAt(ts, sf, position);
+  const template = templateAtCached(ts, sf, position);
   if (!template || ts.isNoSubstitutionTemplateLiteral(template.template)) return void 0;
   const spans = template.template.templateSpans;
   const holeExprs = spans.map((s) => s.expression);
   const holeIndex = holeExprs.findIndex((e) => position >= e.getStart(sf) && position <= e.getEnd());
   if (holeIndex === -1) return void 0;
   const roles = /* @__PURE__ */ new Map();
-  holeRoles(k(templatePieces(ts, template.template, sf)).root.children, roles);
+  holeRoles(parseCached(ts, sf, template.template).root.children, roles);
   const role = roles.get(holeIndex);
   if (!role) return void 0;
   const fn = holeExprs[holeIndex];
@@ -706,7 +734,7 @@ function componentPropCompletions(ts, ls, fileName, position) {
   const program = ls.getProgram();
   const sf = program?.getSourceFile(fileName);
   if (!program || !sf) return void 0;
-  const template = templateAt(ts, sf, position);
+  const template = templateAtCached(ts, sf, position);
   if (!template) return void 0;
   const comp = componentTagAtAttrArea(ts, sf, template.template, position);
   if (!comp || !comp.tag) return void 0;
@@ -735,7 +763,7 @@ function componentPropHover(ts, ls, fileName, position) {
   const program = ls.getProgram();
   const sf = program?.getSourceFile(fileName);
   if (!program || !sf) return void 0;
-  const template = templateAt(ts, sf, position);
+  const template = templateAtCached(ts, sf, position);
   if (!template) return void 0;
   const hit = propNameAt(ts, sf, template.template, position);
   if (!hit) return void 0;
@@ -771,7 +799,7 @@ function componentPropHover(ts, ls, fileName, position) {
   };
 }
 function propNameAt(ts, sf, tpl, position) {
-  const { root } = k(templatePieces(ts, tpl, sf));
+  const { root } = parseCached(ts, sf, tpl);
   let hit;
   const walk = (nodes) => {
     for (const node of nodes) {
@@ -846,7 +874,7 @@ function firstParamType(ts, checker, type) {
   return void 0;
 }
 function componentTagAtAttrArea(ts, sf, tpl, position) {
-  const { root } = k(templatePieces(ts, tpl, sf));
+  const { root } = parseCached(ts, sf, tpl);
   let hit;
   const walk = (nodes) => {
     for (const node of nodes) {
@@ -921,6 +949,175 @@ function propertyAccessAt(ts, sf, position) {
   return found;
 }
 
+// src/elements.ts
+var ATTRIBUTES_MODULE = "@fluixi/dom/attributes";
+var perProgram = /* @__PURE__ */ new WeakMap();
+function intrinsics(ts, program, host, sf) {
+  const hit = perProgram.get(program);
+  if (hit) return hit;
+  let type;
+  try {
+    const checker = program.getTypeChecker();
+    const declared = (file) => {
+      if (!file) return void 0;
+      const moduleSymbol = checker.getSymbolAtLocation(file);
+      const symbol = moduleSymbol?.exports?.get(ts.escapeLeadingUnderscores("IntrinsicElements"));
+      return symbol ? checker.getDeclaredTypeOfSymbol(symbol) : void 0;
+    };
+    const resolved = ts.resolveModuleName(
+      ATTRIBUTES_MODULE,
+      sf.fileName,
+      program.getCompilerOptions(),
+      host
+    );
+    type = declared(
+      resolved.resolvedModule && program.getSourceFile(resolved.resolvedModule.resolvedFileName)
+    );
+    if (!type) {
+      for (const file of program.getSourceFiles()) {
+        if (!file.isDeclarationFile && file.fileName.indexOf("@fluixi/dom") === -1) continue;
+        if (file.fileName.indexOf("@fluixi/dom") === -1) continue;
+        type = declared(file);
+        if (type) break;
+      }
+    }
+  } catch {
+    type = void 0;
+  }
+  const entry = { type, byTag: /* @__PURE__ */ new Map() };
+  perProgram.set(program, entry);
+  return entry;
+}
+function attributesFor(ts, program, host, sf, tag) {
+  const state = intrinsics(ts, program, host, sf);
+  if (!state.type) return void 0;
+  if (state.byTag.has(tag)) return state.byTag.get(tag);
+  let props;
+  const checker = program.getTypeChecker();
+  const tagSymbol = state.type.getProperty(tag);
+  if (tagSymbol) {
+    const decl = tagSymbol.valueDeclaration ?? tagSymbol.declarations?.[0];
+    if (decl) props = checker.getTypeOfSymbolAtLocation(tagSymbol, decl).getProperties();
+  }
+  state.byTag.set(tag, props);
+  return props;
+}
+function elementAtAttributeArea(ts, sf, tpl, position) {
+  const { root } = parseCached(ts, sf, tpl);
+  let hit;
+  const walk = (nodes) => {
+    for (const node of nodes) {
+      if (node.kind === "Element") {
+        const el = node;
+        const openStart = el.loc.start + 1 + el.tag.length;
+        const openEnd = firstAttributeEnd(el);
+        if (position > openStart && position <= openEnd) {
+          const present = /* @__PURE__ */ new Set();
+          for (const a of el.attributes) {
+            if ("loc" in a && a.loc) present.add(writtenName(sf.text, a.loc.start));
+          }
+          hit = { tag: el.tag, present };
+        }
+      }
+      if (!hit && "children" in node && node.children) walk(node.children);
+      if (hit) return;
+    }
+  };
+  walk(root.children);
+  return hit;
+}
+function writtenName(text, start) {
+  let end = start;
+  while (end < text.length && !/[\s=/>]/.test(text[end])) end++;
+  return text.slice(start, end);
+}
+function firstAttributeEnd(el) {
+  let end = el.loc.start + 1 + el.tag.length;
+  for (const a of el.attributes) {
+    if ("loc" in a && a.loc) end = Math.max(end, a.loc.end);
+  }
+  return end + 1;
+}
+function elementAttributeCompletions(ts, ls, host, fileName, position) {
+  const program = ls.getProgram();
+  const sf = program?.getSourceFile(fileName);
+  if (!program || !sf) return void 0;
+  const tpl = templateAtCached(ts, sf, position);
+  if (!tpl) return void 0;
+  const hit = elementAtAttributeArea(ts, sf, tpl.template, position);
+  if (!hit) return void 0;
+  const props = attributesFor(ts, program, host, sf, hit.tag);
+  if (!props) return void 0;
+  const entries = [];
+  for (const p2 of props) {
+    const name = p2.getName();
+    if (name === "children" || hit.present.has(name)) continue;
+    entries.push({
+      name,
+      kind: ts.ScriptElementKind.memberVariableElement,
+      kindModifiers: "",
+      sortText: name.startsWith("on") ? "1" : "0"
+    });
+  }
+  return entries.length ? entries : void 0;
+}
+function attributeNameAt(ts, sf, tpl, position) {
+  const { root } = parseCached(ts, sf, tpl);
+  let hit;
+  const walk = (nodes) => {
+    for (const node of nodes) {
+      if (node.kind === "Element") {
+        const el = node;
+        for (const a of el.attributes) {
+          if (!("loc" in a) || !a.loc) continue;
+          const start = a.loc.start;
+          const name = writtenName(sf.text, start);
+          if (name && position >= start && position <= start + name.length) {
+            hit = { tag: el.tag, name, start };
+          }
+        }
+      }
+      if (!hit && "children" in node && node.children) walk(node.children);
+      if (hit) return;
+    }
+  };
+  walk(root.children);
+  return hit;
+}
+function elementAttributeHover(ts, ls, host, fileName, position) {
+  const program = ls.getProgram();
+  const sf = program?.getSourceFile(fileName);
+  if (!program || !sf) return void 0;
+  const tpl = templateAtCached(ts, sf, position);
+  if (!tpl) return void 0;
+  const hit = attributeNameAt(ts, sf, tpl.template, position);
+  if (!hit) return void 0;
+  const props = attributesFor(ts, program, host, sf, hit.tag);
+  const symbol = props?.find((p2) => p2.getName() === hit.name);
+  if (!symbol) return void 0;
+  const decl = symbol.valueDeclaration ?? symbol.declarations?.[0];
+  if (!decl) return void 0;
+  const checker = program.getTypeChecker();
+  const typeText = checker.typeToString(checker.getTypeOfSymbolAtLocation(symbol, decl));
+  return {
+    kind: ts.ScriptElementKind.memberVariableElement,
+    kindModifiers: "",
+    textSpan: { start: hit.start, length: hit.name.length },
+    displayParts: [
+      { text: "(", kind: "punctuation" },
+      { text: "attribute", kind: "text" },
+      { text: ")", kind: "punctuation" },
+      { text: " ", kind: "space" },
+      { text: `${hit.tag}.`, kind: "text" },
+      { text: hit.name, kind: "propertyName" },
+      { text: ":", kind: "punctuation" },
+      { text: " ", kind: "space" },
+      { text: typeText, kind: "text" }
+    ],
+    documentation: symbol.getDocumentationComment(checker)
+  };
+}
+
 // src/virtual.ts
 var EVENT_MAP_KEYS = new Set(Object.keys({
   click: 0,
@@ -985,12 +1182,6 @@ function inHole(segments, pos) {
 function inKey(segments, pos) {
   return segments.some((s) => s.key && pos >= s.srcStart && pos <= s.srcEnd);
 }
-function toGenerated(segments, pos) {
-  for (const s of segments) {
-    if (pos >= s.srcStart && pos <= s.srcEnd) return s.genStart + (pos - s.srcStart);
-  }
-  return -1;
-}
 function toSource(segments, pos) {
   for (const s of segments) {
     if (pos >= s.genStart && pos <= s.genEnd) return s.srcStart + (pos - s.genStart);
@@ -998,8 +1189,8 @@ function toSource(segments, pos) {
   return -1;
 }
 function buildVirtual(ts, sf) {
-  const templates = collectTemplates(ts, sf);
-  if (templates.length === 0) return void 0;
+  const templates2 = collectTemplates(ts, sf);
+  if (templates2.length === 0) return void 0;
   const srcText = sf.text;
   const segments = [];
   let gen = "";
@@ -1012,7 +1203,7 @@ function buildVirtual(ts, sf) {
     src = to;
   };
   gen += PRELUDE;
-  for (const tpl of templates) {
+  for (const tpl of templates2) {
     copy(tpl.node.getStart(sf));
     gen = emitTemplate(ts, sf, tpl, gen, segments, srcText);
     src = tpl.node.getEnd();
@@ -1207,81 +1398,105 @@ function emitTemplate(ts, sf, tpl, gen, segments, srcText) {
   return gen;
 }
 
-// src/virtual-service.ts
-var VirtualService = class {
+// src/shadow.ts
+var SUFFIX = ".__fx.ts";
+function isShadowPath(fileName) {
+  return fileName.endsWith(SUFFIX);
+}
+function shadowPathFor(fileName) {
+  return fileName + SUFFIX;
+}
+function sourcePathFor(shadow) {
+  return shadow.slice(0, -SUFFIX.length);
+}
+var ShadowFiles = class {
   constructor(ts, host) {
     this.ts = ts;
     this.host = host;
+    this.patchHost();
+  }
+  built = /* @__PURE__ */ new Map();
+  /** Source files known to contain no templates, so we skip building a shadow. */
+  barren = /* @__PURE__ */ new Map();
+  /**
+   * Teach the existing host about shadow paths. The language service holds this
+   * host object, so overriding its methods in place is enough — no second service.
+   */
+  patchHost() {
+    const ts = this.ts;
+    const host = this.host;
     const self = this;
-    const virtualHost = new Proxy(host, {
-      get(target, prop, receiver) {
-        if (prop === "getScriptSnapshot") {
-          return (fileName) => {
-            const v2 = self.virtual(fileName);
-            return v2 ? self.ts.ScriptSnapshot.fromString(v2.text) : target.getScriptSnapshot(fileName);
-          };
-        }
-        const value = Reflect.get(target, prop, receiver);
-        return typeof value === "function" ? value.bind(target) : value;
+    const originalNames = host.getScriptFileNames.bind(host);
+    host.getScriptFileNames = () => {
+      const names = originalNames();
+      const out = names.slice();
+      for (const name of names) {
+        if (!isShadowPath(name) && self.build(name)) out.push(shadowPathFor(name));
       }
-    });
-    this.ls = ts.createLanguageService(virtualHost, ts.createDocumentRegistry());
+      return out;
+    };
+    const originalSnapshot = host.getScriptSnapshot.bind(host);
+    host.getScriptSnapshot = (fileName) => {
+      if (!isShadowPath(fileName)) return originalSnapshot(fileName);
+      const built = self.build(sourcePathFor(fileName));
+      return built ? ts.ScriptSnapshot.fromString(built.text) : void 0;
+    };
+    const originalVersion = host.getScriptVersion.bind(host);
+    host.getScriptVersion = (fileName) => isShadowPath(fileName) ? originalVersion(sourcePathFor(fileName)) : originalVersion(fileName);
+    if (typeof host.fileExists === "function") {
+      const originalExists = host.fileExists.bind(host);
+      host.fileExists = (fileName) => isShadowPath(fileName) ? !!self.build(sourcePathFor(fileName)) : originalExists(fileName);
+    }
   }
-  ls;
-  /** Cached per file: the virtual text + segments, keyed by the file's version. */
-  cache = /* @__PURE__ */ new Map();
-  /** The virtual doc for a file (built + cached per source version), if it has templates. */
-  virtual(fileName) {
+  /** Build (and cache per source version) the shadow text for a file. */
+  build(fileName) {
     const version = this.host.getScriptVersion(fileName);
-    const hit = this.cache.get(fileName);
-    if (hit && hit.version === version) return hit.text ? hit : void 0;
-    const snap = this.host.getScriptSnapshot(fileName);
-    if (!snap) return void 0;
-    const src = snap.getText(0, snap.getLength());
-    const sf = this.ts.createSourceFile(fileName, src, this.ts.ScriptTarget.Latest, true, scriptKind(this.ts, fileName));
-    const v2 = buildVirtual(this.ts, sf);
-    this.cache.set(fileName, { version, text: v2?.text ?? "", segments: v2?.segments ?? [] });
-    return v2;
-  }
-  segmentsFor(fileName) {
-    return this.virtual(fileName)?.segments;
+    if (this.barren.get(fileName) === version) return void 0;
+    const hit = this.built.get(fileName);
+    if (hit && hit.version === version) return hit;
+    const snapshot = this.host.getScriptSnapshot(fileName);
+    if (!snapshot) return void 0;
+    const text = snapshot.getText(0, snapshot.getLength());
+    if (text.indexOf("html`") === -1 && text.indexOf("svg`") === -1) {
+      this.barren.set(fileName, version);
+      this.built.delete(fileName);
+      return void 0;
+    }
+    const sf = this.ts.createSourceFile(fileName, text, this.ts.ScriptTarget.Latest, true);
+    const virtual = buildVirtual(this.ts, sf);
+    if (!virtual) {
+      this.barren.set(fileName, version);
+      this.built.delete(fileName);
+      return void 0;
+    }
+    const entry = {
+      version,
+      text: virtual.text + "\nexport {};\n",
+      segments: virtual.segments
+    };
+    this.built.set(fileName, entry);
+    return entry;
   }
-  service() {
-    return this.ls;
+  /** The shadow path for a source file, when it has one. */
+  shadowFor(fileName) {
+    return this.build(fileName) ? shadowPathFor(fileName) : void 0;
   }
-  toGen(fileName, pos) {
-    const segs = this.virtual(fileName)?.segments;
-    return segs ? toGenerated(segs, pos) : -1;
+  segmentsFor(fileName) {
+    return this.build(fileName)?.segments;
   }
-  toSrc(fileName, pos) {
-    const segs = this.virtual(fileName)?.segments;
-    return segs ? toSource(segs, pos) : -1;
+  toSrc(fileName, position) {
+    const segments = this.segmentsFor(fileName);
+    return segments ? toSource(segments, position) : -1;
   }
-  /** True when a SOURCE position lies inside an embedded `${…}` hole. */
-  inHole(fileName, pos) {
-    const segs = this.virtual(fileName)?.segments;
-    return segs ? inHole(segs, pos) : false;
+  inHole(fileName, position) {
+    const segments = this.segmentsFor(fileName);
+    return !!segments && inHole(segments, position);
   }
-  /** True when a SOURCE position lies on a mapped component prop-name key. */
-  inKey(fileName, pos) {
-    const segs = this.virtual(fileName)?.segments;
-    return segs ? inKey(segs, pos) : false;
+  inKey(fileName, position) {
+    const segments = this.segmentsFor(fileName);
+    return !!segments && inKey(segments, position);
   }
 };
-function scriptKind(ts, fileName) {
-  if (fileName.endsWith(".tsx")) return ts.ScriptKind.TSX;
-  if (fileName.endsWith(".jsx")) return ts.ScriptKind.JSX;
-  if (fileName.endsWith(".js") || fileName.endsWith(".mjs") || fileName.endsWith(".cjs")) return ts.ScriptKind.JS;
-  return ts.ScriptKind.TS;
-}
-
-// src/bridge.ts
-function mapDiagnostic(vs, fileName, d) {
-  if (d.start === void 0) return d;
-  const start = vs.toSrc(fileName, d.start);
-  if (start === -1) return void 0;
-  return { ...d, start };
-}
 
 // src/index.ts
 function init(modules) {
@@ -1289,11 +1504,12 @@ function init(modules) {
   return {
     create(info) {
       const ls = info.languageService;
-      let vs;
+      const host = info.languageServiceHost;
+      let shadows;
       try {
-        vs = new VirtualService(ts, info.languageServiceHost);
+        shadows = new ShadowFiles(ts, info.languageServiceHost);
       } catch {
-        vs = void 0;
+        shadows = void 0;
       }
       const proxy = /* @__PURE__ */ Object.create(null);
       for (const key of Object.keys(ls)) {
@@ -1318,17 +1534,18 @@ function init(modules) {
           return true;
         });
       };
-      const holeDiagnostics = (fileName, get) => {
-        if (!vs || !vs.segmentsFor(fileName)) return [];
+      const holeDiagnostics = (fileName) => {
+        const shadow = shadows?.shadowFor(fileName);
+        if (!shadow) return [];
         try {
           const sourceFile = ls.getProgram()?.getSourceFile(fileName);
           const out = [];
-          for (const d of get(fileName)) {
+          for (const d of ls.getSemanticDiagnostics(shadow)) {
             if (d.start === void 0) continue;
-            const m2 = mapDiagnostic(vs, fileName, d);
-            if (m2 && m2.start !== void 0 && (vs.inHole(fileName, m2.start) || vs.inKey(fileName, m2.start))) {
-              out.push({ ...m2, file: sourceFile });
-            }
+            const start = shadows.toSrc(fileName, d.start);
+            if (start === -1) continue;
+            if (!shadows.inHole(fileName, start) && !shadows.inKey(fileName, start)) continue;
+            out.push({ ...d, start, file: sourceFile });
           }
           return out;
         } catch {
@@ -1336,16 +1553,30 @@ function init(modules) {
         }
       };
       proxy.getSemanticDiagnostics = (fileName) => {
+        if (isShadowPath(fileName)) return [];
         const base = reliableFilter(fileName, ls.getSemanticDiagnostics(fileName));
-        return base.concat(holeDiagnostics(fileName, (f) => vs.service().getSemanticDiagnostics(f)));
+        return base.concat(holeDiagnostics(fileName));
       };
-      proxy.getSuggestionDiagnostics = (fileName) => reliableFilter(fileName, ls.getSuggestionDiagnostics(fileName));
+      proxy.getSuggestionDiagnostics = (fileName) => isShadowPath(fileName) ? [] : reliableFilter(fileName, ls.getSuggestionDiagnostics(fileName));
+      proxy.getSyntacticDiagnostics = (fileName) => isShadowPath(fileName) ? [] : ls.getSyntacticDiagnostics(fileName);
+      const notShadow = (items) => items?.filter((i) => !isShadowPath(i.fileName));
+      proxy.findRenameLocations = (fileName, position, findInStrings, findInComments, prefs) => notShadow(ls.findRenameLocations(fileName, position, findInStrings, findInComments, prefs));
+      proxy.getReferencesAtPosition = (fileName, position) => notShadow(ls.getReferencesAtPosition(fileName, position));
+      proxy.getDefinitionAtPosition = (fileName, position) => notShadow(ls.getDefinitionAtPosition(fileName, position));
+      proxy.getImplementationAtPosition = (fileName, position) => notShadow(ls.getImplementationAtPosition(fileName, position));
+      proxy.getDocumentHighlights = (fileName, position, filesToSearch) => ls.getDocumentHighlights(fileName, position, filesToSearch)?.filter((h) => !isShadowPath(h.fileName));
+      proxy.findReferences = (fileName, position) => ls.findReferences(fileName, position)?.filter((r) => !isShadowPath(r.definition.fileName)).map((r) => ({ ...r, references: r.references.filter((x2) => !isShadowPath(x2.fileName)) }));
       proxy.getQuickInfoAtPosition = (fileName, position) => {
         try {
           const prop = componentPropHover(ts, ls, fileName, position);
           if (prop) return prop;
         } catch {
         }
+        try {
+          const attr = elementAttributeHover(ts, ls, host, fileName, position);
+          if (attr) return attr;
+        } catch {
+        }
         try {
           const inferred = paramQuickInfo(ts, ls, fileName, position);
           if (inferred) return inferred;
@@ -1359,6 +1590,11 @@ function init(modules) {
           if (props) return completionList(props);
         } catch {
         }
+        try {
+          const attrs = elementAttributeCompletions(ts, ls, host, fileName, position);
+          if (attrs) return completionList(attrs);
+        } catch {
+        }
         try {
           const members = paramMemberCompletions(ts, ls, fileName, position);
           if (members) return completionList(members);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fluixi/ts-plugin",
-  "version": "0.1.0-alpha.1",
+  "version": "0.1.0-alpha.2",
   "license": "MIT",
   "private": false,
   "publishConfig": {