@rohal12/spindle-lsp 0.1.0 → 0.2.0

package/dist/bin.js

@@ -4453,6 +4453,299 @@ var init_code_actions = __esm({
   }
 });
 
+// src/plugins/document-symbol.ts
+import { SymbolKind } from "vscode-languageserver";
+function computeDocumentSymbols(uri, workspace) {
+  const text = workspace.documents.getText(uri);
+  if (text === void 0) return [];
+  const passages = workspace.passages.getPassagesInDocument(uri);
+  if (passages.length === 0) return [];
+  const storyVarsPassage = workspace.passages.getStoryVariables();
+  const lines = text.split("\n");
+  const symbols = [];
+  for (const passage of passages) {
+    const headerLine = passage.range.start.line;
+    const selectionRange = {
+      start: { line: headerLine, character: 0 },
+      end: { line: headerLine, character: lines[headerLine]?.length ?? 0 }
+    };
+    const passageSymbol = {
+      name: passage.name,
+      kind: SymbolKind.Namespace,
+      range: passage.range,
+      selectionRange,
+      children: []
+    };
+    if (passage.tags?.includes("widget")) {
+      const contentStart = passage.range.start.line + 1;
+      const contentEnd = passage.range.end.line + 1;
+      const widgetDefRegex2 = /\{widget\s+"([^"]+)"[^}]*\}/gi;
+      for (let i = contentStart; i < contentEnd && i < lines.length; i++) {
+        widgetDefRegex2.lastIndex = 0;
+        let match;
+        while ((match = widgetDefRegex2.exec(lines[i])) !== null) {
+          const charStart = match.index;
+          const charEnd = charStart + match[0].length;
+          passageSymbol.children.push({
+            name: match[1],
+            kind: SymbolKind.Function,
+            range: {
+              start: { line: i, character: charStart },
+              end: { line: i, character: charEnd }
+            },
+            selectionRange: {
+              start: { line: i, character: charStart },
+              end: { line: i, character: charEnd }
+            }
+          });
+        }
+      }
+    }
+    if (storyVarsPassage && storyVarsPassage.uri === uri && passage.name === "StoryVariables") {
+      const contentStart = passage.range.start.line + 1;
+      const contentEnd = passage.range.end.line + 1;
+      for (let i = contentStart; i < contentEnd && i < lines.length; i++) {
+        const varMatch = lines[i].match(/^\$([A-Za-z_$][\w$]*)\s*=/);
+        if (varMatch) {
+          const charEnd = varMatch[0].length;
+          passageSymbol.children.push({
+            name: "$" + varMatch[1],
+            kind: SymbolKind.Variable,
+            range: {
+              start: { line: i, character: 0 },
+              end: { line: i, character: lines[i].length }
+            },
+            selectionRange: {
+              start: { line: i, character: 0 },
+              end: { line: i, character: charEnd }
+            }
+          });
+        }
+      }
+    }
+    symbols.push(passageSymbol);
+  }
+  return symbols;
+}
+function toLspRange7(r) {
+  return {
+    start: { line: r.start.line, character: r.start.character },
+    end: { line: r.end.line, character: r.end.character }
+  };
+}
+function toLspDocumentSymbol(sym) {
+  return {
+    name: sym.name,
+    kind: sym.kind,
+    range: toLspRange7(sym.range),
+    selectionRange: toLspRange7(sym.selectionRange),
+    children: sym.children?.map(toLspDocumentSymbol)
+  };
+}
+var documentSymbolPlugin;
+var init_document_symbol = __esm({
+  "src/plugins/document-symbol.ts"() {
+    "use strict";
+    documentSymbolPlugin = {
+      id: "document-symbol",
+      capabilities: {
+        documentSymbolProvider: true
+      },
+      initialize(ctx) {
+        ctx.connection.onDocumentSymbol((params) => {
+          const symbols = computeDocumentSymbols(params.textDocument.uri, ctx.workspace);
+          return symbols.map(toLspDocumentSymbol);
+        });
+      }
+    };
+  }
+});
+
+// src/plugins/workspace-symbol.ts
+import { SymbolKind as SymbolKind2 } from "vscode-languageserver";
+function searchWorkspaceSymbols(query, workspace) {
+  const lowerQuery = query.toLowerCase();
+  const results = [];
+  for (const passage of workspace.passages.getAllPassages()) {
+    if (lowerQuery && !passage.name.toLowerCase().includes(lowerQuery)) continue;
+    results.push({
+      name: passage.name,
+      kind: SymbolKind2.Namespace,
+      uri: passage.uri,
+      range: passage.range
+    });
+  }
+  for (const widget of workspace.widgets.getAllWidgets()) {
+    if (lowerQuery && !widget.name.toLowerCase().includes(lowerQuery)) continue;
+    results.push({
+      name: widget.name,
+      kind: SymbolKind2.Function,
+      uri: widget.uri,
+      range: widget.range
+    });
+  }
+  for (const [name, decl] of workspace.variables.getDeclared()) {
+    const displayName = "$" + name;
+    if (lowerQuery && !displayName.toLowerCase().includes(lowerQuery)) continue;
+    results.push({
+      name: displayName,
+      kind: SymbolKind2.Variable,
+      uri: decl.declarationUri ?? "",
+      range: decl.declarationRange ?? { start: { line: 0, character: 0 }, end: { line: 0, character: 0 } }
+    });
+  }
+  return results;
+}
+function toLspRange8(r) {
+  return {
+    start: { line: r.start.line, character: r.start.character },
+    end: { line: r.end.line, character: r.end.character }
+  };
+}
+var workspaceSymbolPlugin;
+var init_workspace_symbol = __esm({
+  "src/plugins/workspace-symbol.ts"() {
+    "use strict";
+    workspaceSymbolPlugin = {
+      id: "workspace-symbol",
+      capabilities: {
+        workspaceSymbolProvider: true
+      },
+      initialize(ctx) {
+        ctx.connection.onWorkspaceSymbol((params) => {
+          const symbols = searchWorkspaceSymbols(params.query, ctx.workspace);
+          return symbols.map((s) => ({
+            name: s.name,
+            kind: s.kind,
+            location: {
+              uri: s.uri,
+              range: toLspRange8(s.range)
+            }
+          }));
+        });
+      }
+    };
+  }
+});
+
+// src/plugins/folding-range.ts
+import { FoldingRangeKind } from "vscode-languageserver";
+function computeFoldingRanges(uri, workspace) {
+  const text = workspace.documents.getText(uri);
+  if (text === void 0) return [];
+  const ranges = [];
+  const passages = workspace.passages.getPassagesInDocument(uri);
+  for (const passage of passages) {
+    const startLine = passage.range.start.line;
+    const endLine = passage.range.end.line;
+    if (endLine > startLine) {
+      ranges.push({
+        startLine,
+        endLine,
+        kind: "region"
+      });
+    }
+  }
+  const macros = parseMacros(text);
+  pairMacros(macros, (name) => workspace.macros.isBlock(name));
+  for (const macro of macros) {
+    if (macro.open && macro.pair !== -1) {
+      const closingMacro = macros[macro.pair];
+      const startLine = macro.range.start.line;
+      const endLine = closingMacro.range.start.line;
+      if (endLine > startLine) {
+        ranges.push({
+          startLine,
+          endLine
+        });
+      }
+    }
+  }
+  return ranges;
+}
+var foldingRangePlugin;
+var init_folding_range = __esm({
+  "src/plugins/folding-range.ts"() {
+    "use strict";
+    init_macro_parser();
+    foldingRangePlugin = {
+      id: "folding-range",
+      capabilities: {
+        foldingRangeProvider: true
+      },
+      initialize(ctx) {
+        ctx.connection.onFoldingRanges((params) => {
+          const ranges = computeFoldingRanges(params.textDocument.uri, ctx.workspace);
+          return ranges.map((r) => ({
+            startLine: r.startLine,
+            endLine: r.endLine,
+            kind: r.kind === "region" ? FoldingRangeKind.Region : void 0
+          }));
+        });
+      }
+    };
+  }
+});
+
+// src/plugins/document-link.ts
+function computeDocumentLinks(uri, workspace) {
+  const text = workspace.documents.getText(uri);
+  if (text === void 0) return [];
+  const passages = workspace.passages.getPassagesInDocument(uri);
+  if (passages.length === 0) return [];
+  const links = [];
+  for (const passage of passages) {
+    const contentStartLine = passage.range.start.line + 1;
+    const contentEndLine = passage.range.end.line + 1;
+    const lines = text.split("\n");
+    const contentLines = lines.slice(contentStartLine, contentEndLine);
+    const content = contentLines.join("\n");
+    const passageLinks = parseLinks(content, contentStartLine);
+    for (const ref of passageLinks) {
+      const targetPassage = workspace.passages.getPassage(ref.name);
+      let target;
+      if (targetPassage) {
+        target = `${targetPassage.uri}#L${targetPassage.range.start.line + 1}`;
+      }
+      links.push({
+        range: ref.range,
+        target
+      });
+    }
+  }
+  return links;
+}
+function toLspRange9(r) {
+  return {
+    start: { line: r.start.line, character: r.start.character },
+    end: { line: r.end.line, character: r.end.character }
+  };
+}
+var documentLinkPlugin;
+var init_document_link = __esm({
+  "src/plugins/document-link.ts"() {
+    "use strict";
+    init_link_parser();
+    documentLinkPlugin = {
+      id: "document-link",
+      capabilities: {
+        documentLinkProvider: {
+          resolveProvider: false
+        }
+      },
+      initialize(ctx) {
+        ctx.connection.onDocumentLinks((params) => {
+          const links = computeDocumentLinks(params.textDocument.uri, ctx.workspace);
+          return links.map((l) => ({
+            range: toLspRange9(l.range),
+            target: l.target
+          }));
+        });
+      }
+    };
+  }
+});
+
 // src/plugins/index.ts
 var allPlugins;
 var init_plugins = __esm({
@@ -4470,6 +4763,10 @@ var init_plugins = __esm({
     init_semantic_tokens();
     init_code_actions();
     init_format();
+    init_document_symbol();
+    init_workspace_symbol();
+    init_folding_range();
+    init_document_link();
     allPlugins = [
       diagnosticsPlugin,
       completionsPlugin,
@@ -4482,7 +4779,11 @@ var init_plugins = __esm({
       inlayHintsPlugin,
       semanticTokensPlugin,
       codeActionsPlugin,
-      formatPlugin
+      formatPlugin,
+      documentSymbolPlugin,
+      workspaceSymbolPlugin,
+      foldingRangePlugin,
+      documentLinkPlugin
     ];
   }
 });