@tsrx/language-server 0.6.3 → 0.7.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -2397,6 +2397,12 @@ var TSRXVirtualCode = class {
2397
2397
  originalCode = "";
2398
2398
  /** @type {AST.Program | null} */
2399
2399
  sourceAst = null;
2400
+ /**
2401
+ * The `<script>` bodies of code (not data blocks) the transform appends to the
2402
+ * generated TSX as blocks; empty while the file has a fatal compile error.
2403
+ * @type {EmbeddedRegion[]}
2404
+ */
2405
+ scriptRegions = [];
2400
2406
  /** @type {boolean} */
2401
2407
  isDotCompletionMode = false;
2402
2408
  /** @type {unknown[]} */
@@ -2439,6 +2445,7 @@ var TSRXVirtualCode = class {
2439
2445
  this.fatalErrors = [];
2440
2446
  this.usageErrors = [];
2441
2447
  this.sourceAst = null;
2448
+ this.scriptRegions = [];
2442
2449
  this.isDotCompletionMode = false;
2443
2450
  let isDotTyped = false;
2444
2451
  let dotPosition = -1;
@@ -2497,7 +2504,7 @@ var TSRXVirtualCode = class {
2497
2504
  }
2498
2505
  if (result.fatalError) {
2499
2506
  logError$4("TSRX compilation failed for", this.fileName, ":", result.fatalError);
2500
- if (process.env.TSRX_TSC === "true") logTSRXErrors(this.fileName, [result.fatalError]);
2507
+ if (process.env.TSRX_TSC === "true") logTSRXErrors(this.fileName, [result.fatalError], newCode);
2501
2508
  this.fatalErrors.push(result.fatalError);
2502
2509
  files_with_fatal_compile_error.add(normalize_file_name_key(this.fileName));
2503
2510
  } else {
@@ -2506,11 +2513,12 @@ var TSRXVirtualCode = class {
2506
2513
  }
2507
2514
  this.originalCode = newCode;
2508
2515
  if (!result.fatalError && result.text) {
2509
- this.generatedCode = result.text;
2516
+ this.generatedCode = hashbang_as_comment(result.text);
2510
2517
  this.mappings = result.mappings;
2511
2518
  this.usageErrors = result.errors;
2512
2519
  this.sourceAst = result.sourceAst;
2513
- if (process.env.TSRX_TSC === "true" && result.errors.length > 0) logTSRXErrors(this.fileName, result.errors);
2520
+ this.scriptRegions = result.scriptRegions;
2521
+ if (process.env.TSRX_TSC === "true" && result.errors.length > 0) logTSRXErrors(this.fileName, result.errors, newCode);
2514
2522
  if (result.cssRegions.length > 0) log$9("Creating", result.cssRegions.length, "CSS embedded codes");
2515
2523
  this.embeddedCodes = result.cssRegions.map((region) => create_embedded_code_from_region(region, "css"));
2516
2524
  if (DEBUG) {
@@ -2529,7 +2537,7 @@ var TSRXVirtualCode = class {
2529
2537
  }
2530
2538
  } else {
2531
2539
  log$9("Compilation failed, only display where the compilation error occurred.");
2532
- this.generatedCode = newCode;
2540
+ this.generatedCode = hashbang_as_comment(newCode);
2533
2541
  this.mappings = [{
2534
2542
  sourceOffsets: [0],
2535
2543
  generatedOffsets: [0],
@@ -2628,6 +2636,19 @@ var TSRXVirtualCode = class {
2628
2636
  }
2629
2637
  };
2630
2638
  /**
2639
+ * Volar puts the generated code after blank lines as long as the source in the
2640
+ * file TypeScript reads (in tsserver and `tsrx-tsc`), so a `#!` line there is no
2641
+ * longer at the start of the file and TypeScript reads it as code: two
2642
+ * expression statements without `;`. They count when TypeScript infers the
2643
+ * semicolon style of an edit, so an import added to a file whose own statements
2644
+ * have no `;` lost its `;`. A line comment of the same length keeps every offset.
2645
+ * @param {string} code
2646
+ * @returns {string}
2647
+ */
2648
+ function hashbang_as_comment(code) {
2649
+ return code.startsWith("#!") ? `//${code.slice(2)}` : code;
2650
+ }
2651
+ /**
2631
2652
  * Clamp an intra-token offset into `[0, length]`.
2632
2653
  * @param {number} offset
2633
2654
  * @param {number} length
@@ -2637,20 +2658,70 @@ function clamp_offset(offset, length) {
2637
2658
  return Math.min(Math.max(offset, 0), length);
2638
2659
  }
2639
2660
  /**
2661
+ * @typedef {{
2662
+ * message?: unknown,
2663
+ * code?: unknown,
2664
+ * severity?: unknown,
2665
+ * type?: unknown,
2666
+ * pos?: unknown,
2667
+ * loc?: { line?: unknown, column?: unknown, start?: { line?: unknown, column?: unknown } },
2668
+ * }} LoggedDiagnostic
2669
+ */
2670
+ /**
2671
+ * Mirrors compiler diagnostics to stderr under `tsrx-tsc`. The line follows
2672
+ * tsc's `file(line,col): error TS2339: message` convention — position when the
2673
+ * diagnostic has one, then severity and the diagnostic `code` — so output is
2674
+ * greppable by code and actionable by position. A thrown (fatal) error stops
2675
+ * the compile, so it prints as an error whatever its `severity`, as the
2676
+ * language server shows it.
2640
2677
  * @param {string} file_name
2641
2678
  * @param {ReadonlyArray<unknown>} errors
2679
+ * @param {string} source the compiled text, which a diagnostic's `pos` indexes
2642
2680
  */
2643
- function logTSRXErrors(file_name, errors) {
2681
+ function logTSRXErrors(file_name, errors, source) {
2644
2682
  for (const error of errors) {
2645
- const message = error && typeof error === "object" && "message" in error ? String(
2646
- /** @type {{ message: unknown }} */
2647
- error.message
2648
- ) : String(error);
2649
- const key = `${file_name}\0${message}`;
2683
+ const details = error && typeof error === "object" ? error : void 0;
2684
+ const message = details && "message" in details ? String(details.message) : String(error);
2685
+ const severity = details?.severity === "warning" && details.type !== "fatal" ? "warning" : "error";
2686
+ const code = typeof details?.code === "string" && details.code.length > 0 ? details.code : void 0;
2687
+ const label = code === void 0 ? severity : `${severity} ${code}`;
2688
+ const start = diagnostic_start(details, source);
2689
+ const position = start ? `(${start.line},${start.column + 1})` : "";
2690
+ const key = `${file_name}\0${position}\0${label}\0${message}`;
2650
2691
  if (loggedCompilationFailures.has(key)) continue;
2651
2692
  loggedCompilationFailures.add(key);
2652
- console.error(`[tsrx-tsc] ${file_name}: ${message}`);
2693
+ console.error(`[tsrx-tsc] ${file_name}${position}: ${label}: ${message}`);
2694
+ }
2695
+ }
2696
+ const LINE_BREAK = /\r\n?|[\n\u2028\u2029]/g;
2697
+ /**
2698
+ * Where a diagnostic starts, as a 1-based line and a 0-based column. A
2699
+ * collected error's `loc` is a range, and a parse error acorn throws gives its
2700
+ * position as `loc` itself (`{ line, column }`). A diagnostic without `loc`,
2701
+ * such as one a consumer compiler builds with only `pos` and `end`, is placed
2702
+ * by `pos` in `source`, breaking lines where tsc does.
2703
+ * @param {LoggedDiagnostic | undefined} details
2704
+ * @param {string} source
2705
+ * @returns {{ line: number, column: number } | undefined}
2706
+ */
2707
+ function diagnostic_start(details, source) {
2708
+ const start = details?.loc?.start ?? details?.loc;
2709
+ if (typeof start?.line === "number" && typeof start?.column === "number") return {
2710
+ line: start.line,
2711
+ column: start.column
2712
+ };
2713
+ const pos = details?.pos;
2714
+ if (typeof pos !== "number" || pos < 0 || pos > source.length) return void 0;
2715
+ let line = 1;
2716
+ let line_start = 0;
2717
+ for (const match of source.slice(0, pos).matchAll(LINE_BREAK)) {
2718
+ line++;
2719
+ line_start = match.index + match[0].length;
2653
2720
  }
2721
+ return {
2722
+ line,
2723
+ column: pos - line_start
2724
+ };
2654
2725
  }
2655
2726
  /**
2656
2727
  * Build an embedded virtual code from a `<style>` / `<script>` region produced
@@ -6418,7 +6489,7 @@ var main_exports$1 = /* @__PURE__ */ __exportAll({
6418
6489
  TextDocumentIdentifier: () => TextDocumentIdentifier,
6419
6490
  TextDocumentItem: () => TextDocumentItem,
6420
6491
  TextEdit: () => TextEdit,
6421
- URI: () => URI$4,
6492
+ URI: () => URI$5,
6422
6493
  VersionedTextDocumentIdentifier: () => VersionedTextDocumentIdentifier,
6423
6494
  WorkspaceChange: () => WorkspaceChange,
6424
6495
  WorkspaceEdit: () => WorkspaceEdit,
@@ -6427,7 +6498,7 @@ var main_exports$1 = /* @__PURE__ */ __exportAll({
6427
6498
  integer: () => integer,
6428
6499
  uinteger: () => uinteger
6429
6500
  });
6430
- var DocumentUri, URI$4, integer, uinteger, Position, Range, Location, LocationLink, Color, ColorInformation, ColorPresentation, FoldingRangeKind, FoldingRange, DiagnosticRelatedInformation, DiagnosticSeverity$1, DiagnosticTag, CodeDescription, Diagnostic, Command, TextEdit, ChangeAnnotation, ChangeAnnotationIdentifier, AnnotatedTextEdit, TextDocumentEdit, CreateFile, RenameFile, DeleteFile, WorkspaceEdit, TextEditChangeImpl, SnippetTextEdit, ChangeAnnotations, WorkspaceChange, TextDocumentIdentifier, VersionedTextDocumentIdentifier, OptionalVersionedTextDocumentIdentifier, LanguageKind, TextDocumentItem, MarkupKind, MarkupContent, CompletionItemKind$1, InsertTextFormat$1, CompletionItemTag, InsertReplaceEdit, InsertTextMode, ApplyKind, CompletionItemLabelDetails, CompletionItem, CompletionList, MarkedString, Hover, ParameterInformation, SignatureInformation, DocumentHighlightKind, DocumentHighlight, SymbolKind$1, SymbolTag, SymbolInformation, WorkspaceSymbol, DocumentSymbol, CodeActionKind, CodeActionTriggerKind, CodeActionContext, CodeActionTag, CodeAction, CodeLens, FormattingOptions, DocumentLink, SelectionRange, SemanticTokenTypes, SemanticTokenModifiers, SemanticTokens, InlineValueText, InlineValueVariableLookup, InlineValueEvaluatableExpression, InlineValueContext, InlayHintKind, InlayHintLabelPart, InlayHint, StringValue, InlineCompletionItem, InlineCompletionList, InlineCompletionTriggerKind, SelectedCompletionInfo, InlineCompletionContext, WorkspaceFolder, EOL, TextDocument$1, FullTextDocument$1, Is;
6501
+ var DocumentUri, URI$5, integer, uinteger, Position, Range, Location, LocationLink, Color, ColorInformation, ColorPresentation, FoldingRangeKind, FoldingRange, DiagnosticRelatedInformation, DiagnosticSeverity$1, DiagnosticTag, CodeDescription, Diagnostic, Command, TextEdit, ChangeAnnotation, ChangeAnnotationIdentifier, AnnotatedTextEdit, TextDocumentEdit, CreateFile, RenameFile, DeleteFile, WorkspaceEdit, TextEditChangeImpl, SnippetTextEdit, ChangeAnnotations, WorkspaceChange, TextDocumentIdentifier, VersionedTextDocumentIdentifier, OptionalVersionedTextDocumentIdentifier, LanguageKind, TextDocumentItem, MarkupKind, MarkupContent, CompletionItemKind$1, InsertTextFormat$1, CompletionItemTag, InsertReplaceEdit, InsertTextMode, ApplyKind, CompletionItemLabelDetails, CompletionItem, CompletionList, MarkedString, Hover, ParameterInformation, SignatureInformation, DocumentHighlightKind, DocumentHighlight, SymbolKind$1, SymbolTag, SymbolInformation, WorkspaceSymbol, DocumentSymbol, CodeActionKind, CodeActionTriggerKind, CodeActionContext, CodeActionTag, CodeAction, CodeLens, FormattingOptions, DocumentLink, SelectionRange, SemanticTokenTypes, SemanticTokenModifiers, SemanticTokens, InlineValueText, InlineValueVariableLookup, InlineValueEvaluatableExpression, InlineValueContext, InlayHintKind, InlayHintLabelPart, InlayHint, StringValue, InlineCompletionItem, InlineCompletionList, InlineCompletionTriggerKind, SelectedCompletionInfo, InlineCompletionContext, WorkspaceFolder, EOL, TextDocument$1, FullTextDocument$1, Is;
6431
6502
  var init_main$1 = __esmMin((() => {
6432
6503
  ;
6433
6504
  (function(DocumentUri) {
@@ -6442,7 +6513,7 @@ var init_main$1 = __esmMin((() => {
6442
6513
  return typeof value === "string";
6443
6514
  }
6444
6515
  URI.is = is;
6445
- })(URI$4 || (URI$4 = {}));
6516
+ })(URI$5 || (URI$5 = {}));
6446
6517
  ;
6447
6518
  (function(integer) {
6448
6519
  integer.MIN_VALUE = -2147483648;
@@ -8277,7 +8348,7 @@ var init_main$1 = __esmMin((() => {
8277
8348
  (function(WorkspaceFolder) {
8278
8349
  function is(value) {
8279
8350
  const candidate = value;
8280
- return Is.objectLiteral(candidate) && URI$4.is(candidate.uri) && Is.string(candidate.name);
8351
+ return Is.objectLiteral(candidate) && URI$5.is(candidate.uri) && Is.string(candidate.name);
8281
8352
  }
8282
8353
  WorkspaceFolder.is = is;
8283
8354
  })(WorkspaceFolder || (WorkspaceFolder = {}));
@@ -22683,6 +22754,83 @@ function typescript_notice(found, workspace_dirs) {
22683
22754
  ].join(" ");
22684
22755
  }
22685
22756
 
22757
+ //#endregion
22758
+ //#region ../typescript-plugin/src/unclosed-element.js
22759
+ /** @import * as AST from 'estree' */
22760
+ /**
22761
+ * Elements whose body is raw text, each with a pattern for its opening tag. The
22762
+ * body ends at the next `</style>` or `<\/script>`, wherever it is later in the
22763
+ * file, so that closing tag can belong to a later element (see `isUnclosed`).
22764
+ */
22765
+ const RAW_TEXT_OPENING_TAGS = /* @__PURE__ */ new Map([["style", /<style[\s/>]/], ["script", /<script[\s/>]/]]);
22766
+ /**
22767
+ * An element of the parsed source and, when the element is one of its children,
22768
+ * the element that holds it.
22769
+ * @typedef {{ element: AST.TSRXJSXElement; parent: ElementPath | null }} ElementPath
22770
+ */
22771
+ /**
22772
+ * Find the element whose opening tag ends at `end` in the parsed source.
22773
+ * @param {unknown} node
22774
+ * @param {number} end - The offset right after the opening tag's `>`
22775
+ * @param {ElementPath | null} [parent] - The element whose `children` hold `node`
22776
+ * @returns {ElementPath | null}
22777
+ */
22778
+ function findElement(node, end, parent = null) {
22779
+ if (Array.isArray(node)) {
22780
+ for (const child of node) {
22781
+ const found = findElement(child, end, parent);
22782
+ if (found) return found;
22783
+ }
22784
+ return null;
22785
+ }
22786
+ if (!node || typeof node !== "object") return null;
22787
+ const element = node;
22788
+ const path = element.openingElement ? {
22789
+ element,
22790
+ parent
22791
+ } : null;
22792
+ if (path?.element.openingElement.end === end) return path;
22793
+ for (const [key, value] of Object.entries(node)) {
22794
+ if (key === "loc" || key === "metadata") continue;
22795
+ const found = findElement(value, end, key === "children" ? path : null);
22796
+ if (found) return found;
22797
+ }
22798
+ return null;
22799
+ }
22800
+ /**
22801
+ * Whether the element still needs its closing tag, decided like TypeScript's
22802
+ * `isUnclosedTag`: the element is unclosed, or it took the closing tag of a parent
22803
+ * with the same name (`<div>` typed as the first child of a `<div>`), which is then
22804
+ * the unclosed one. Loose-mode recovery marks an element without its closing tag
22805
+ * `unclosed`.
22806
+ *
22807
+ * A `<style>` or `<script>` body ends at the next closing tag with its name, which
22808
+ * can belong to a later element: a new `<style>` typed in one component takes the
22809
+ * `</style>` of the style block in the next component. That element's opening tag
22810
+ * is then in the body, so the new element still needs its own closing tag.
22811
+ * @param {ElementPath} path
22812
+ * @param {string} sourceCode
22813
+ * @returns {boolean}
22814
+ */
22815
+ function isUnclosed(path, sourceCode) {
22816
+ /** @param {AST.TSRXJSXElement} element */
22817
+ const name = (element) => {
22818
+ const { start, end } = element.openingElement.name;
22819
+ return sourceCode.slice(start, end);
22820
+ };
22821
+ const { element } = path;
22822
+ const rawTextOpeningTag = RAW_TEXT_OPENING_TAGS.get(name(element));
22823
+ if (rawTextOpeningTag) {
22824
+ if (element.unclosed || !element.closingElement) return true;
22825
+ const bodyEnd = element.closingElement.start;
22826
+ return rawTextOpeningTag.test(sourceCode.slice(element.openingElement.end, bodyEnd));
22827
+ }
22828
+ for (let current = path;; current = current.parent) {
22829
+ if (current.element.unclosed) return true;
22830
+ if (!current.parent || name(current.parent.element) !== name(current.element)) return false;
22831
+ }
22832
+ }
22833
+
22686
22834
  //#endregion
22687
22835
  //#region src/autoInsertPlugin.js
22688
22836
  /** @import * as AST from 'estree' */
@@ -22711,12 +22859,6 @@ const VOID_ELEMENTS = /* @__PURE__ */ new Set([
22711
22859
  "wbr"
22712
22860
  ]);
22713
22861
  /**
22714
- * Elements whose body is raw text, each with a pattern for its opening tag. The
22715
- * body ends at the next `</style>` or `<\/script>`, wherever it is later in the
22716
- * file, so that closing tag can belong to a later element (see `isUnclosed`).
22717
- */
22718
- const RAW_TEXT_OPENING_TAGS = /* @__PURE__ */ new Map([["style", /<style[\s/>]/], ["script", /<script[\s/>]/]]);
22719
- /**
22720
22862
  * Auto-insert plugin for TSRX.
22721
22863
  * Handles auto-closing tags when typing '>' after a tag name. The VS Code extension
22722
22864
  * asks for them with Volar's `volar/client/autoInsert` request; other editors get
@@ -22805,73 +22947,6 @@ async provideAutoInsertSnippet(document, position, lastChange, _token) {
22805
22947
  };
22806
22948
  }
22807
22949
  /**
22808
- * An element of the parsed source and, when the element is one of its children,
22809
- * the element that holds it.
22810
- * @typedef {{ element: AST.TSRXJSXElement; parent: ElementPath | null }} ElementPath
22811
- */
22812
- /**
22813
- * Find the element whose opening tag ends at `end` in the parsed source.
22814
- * @param {unknown} node
22815
- * @param {number} end - The offset right after the opening tag's `>`
22816
- * @param {ElementPath | null} [parent] - The element whose `children` hold `node`
22817
- * @returns {ElementPath | null}
22818
- */
22819
- function findElement(node, end, parent = null) {
22820
- if (Array.isArray(node)) {
22821
- for (const child of node) {
22822
- const found = findElement(child, end, parent);
22823
- if (found) return found;
22824
- }
22825
- return null;
22826
- }
22827
- if (!node || typeof node !== "object") return null;
22828
- const element = node;
22829
- const path = element.openingElement ? {
22830
- element,
22831
- parent
22832
- } : null;
22833
- if (path?.element.openingElement.end === end) return path;
22834
- for (const [key, value] of Object.entries(node)) {
22835
- if (key === "loc" || key === "metadata") continue;
22836
- const found = findElement(value, end, key === "children" ? path : null);
22837
- if (found) return found;
22838
- }
22839
- return null;
22840
- }
22841
- /**
22842
- * Whether the element still needs its closing tag, decided like TypeScript's
22843
- * `isUnclosedTag`: the element is unclosed, or it took the closing tag of a parent
22844
- * with the same name (`<div>` typed as the first child of a `<div>`), which is then
22845
- * the unclosed one. Loose-mode recovery marks an element without its closing tag
22846
- * `unclosed`.
22847
- *
22848
- * A `<style>` or `<script>` body ends at the next closing tag with its name, which
22849
- * can belong to a later element: a new `<style>` typed in one component takes the
22850
- * `</style>` of the style block in the next component. That element's opening tag
22851
- * is then in the body, so the new element still needs its own closing tag.
22852
- * @param {ElementPath} path
22853
- * @param {string} sourceCode
22854
- * @returns {boolean}
22855
- */
22856
- function isUnclosed(path, sourceCode) {
22857
- /** @param {AST.TSRXJSXElement} element */
22858
- const name = (element) => {
22859
- const { start, end } = element.openingElement.name;
22860
- return sourceCode.slice(start, end);
22861
- };
22862
- const { element } = path;
22863
- const rawTextOpeningTag = RAW_TEXT_OPENING_TAGS.get(name(element));
22864
- if (rawTextOpeningTag) {
22865
- if (element.unclosed || !element.closingElement) return true;
22866
- const bodyEnd = element.closingElement.start;
22867
- return rawTextOpeningTag.test(sourceCode.slice(element.openingElement.end, bodyEnd));
22868
- }
22869
- for (let current = path;; current = current.parent) {
22870
- if (current.element.unclosed) return true;
22871
- if (!current.parent || name(current.parent.element) !== name(current.element)) return false;
22872
- }
22873
- }
22874
- /**
22875
22950
  * Escape `text` so that a snippet inserts it as written. `\`, `$` and `}` are snippet
22876
22951
  * syntax: unescaped, the `$Foo` in `</$Foo>` is a variable, which VS Code replaces
22877
22952
  * with nothing.
@@ -23055,7 +23130,7 @@ function parseCompilationErrorWithDocument(error, virtualCode, sourceMap, docume
23055
23130
  let start = null;
23056
23131
  /** @type {Position | null} */
23057
23132
  let end = null;
23058
- if (error.pos) {
23133
+ if (error.pos !== void 0) {
23059
23134
  const start_offset = get_start_offset_from_error(error);
23060
23135
  const end_offset = get_end_offset_from_error(error, start_offset);
23061
23136
  const mapping = virtualCode.findMappingBySourceRange(start_offset, end_offset);
@@ -23076,6 +23151,13 @@ function parseCompilationErrorWithDocument(error, virtualCode, sourceMap, docume
23076
23151
  }
23077
23152
  }
23078
23153
  }
23154
+ if (!start || !end) {
23155
+ const nearest = nearest_reported_range(virtualCode, start_offset, error.raisedAt);
23156
+ if (nearest) {
23157
+ start = document.positionAt(nearest[0]);
23158
+ end = document.positionAt(nearest[1]);
23159
+ }
23160
+ }
23079
23161
  }
23080
23162
  if (!start || !end) {
23081
23163
  start = {
@@ -23088,7 +23170,7 @@ function parseCompilationErrorWithDocument(error, virtualCode, sourceMap, docume
23088
23170
  };
23089
23171
  }
23090
23172
  return {
23091
- severity: import_language_server.DiagnosticSeverity.Error,
23173
+ severity: error.severity === "warning" ? import_language_server.DiagnosticSeverity.Warning : import_language_server.DiagnosticSeverity.Error,
23092
23174
  range: {
23093
23175
  start,
23094
23176
  end
@@ -23099,6 +23181,56 @@ function parseCompilationErrorWithDocument(error, virtualCode, sourceMap, docume
23099
23181
  };
23100
23182
  }
23101
23183
  /**
23184
+ * The generated range of the source token that reports diagnostics and starts
23185
+ * nearest after `offset`, when it starts before `reach`. Otherwise the one that
23186
+ * ends nearest before `offset`, or starts nearest after it when none ends
23187
+ * before it. Of tokens the same distance away, the shortest. A mapping over
23188
+ * whitespace only, such as the indentation before a template's output, is not
23189
+ * code to show the error on.
23190
+ * @param {TSRXVirtualCodeInstance} virtualCode
23191
+ * @param {number} offset
23192
+ * @param {number} [reach] Where the error's parser stopped, such as the token that ended a template
23193
+ * @returns {[number, number] | null}
23194
+ */
23195
+ function nearest_reported_range(virtualCode, offset, reach = offset) {
23196
+ /** @type {{ range: [number, number], distance: number, length: number } | null} */
23197
+ let before = null;
23198
+ /** @type {{ range: [number, number], distance: number, length: number, start: number } | null} */
23199
+ let after = null;
23200
+ for (const mapping of virtualCode.mappings ?? []) {
23201
+ if (!mapping.data?.verification) continue;
23202
+ for (let i = 0; i < mapping.sourceOffsets.length; i++) {
23203
+ const source_start = mapping.sourceOffsets[i];
23204
+ const length = mapping.lengths[i];
23205
+ const generated_length = mapping.generatedLengths?.[i] ?? length;
23206
+ if (length === 0 || generated_length <= 0) continue;
23207
+ if (!/\S/.test(virtualCode.originalCode.slice(source_start, source_start + length))) continue;
23208
+ const generated_start = mapping.generatedOffsets[i];
23209
+ const ends_before = source_start + length <= offset;
23210
+ if (!ends_before && source_start < offset) continue;
23211
+ const candidate = {
23212
+ /** @type {[number, number]} */
23213
+ range: [generated_start, generated_start + generated_length],
23214
+ distance: ends_before ? offset - (source_start + length) : source_start - offset,
23215
+ length,
23216
+ start: source_start
23217
+ };
23218
+ if (ends_before) {
23219
+ if (is_nearer(candidate, before)) before = candidate;
23220
+ } else if (is_nearer(candidate, after)) after = candidate;
23221
+ }
23222
+ }
23223
+ if (after && after.start < reach) return after.range;
23224
+ return (before ?? after)?.range ?? null;
23225
+ }
23226
+ /**
23227
+ * @param {{ distance: number, length: number }} candidate
23228
+ * @param {{ distance: number, length: number } | null} best
23229
+ */
23230
+ function is_nearer(candidate, best) {
23231
+ return !best || candidate.distance < best.distance || candidate.distance === best.distance && candidate.length < best.length;
23232
+ }
23233
+ /**
23102
23234
  * @param {CompileError} error
23103
23235
  * @param {TextDocument} document
23104
23236
  * @returns {Range}
@@ -23999,6 +24131,14 @@ init_main();
23999
24131
  * }} NodeWithId;
24000
24132
  */
24001
24133
  /**
24134
+ * A raw-text `<script>` element, its body verbatim in `content`.
24135
+ * @typedef {{
24136
+ * openingElement: { name: { start: number, end: number }, end: number },
24137
+ * closingElement: { name: { end: number } } | null,
24138
+ * content: string,
24139
+ * }} ScriptElement;
24140
+ */
24141
+ /**
24002
24142
  * @typedef {[
24003
24143
  * Omit<DocumentSymbol, 'children'> & { children: SymbolInfo[] }, {
24004
24144
  * rangeNode: AST.Node;
@@ -24031,7 +24171,7 @@ function createDocumentSymbolPlugin() {
24031
24171
  if (virtualCode?.fatalErrors?.length || virtualCode?.isDotCompletionMode) return collectFallbackDocumentSymbols(document, fallbackFileName) ?? cachedSymbols;
24032
24172
  if (!sourceMap || !sourceAst) return collectFallbackDocumentSymbols(document, fallbackFileName) ?? [];
24033
24173
  const sourceDocument = TextDocument.create(sourceUri.toString(), "tsrx", 0, originalCode);
24034
- const symbols = mapDocumentSymbolsToGenerated(collectDocumentSymbols(sourceAst, sourceDocument), virtualCode, sourceDocument, document, sourceMap);
24174
+ const symbols = mapDocumentSymbolsToGenerated(collectDocumentSymbols(sourceAst, sourceDocument, virtualCode.scriptRegions), virtualCode, sourceDocument, document, sourceMap);
24035
24175
  documentSymbolCache.set(cacheKey, symbols);
24036
24176
  return symbols;
24037
24177
  } };
@@ -24172,10 +24312,70 @@ function isSymbolMapping(data) {
24172
24312
  /**
24173
24313
  * @param {AST.Program} ast
24174
24314
  * @param {TextDocument} document
24315
+ * @param {Array<{ start: number, content: string }>} [scriptRegions] The `<script>` bodies of
24316
+ * code, from the compiler's script mappings.
24175
24317
  * @returns {SymbolInfo[]}
24176
24318
  */
24177
- function collectDocumentSymbols(ast, document) {
24178
- return collectSymbolsFromStatements(Array.isArray(ast.body) ? ast.body : [], document);
24319
+ function collectDocumentSymbols(ast, document, scriptRegions = []) {
24320
+ const symbols = collectSymbolsFromStatements(Array.isArray(ast.body) ? ast.body : [], document);
24321
+ if (scriptRegions.length > 0) {
24322
+ const elements = findScriptElements(ast);
24323
+ for (const region of scriptRegions) {
24324
+ const element = elements.get(region.start);
24325
+ if (element) symbols.push(createScriptSymbol(element, region, document));
24326
+ }
24327
+ }
24328
+ return symbols.sort(([, a], [, b]) => a.rangeNode.start - b.rangeNode.start);
24329
+ }
24330
+ /**
24331
+ * The `<script>` elements of a source AST, by the offset where their body starts (the end of
24332
+ * the opening tag), which is where the compiler's script regions start.
24333
+ * @param {AST.Node} ast
24334
+ * @returns {Map<number, ScriptElement>}
24335
+ */
24336
+ function findScriptElements(ast) {
24337
+ /** @type {Map<number, ScriptElement>} */
24338
+ const elements = /* @__PURE__ */ new Map();
24339
+ /** @param {any} node */
24340
+ const visit = (node) => {
24341
+ if (node.type === "JSXElement" && node.openingElement?.name?.type === "JSXIdentifier" && node.openingElement.name.name === "script" && typeof node.content === "string") elements.set(node.openingElement.end, node);
24342
+ for (const key in node) {
24343
+ if (key === "loc" || key === "metadata" || key === "css") continue;
24344
+ const value = node[key];
24345
+ for (const child of Array.isArray(value) ? value : [value]) if (child && typeof child === "object" && typeof child.type === "string") visit(child);
24346
+ }
24347
+ };
24348
+ visit(ast);
24349
+ return elements;
24350
+ }
24351
+ /**
24352
+ * A `<script>` symbol spanning the element from its tag name to its closing tag name (the
24353
+ * parts of it that map to the generated TSX), selected by the opening tag's name, with the
24354
+ * top-level declarations of its body as children. The transform appends each body to the
24355
+ * generated TSX as a bare block, which TypeScript's navigation tree skips, so the body is
24356
+ * parsed here, where it stands in the source: the rest of the file is blanked, which keeps
24357
+ * every offset a source offset.
24358
+ * @param {ScriptElement} element
24359
+ * @param {{ start: number, content: string }} region
24360
+ * @param {TextDocument} document
24361
+ * @returns {SymbolInfo}
24362
+ */
24363
+ function createScriptSymbol(element, region, document) {
24364
+ /** @type {AST.Node[]} */
24365
+ let statements = [];
24366
+ try {
24367
+ const blanked = document.getText().slice(0, region.start).replace(/[^\r\n]/g, " ") + region.content;
24368
+ statements = (0, _tsrx_core.parseModule)(blanked, document.uri, { loose: true }).body;
24369
+ } catch (error) {
24370
+ logError$3(`Unable to read a <script> body: ${/** @type {Error} */ error.message}`);
24371
+ }
24372
+ const name = element.openingElement.name;
24373
+ const range = {
24374
+ type: "JSXElement",
24375
+ start: name.start,
24376
+ end: element.closingElement?.name.end ?? region.start + region.content.length
24377
+ };
24378
+ return createNamedNodeSymbol("<script>", import_language_server.SymbolKind.Module, range, name, document, collectSymbolsFromStatements(statements, document));
24179
24379
  }
24180
24380
  /**
24181
24381
  * @param {AST.Node[]} statements
@@ -24233,6 +24433,9 @@ function createSymbolForDeclaration(node, document, fallbackName) {
24233
24433
  case "TSTypeAliasDeclaration":
24234
24434
  if (!id || !name) return [];
24235
24435
  return [createNamedNodeSymbol(name, import_language_server.SymbolKind.TypeParameter, node, id, document)];
24436
+ case "TSEnumDeclaration":
24437
+ if (!id || !name) return [];
24438
+ return [createNamedNodeSymbol(name, import_language_server.SymbolKind.Enum, node, id, document)];
24236
24439
  default: return [];
24237
24440
  }
24238
24441
  }
@@ -24629,6 +24832,74 @@ function createTypeScriptDiagnosticFilterPlugin() {
24629
24832
  };
24630
24833
  }
24631
24834
 
24835
+ //#endregion
24836
+ //#region ../typescript-plugin/src/module-format.js
24837
+ /**
24838
+ * The module format (`impliedNodeFormat`) of `.tsrx` files. TypeScript derives a
24839
+ * file's format from its extension, and knows none for `.tsrx`, so under
24840
+ * `node16`/`nodenext` it treats every `.tsrx` file as CommonJS: `import.meta`
24841
+ * reports TS1470 even in a `"type": "module"` package. Volar's
24842
+ * `fixupImpliedNodeFormatForFile` sets the format only while it resolves the
24843
+ * file's imports, and resets it afterwards.
24844
+ *
24845
+ * A `.tsrx` file takes the format a `.ts` file at the same path would have:
24846
+ * from the `type` of the nearest `package.json` under `node16`/`nodenext` (or in
24847
+ * `node_modules`), and none otherwise. TSRX has no `.mtsrx`/`.ctsrx`
24848
+ * counterparts of `.mts`/`.cts`. The format goes into the options TypeScript
24849
+ * creates the source file with, so the source file's external-module status, the
24850
+ * document registry's key and the `package.json` TypeScript watches all match it.
24851
+ */
24852
+ /**
24853
+ * Fill in the module format of a `.tsrx` file in the options TypeScript is about
24854
+ * to create its source file with, as TypeScript fills it in for a `.ts` file.
24855
+ * Options that already carry a format, and other files, are left alone.
24856
+ * @param {typeof import('typescript')} ts
24857
+ * @param {string} file_name
24858
+ * @param {unknown} source_file_options The `languageVersionOrOptions` of `getSourceFile`.
24859
+ * @param {import('typescript').PackageJsonInfoCache | undefined} package_json_info_cache
24860
+ * @param {import('typescript').ModuleResolutionHost} host
24861
+ * @param {import('typescript').CompilerOptions} compiler_options
24862
+ */
24863
+ function fill_tsrx_module_format(ts, file_name, source_file_options, package_json_info_cache, host, compiler_options) {
24864
+ if (typeof source_file_options !== "object" || source_file_options === null || source_file_options.impliedNodeFormat !== void 0 || !is_tsrx_file(file_name)) return;
24865
+ const worker = ts.getImpliedNodeFormatForFileWorker;
24866
+ const format = worker ? worker(`${file_name}.ts`, package_json_info_cache, host, compiler_options) : ts.getImpliedNodeFormatForFile?.(`${file_name}.ts`, package_json_info_cache, host, compiler_options);
24867
+ if (typeof format === "object" && format !== null) Object.assign(source_file_options, format);
24868
+ else if (format !== void 0)
24869
+ /** @type {import('typescript').CreateSourceFileOptions} */ source_file_options.impliedNodeFormat = format;
24870
+ }
24871
+ /** @type {WeakSet<object>} */
24872
+ const patched = /* @__PURE__ */ new WeakSet();
24873
+ /**
24874
+ * Language services (tsserver, the language server): fill in the module format
24875
+ * of each `.tsrx` document the registry creates or updates. The language
24876
+ * service passes the options the program computed, and the registry keys its
24877
+ * entries by their format, so it has to be set before the registry sees them.
24878
+ * @param {typeof import('typescript')} ts
24879
+ * @param {import('typescript').DocumentRegistry} registry
24880
+ * @returns {import('typescript').DocumentRegistry}
24881
+ */
24882
+ function with_tsrx_module_format_in_registry(ts, registry) {
24883
+ if (patched.has(registry)) return registry;
24884
+ patched.add(registry);
24885
+ for (const method of ["acquireDocumentWithKey", "updateDocumentWithKey"]) {
24886
+ const original = registry[method];
24887
+ /** @type {any} */ registry[method] = (file_name, path, host, key, snapshot, version, script_kind, source_file_options) => {
24888
+ fill_tsrx_module_format(
24889
+ ts,
24890
+ file_name,
24891
+ source_file_options,
24892
+ /** @type {any} */
24893
+ host.getModuleResolutionCache?.()?.getPackageJsonInfoCache(),
24894
+ host,
24895
+ host.getCompilationSettings()
24896
+ );
24897
+ return original.call(registry, file_name, path, host, key, snapshot, version, script_kind, source_file_options);
24898
+ };
24899
+ }
24900
+ return registry;
24901
+ }
24902
+
24632
24903
  //#endregion
24633
24904
  //#region src/typescriptService.js
24634
24905
  /**
@@ -24670,7 +24941,19 @@ function load_typescript_service() {
24670
24941
  * @returns {ReturnType<typeof import('volar-service-typescript').create>}
24671
24942
  */
24672
24943
  function createTypeScriptServices(ts) {
24673
- return load_typescript_service().create(ts);
24944
+ return load_typescript_service().create(with_tsrx_document_registries(ts));
24945
+ }
24946
+ /**
24947
+ * `ts` for `volar-service-typescript`, whose language services get each `.tsrx`
24948
+ * document's module format from their document registry
24949
+ * (`with_tsrx_module_format_in_registry`). The service creates the registries
24950
+ * itself, and the module's exports are read-only getters, so the override sits
24951
+ * on an object that inherits everything else from `ts`.
24952
+ * @param {typeof import('typescript')} ts
24953
+ * @returns {typeof import('typescript')}
24954
+ */
24955
+ function with_tsrx_document_registries(ts) {
24956
+ return Object.create(ts, { createDocumentRegistry: { value: (...args) => with_tsrx_module_format_in_registry(ts, ts.createDocumentRegistry(...args)) } });
24674
24957
  }
24675
24958
 
24676
24959
  //#endregion
@@ -24708,6 +24991,26 @@ function stripFormatting(plugin) {
24708
24991
  };
24709
24992
  }
24710
24993
  /**
24994
+ * Strip the folding capability from a Volar service plugin.
24995
+ *
24996
+ * Volar runs service plugins on the generated TS and CSS, and keeps the folds whose ends
24997
+ * map back to the `.tsrx` source: the CSS service's folds in `<style>` blocks do, but none
24998
+ * of TypeScript's. The server folds `.tsrx` sources itself (`foldingRangeHandler.js`) and
24999
+ * adds the folds Volar maps back: a plugin that offered folding ranges would make Volar
25000
+ * register its own `textDocument/foldingRange` handler, which would replace that one.
25001
+ *
25002
+ * @template {{ capabilities?: Record<string, unknown> }} T
25003
+ * @param {T} plugin
25004
+ * @returns {T}
25005
+ */
25006
+ function stripFoldingRanges(plugin) {
25007
+ const { foldingRangeProvider: _folding, ...capabilities } = plugin.capabilities ?? {};
25008
+ return {
25009
+ ...plugin,
25010
+ capabilities
25011
+ };
25012
+ }
25013
+ /**
24711
25014
  * The Volar service plugins for a backend, in registration order.
24712
25015
  *
24713
25016
  * Classic: the TypeScript services run in this process and the TSRX
@@ -24733,7 +25036,7 @@ function createServicePlugins(backend, ts) {
24733
25036
  const shared_last = [
24734
25037
  createDefinitionPlugin(),
24735
25038
  createDocumentSymbolPlugin(),
24736
- stripFormatting((0, volar_service_css.create)())
25039
+ stripFoldingRanges(stripFormatting((0, volar_service_css.create)()))
24737
25040
  ];
24738
25041
  if (backend === "native" || backend === "plugin") return [
24739
25042
  ...shared_first,
@@ -24747,7 +25050,7 @@ function createServicePlugins(backend, ts) {
24747
25050
  ...shared_first,
24748
25051
  createCompileErrorDiagnosticPlugin(),
24749
25052
  ...shared_last,
24750
- ...createTypeScriptServices(ts).map(stripFormatting),
25053
+ ...createTypeScriptServices(ts).map((plugin) => stripFoldingRanges(stripFormatting(plugin))),
24751
25054
  createTypeScriptDiagnosticFilterPlugin(),
24752
25055
  createHoverPlugin({ typescriptBackend: backend }),
24753
25056
  createDocumentHighlightPlugin({ typescriptBackend: backend })
@@ -25111,8 +25414,429 @@ async function closing_tags_enabled(connection, uri) {
25111
25414
  }
25112
25415
  }
25113
25416
 
25417
+ //#endregion
25418
+ //#region src/foldingRangeHandler.js
25419
+ /** @import * as AST from 'estree' */
25420
+ /** @import { Connection, FoldingRange, LanguageServer } from '@volar/language-server' */
25421
+ /**
25422
+ * A fold that ends on one of these keeps the line holding it visible: the closing `}`,
25423
+ * `</div>`, `)` or `` ` ``, as VS Code's TypeScript folds TSX.
25424
+ */
25425
+ const CLOSING_CHARACTERS = /* @__PURE__ */ new Set([
25426
+ "}",
25427
+ "]",
25428
+ ")",
25429
+ "`",
25430
+ ">"
25431
+ ]);
25432
+ /** TypeScript's region markers: `// #region name` and `// #endregion`. */
25433
+ const REGION_MARKER = /^#(end)?region/;
25434
+ /** Keys that hold no child nodes, or nodes whose offsets are not source offsets. */
25435
+ const SKIPPED_KEYS = /* @__PURE__ */ new Set([
25436
+ "loc",
25437
+ "metadata",
25438
+ "css",
25439
+ "leadingComments",
25440
+ "trailingComments",
25441
+ "innerComments"
25442
+ ]);
25443
+ /** Statements whose body block folds from the end of the line that opens it. */
25444
+ const ATTACHED_BLOCK_PARENTS = /* @__PURE__ */ new Set([
25445
+ "IfStatement",
25446
+ "ForStatement",
25447
+ "ForInStatement",
25448
+ "ForOfStatement",
25449
+ "WhileStatement",
25450
+ "DoWhileStatement",
25451
+ "WithStatement",
25452
+ "TryStatement",
25453
+ "CatchClause",
25454
+ "SwitchCase",
25455
+ "JSXIfExpression",
25456
+ "JSXForExpression",
25457
+ "JSXTryExpression"
25458
+ ]);
25459
+ const FUNCTION_TYPES = /* @__PURE__ */ new Set([
25460
+ "FunctionDeclaration",
25461
+ "FunctionExpression",
25462
+ "ArrowFunctionExpression"
25463
+ ]);
25464
+ /**
25465
+ * Answer `textDocument/foldingRange` for `.tsrx` files with folds computed from the TSRX
25466
+ * source, merged with the folds Volar's service plugins map back from embedded code (the CSS
25467
+ * of `<style>` blocks). Volar's own handler would only return the mapped ones: TypeScript's
25468
+ * folds on the generated code do not map back, and neither VS Code's TypeScript (whose
25469
+ * tsserver plugin answers no outlining spans for `.tsrx` files) nor TypeScript 7 folds
25470
+ * `.tsrx` files. No Volar service plugin offers folding ranges (`stripFoldingRanges` in
25471
+ * `servicePlugins.js`), so Volar registers no handler that would replace this one.
25472
+ * @param {Connection} connection
25473
+ * @param {LanguageServer} server
25474
+ */
25475
+ function register_folding_ranges(connection, server) {
25476
+ connection.onFoldingRanges(async (params, token) => {
25477
+ const uri = vscode_uri.URI.parse(params.textDocument.uri);
25478
+ const embedded = await (await server.project.getLanguageService(uri)).getFoldingRanges(uri, token) ?? [];
25479
+ if (token.isCancellationRequested) return null;
25480
+ const document = server.documents.get(uri);
25481
+ if (!document || !is_tsrx_document(params.textDocument.uri)) return embedded;
25482
+ return merge_folding_ranges([...collect_folding_ranges(document.getText(), uri.fsPath), ...embedded]);
25483
+ });
25484
+ }
25485
+ /**
25486
+ * The folds of a `.tsrx` source, following the folds TypeScript gives TSX: functions and
25487
+ * other blocks, `@{ ... }` bodies, each directive body and clause (`@else`, `@empty`,
25488
+ * `@case`, `@catch`, `@pending`), multi-line elements and `<style>` blocks, objects, arrays,
25489
+ * multi-line calls, template strings, groups of imports, comments and `// #region` markers.
25490
+ * While the source does not parse, folds follow indentation and region markers.
25491
+ * @param {string} text
25492
+ * @param {string} file_name
25493
+ * @returns {FoldingRange[]}
25494
+ */
25495
+ function collect_folding_ranges(text, file_name) {
25496
+ const line_starts = [0];
25497
+ for (const match of text.matchAll(/\r\n|\r|\n/g)) line_starts.push(
25498
+ /** @type {number} */
25499
+ match.index + match[0].length
25500
+ );
25501
+ /** @param {number} offset */
25502
+ const line_of = (offset) => {
25503
+ let low = 0;
25504
+ let high = line_starts.length - 1;
25505
+ while (low < high) {
25506
+ const middle = low + high + 1 >> 1;
25507
+ if (line_starts[middle] <= offset) low = middle;
25508
+ else high = middle - 1;
25509
+ }
25510
+ return low;
25511
+ };
25512
+ /**
25513
+ * The start of each comment, by the offset where it ends, and its end by its start.
25514
+ * @type {Map<number, number>}
25515
+ */
25516
+ const comment_starts = /* @__PURE__ */ new Map();
25517
+ /** @type {Map<number, number>} */
25518
+ const comment_ends = /* @__PURE__ */ new Map();
25519
+ /**
25520
+ * The offset of the first `character` from `offset` on, outside comments, or -1.
25521
+ * @param {string} character
25522
+ * @param {number} offset
25523
+ */
25524
+ const find_after = (character, offset) => {
25525
+ let index = offset;
25526
+ while (index < text.length) {
25527
+ const comment_end = comment_ends.get(index);
25528
+ if (comment_end !== void 0) index = comment_end;
25529
+ else if (text[index] === character) return index;
25530
+ else index++;
25531
+ }
25532
+ return -1;
25533
+ };
25534
+ /**
25535
+ * The line of the token before `offset`, past blanks and comments, where a block opened on
25536
+ * a line of its own still folds from the line that opens it.
25537
+ * @param {number} offset
25538
+ */
25539
+ const previous_token_line = (offset) => {
25540
+ let index = offset - 1;
25541
+ while (index > 0) {
25542
+ const comment_start = comment_starts.get(index + 1);
25543
+ if (comment_start !== void 0) index = comment_start - 1;
25544
+ else if (/\s/.test(text[index])) index--;
25545
+ else break;
25546
+ }
25547
+ return line_of(Math.max(index, 0));
25548
+ };
25549
+ /** @type {FoldingRange[]} */
25550
+ const ranges = [];
25551
+ /**
25552
+ * @param {number} start_line
25553
+ * @param {number} end Offset after the last folded character.
25554
+ * @param {FoldingRange['kind']} [kind] Comment and region folds end where their text ends.
25555
+ */
25556
+ const fold = (start_line, end, kind) => {
25557
+ let end_line = line_of(end - 1);
25558
+ if (!kind && CLOSING_CHARACTERS.has(text[end - 1])) end_line--;
25559
+ if (end_line > start_line) ranges.push(kind ? {
25560
+ startLine: start_line,
25561
+ endLine: end_line,
25562
+ kind
25563
+ } : {
25564
+ startLine: start_line,
25565
+ endLine: end_line
25566
+ });
25567
+ };
25568
+ /** @type {AST.CommentWithLocation[]} */
25569
+ const comments = [];
25570
+ /** @type {AST.Program} */
25571
+ let ast;
25572
+ try {
25573
+ ast = (0, _tsrx_core.parseModule)(text, file_name, {
25574
+ loose: true,
25575
+ preserveParens: true,
25576
+ comments
25577
+ });
25578
+ } catch {
25579
+ return merge_folding_ranges(fallback_folding_ranges(text));
25580
+ }
25581
+ for (const comment of comments) {
25582
+ comment_starts.set(comment.end, comment.start);
25583
+ comment_ends.set(comment.start, comment.end);
25584
+ }
25585
+ /**
25586
+ * @param {any} node
25587
+ * @param {any} parent
25588
+ */
25589
+ const visit = (node, parent) => {
25590
+ switch (node.type) {
25591
+ case "Program":
25592
+ fold_import_groups(node.body);
25593
+ break;
25594
+ case "BlockStatement":
25595
+ case "JSXCodeBlock":
25596
+ if (FUNCTION_TYPES.has(parent?.type) && parent.body === node) fold(function_start_line(parent), node.end);
25597
+ else if (ATTACHED_BLOCK_PARENTS.has(parent?.type)) fold(previous_token_line(node.start), node.end);
25598
+ else fold(line_of(node.start), node.end);
25599
+ break;
25600
+ case "ClassBody":
25601
+ case "TSInterfaceBody":
25602
+ case "TSEnumBody":
25603
+ case "TSModuleBlock":
25604
+ fold(previous_token_line(node.start), node.end);
25605
+ break;
25606
+ case "SwitchStatement":
25607
+ case "JSXSwitchExpression":
25608
+ fold(previous_token_line(find_after("{", node.discriminant.end)), node.end);
25609
+ break;
25610
+ case "StaticBlock":
25611
+ fold(line_of(find_after("{", node.start)), node.end);
25612
+ break;
25613
+ case "SwitchCase":
25614
+ if (Array.isArray(node.consequent) && node.consequent.length > 0) fold(line_of(node.test?.end ?? node.start), node.consequent.at(-1).end);
25615
+ break;
25616
+ case "ObjectExpression":
25617
+ case "ArrayExpression":
25618
+ case "ObjectPattern":
25619
+ case "ArrayPattern":
25620
+ case "TSTypeLiteral":
25621
+ case "TSTupleType":
25622
+ fold(parent?.type === "ArrayExpression" || parent?.type === "CallExpression" ? line_of(node.start) : previous_token_line(node.start), node.end);
25623
+ break;
25624
+ case "CallExpression":
25625
+ if (node.arguments.length > 0) fold(previous_token_line(find_after("(", node.typeArguments?.end ?? node.callee.end)), node.end);
25626
+ break;
25627
+ case "ArrowFunctionExpression":
25628
+ if (node.body.type !== "BlockStatement" && node.body.type !== "JSXCodeBlock" && node.body.type !== "ParenthesizedExpression") fold(previous_token_line(node.body.start), node.body.end);
25629
+ break;
25630
+ case "ImportDeclaration":
25631
+ case "ExportNamedDeclaration":
25632
+ case "ExportAllDeclaration":
25633
+ fold_braces((node.specifiers ?? []).filter((specifier) => specifier.type === "ImportSpecifier" || specifier.type === "ExportSpecifier"));
25634
+ fold_braces(node.attributes ?? []);
25635
+ break;
25636
+ case "JSXOpeningElement":
25637
+ if (node.attributes.length > 0) fold(line_of(node.attributes[0].start), node.attributes.at(-1).end);
25638
+ break;
25639
+ case "JSXElement":
25640
+ case "JSXStyleElement":
25641
+ if (node.closingElement) fold(line_of(node.start), node.end);
25642
+ break;
25643
+ case "TemplateLiteral":
25644
+ case "ParenthesizedExpression":
25645
+ case "JSXFragment": fold(line_of(node.start), node.end);
25646
+ }
25647
+ for (const key in node) {
25648
+ if (SKIPPED_KEYS.has(key)) continue;
25649
+ const value = node[key];
25650
+ if (Array.isArray(value)) {
25651
+ for (const child of value) if (is_node(child)) visit(child, node);
25652
+ } else if (is_node(value)) visit(value, node);
25653
+ }
25654
+ };
25655
+ /**
25656
+ * A function folds from its `(` when its parameters span lines, else from its body's `{`.
25657
+ * @param {any} node
25658
+ */
25659
+ const function_start_line = (node) => {
25660
+ if (node.params.length > 0) {
25661
+ const open = previous_token_line(node.params[0].start);
25662
+ if (open !== line_of(node.params.at(-1).end)) return open;
25663
+ }
25664
+ return previous_token_line(node.body.start);
25665
+ };
25666
+ /**
25667
+ * Two or more imports in a row fold together.
25668
+ * @param {AST.Node[]} statements
25669
+ */
25670
+ const fold_import_groups = (statements) => {
25671
+ let first = 0;
25672
+ while (first < statements.length) {
25673
+ let last = first;
25674
+ while (last < statements.length && is_import(statements[last])) last++;
25675
+ if (last - first > 1) fold(
25676
+ line_of(
25677
+ /** @type {any} */
25678
+ statements[first].start
25679
+ ),
25680
+ /** @type {any} */
25681
+ statements[last - 1].end,
25682
+ "imports"
25683
+ );
25684
+ first = last + 1;
25685
+ }
25686
+ };
25687
+ /**
25688
+ * The braces around `elements`: the names of `import { a, b } from` and `export { a, b }`,
25689
+ * and import attributes (`with { type: 'json' }`).
25690
+ * @param {any[]} elements
25691
+ */
25692
+ const fold_braces = (elements) => {
25693
+ if (elements.length === 0) return;
25694
+ const close = find_after("}", elements.at(-1).end);
25695
+ if (close !== -1) fold(previous_token_line(elements[0].start), close + 1);
25696
+ };
25697
+ visit(ast, null);
25698
+ fold_comments(comments, text, line_of, (offset) => /^[ \t]*$/.test(text.slice(line_starts[line_of(offset)], offset)), fold);
25699
+ return merge_folding_ranges(ranges);
25700
+ }
25701
+ /**
25702
+ * Multi-line block comments, runs of two or more line comments each on a line of its own,
25703
+ * and `// #region` ... `// #endregion` pairs.
25704
+ * @param {AST.CommentWithLocation[]} comments
25705
+ * @param {string} text
25706
+ * @param {(offset: number) => number} line_of
25707
+ * @param {(offset: number) => boolean} first_on_line Whether only blanks precede `offset` on
25708
+ * its line.
25709
+ * @param {(start_line: number, end: number, kind: FoldingRange['kind']) => void} fold
25710
+ */
25711
+ function fold_comments(comments, text, line_of, first_on_line, fold) {
25712
+ /** @type {number[]} */
25713
+ const regions = [];
25714
+ /** @type {AST.CommentWithLocation | null} */
25715
+ let first = null;
25716
+ /** @type {AST.CommentWithLocation | null} */
25717
+ let last = null;
25718
+ const end_run = () => {
25719
+ if (first && last && first !== last) fold(line_of(first.start), last.end, "comment");
25720
+ first = last = null;
25721
+ };
25722
+ for (const comment of comments) {
25723
+ const own_line = comment.type === "Line" && first_on_line(comment.start);
25724
+ const region = own_line ? REGION_MARKER.exec(comment.value.trim()) : null;
25725
+ if (region || !own_line || last && /\S/.test(text.slice(last.end, comment.start))) end_run();
25726
+ if (region) {
25727
+ if (!region[1]) regions.push(line_of(comment.start));
25728
+ else if (regions.length > 0) fold(regions.pop(), comment.end, "region");
25729
+ } else if (own_line) {
25730
+ first ??= comment;
25731
+ last = comment;
25732
+ } else if (comment.type === "Block") fold(line_of(comment.start), comment.end, "comment");
25733
+ }
25734
+ end_run();
25735
+ }
25736
+ /**
25737
+ * Folds by indentation, the way VS Code folds a file no provider folds, plus region markers.
25738
+ * @param {string} text
25739
+ * @returns {FoldingRange[]}
25740
+ */
25741
+ function fallback_folding_ranges(text) {
25742
+ const lines = text.split(/\r\n|\r|\n/);
25743
+ /** @type {FoldingRange[]} */
25744
+ const ranges = [];
25745
+ /** @type {Array<{ indent: number, end_above: number }>} */
25746
+ const open = [{
25747
+ indent: -1,
25748
+ end_above: lines.length
25749
+ }];
25750
+ for (let line = lines.length - 1; line >= 0; line--) {
25751
+ const indent = indent_of(lines[line]);
25752
+ if (indent === -1) continue;
25753
+ let previous = open[open.length - 1];
25754
+ if (previous.indent > indent) {
25755
+ do {
25756
+ open.pop();
25757
+ previous = open[open.length - 1];
25758
+ } while (previous.indent > indent);
25759
+ if (previous.end_above - 1 > line) ranges.push({
25760
+ startLine: line,
25761
+ endLine: previous.end_above - 1
25762
+ });
25763
+ }
25764
+ if (previous.indent === indent) previous.end_above = line;
25765
+ else open.push({
25766
+ indent,
25767
+ end_above: line
25768
+ });
25769
+ }
25770
+ /** @type {number[]} */
25771
+ const regions = [];
25772
+ for (const [line, content] of lines.entries()) {
25773
+ const region = /^\s*\/\/(.*)$/.exec(content);
25774
+ const marker = region && REGION_MARKER.exec(region[1].trim());
25775
+ if (!marker) continue;
25776
+ if (!marker[1]) regions.push(line);
25777
+ else if (regions.length > 0) {
25778
+ const start = regions.pop();
25779
+ if (line > start) ranges.push({
25780
+ startLine: start,
25781
+ endLine: line,
25782
+ kind: "region"
25783
+ });
25784
+ }
25785
+ }
25786
+ return ranges;
25787
+ }
25788
+ /**
25789
+ * The width of a line's indentation, tabs counting to the next multiple of 4, or -1 for a
25790
+ * blank line.
25791
+ * @param {string} line
25792
+ */
25793
+ function indent_of(line) {
25794
+ let width = 0;
25795
+ for (const character of line) if (character === " ") width++;
25796
+ else if (character === " ") width += 4 - width % 4;
25797
+ else return width;
25798
+ return -1;
25799
+ }
25800
+ /**
25801
+ * Sorted by line, one fold per first line: the one that reaches furthest, which is the one an
25802
+ * editor that keeps a single fold per line keeps for TSX.
25803
+ * @param {FoldingRange[]} ranges
25804
+ * @returns {FoldingRange[]}
25805
+ */
25806
+ function merge_folding_ranges(ranges) {
25807
+ const sorted = [...ranges].sort((a, b) => a.startLine - b.startLine || b.endLine - a.endLine);
25808
+ return sorted.filter((range, index) => index === 0 || sorted[index - 1].startLine !== range.startLine);
25809
+ }
25810
+ /**
25811
+ * @param {unknown} value
25812
+ * @returns {boolean}
25813
+ */
25814
+ function is_node(value) {
25815
+ return !!value && typeof value === "object" && typeof value.type === "string" && typeof value.start === "number";
25816
+ }
25817
+ /**
25818
+ * @param {AST.Node} statement
25819
+ * @returns {boolean}
25820
+ */
25821
+ function is_import(statement) {
25822
+ return statement.type === "ImportDeclaration" || statement.type === "TSImportEqualsDeclaration";
25823
+ }
25824
+
25114
25825
  //#endregion
25115
25826
  //#region src/workspaceState.js
25827
+ /** Configs and package state, which every backend reacts to (`classifyWorkspaceChanges`). */
25828
+ const CONFIG_AND_PACKAGE_STATE_PATTERNS = [
25829
+ "**/*.json",
25830
+ "**/pnpm-lock.yaml",
25831
+ "**/pnpm-workspace.yaml",
25832
+ "**/yarn.lock",
25833
+ "**/bun.lock",
25834
+ "**/bun.lockb",
25835
+ "**/node_modules/.modules.yaml",
25836
+ "**/node_modules/.package-lock.json",
25837
+ "**/node_modules/.yarn-state.yml",
25838
+ "**/node_modules/.yarn-integrity"
25839
+ ];
25116
25840
  const WORKSPACE_FILE_PATTERNS = [
25117
25841
  "**/*.tsrx",
25118
25842
  "**/*.ts",
@@ -25123,13 +25847,44 @@ const WORKSPACE_FILE_PATTERNS = [
25123
25847
  "**/*.jsx",
25124
25848
  "**/*.cjs",
25125
25849
  "**/*.mjs",
25126
- "**/*.json",
25127
- "**/pnpm-lock.yaml",
25128
- "**/pnpm-workspace.yaml",
25129
- "**/yarn.lock",
25130
- "**/bun.lock",
25131
- "**/bun.lockb"
25850
+ ...CONFIG_AND_PACKAGE_STATE_PATTERNS
25132
25851
  ];
25852
+ /**
25853
+ * The files to watch on a backend. Only the classic backend hosts a TypeScript
25854
+ * project, which needs the TypeScript and JavaScript source events. On the other
25855
+ * backends the editor's TypeScript reads those files, and watching them in a large
25856
+ * workspace only floods the server with events from build output and dev servers.
25857
+ * @param {import('./backend.js').TypeScriptBackend} backend
25858
+ * @returns {string[]}
25859
+ */
25860
+ function getWorkspaceFilePatterns(backend) {
25861
+ return backend === "classic" ? WORKSPACE_FILE_PATTERNS : ["**/*.tsrx", ...CONFIG_AND_PACKAGE_STATE_PATTERNS];
25862
+ }
25863
+ /**
25864
+ * Directories that installs, dev servers and builds write, such as Vite's
25865
+ * `node_modules/.vite/deps/package.json` or Next.js's `.next/package.json`. No
25866
+ * project the TSRX compiler resolves from lives in one. Keep in sync with
25867
+ * `file-events.js` in the VS Code extension, which drops the same events.
25868
+ */
25869
+ const GENERATED_DIRECTORY_NAMES = /* @__PURE__ */ new Set([
25870
+ "node_modules",
25871
+ ".next",
25872
+ ".nuxt",
25873
+ ".output",
25874
+ ".svelte-kit",
25875
+ ".turbo",
25876
+ ".vercel"
25877
+ ]);
25878
+ /**
25879
+ * Files that pnpm, npm, Yarn (node-modules linker) and Yarn 1 write directly in
25880
+ * `node_modules` at the end of every install.
25881
+ */
25882
+ const INSTALL_MARKER_FILE_NAMES = /* @__PURE__ */ new Set([
25883
+ ".modules.yaml",
25884
+ ".package-lock.json",
25885
+ ".yarn-state.yml",
25886
+ ".yarn-integrity"
25887
+ ]);
25133
25888
  const PACKAGE_STATE_FILE_NAMES = /* @__PURE__ */ new Set([
25134
25889
  "package.json",
25135
25890
  "package-lock.json",
@@ -25159,6 +25914,39 @@ function isPackageStateFile(file_name) {
25159
25914
  return PACKAGE_STATE_FILE_NAMES.has(node_path.default.basename(file_name).toLowerCase());
25160
25915
  }
25161
25916
  /**
25917
+ * The path segments of a file, relative to the workspace folder that holds it, so a
25918
+ * workspace opened inside a `node_modules` folder keeps its own events.
25919
+ * @param {string} file_name
25920
+ * @param {readonly string[]} workspace_folders
25921
+ */
25922
+ function workspaceRelativeSegments(file_name, workspace_folders) {
25923
+ const normalized = normalizeFileName(file_name);
25924
+ let relative = normalized;
25925
+ for (const folder of workspace_folders) {
25926
+ const normalized_folder = normalizeFileName(folder).replace(/[\\/]+$/, "");
25927
+ if (normalized.startsWith(normalized_folder) && /[\\/]/.test(normalized[normalized_folder.length] ?? "") && normalized.length - normalized_folder.length - 1 < relative.length) relative = normalized.slice(normalized_folder.length + 1);
25928
+ }
25929
+ return relative.split(/[\\/]/);
25930
+ }
25931
+ /**
25932
+ * Whether a file under `node_modules` shows that an install finished: an install
25933
+ * marker, or the manifest of a package installed directly in a `node_modules`
25934
+ * folder (`node_modules/<name>/package.json`, `node_modules/@scope/<name>/package.json`),
25935
+ * which npm and Bun write for each package they install. The lockfile is not enough:
25936
+ * `git pull` can change it before the install that changes the TSRX compiler. A
25937
+ * `node_modules` inside build output (`.output/server/node_modules`,
25938
+ * `.next/standalone/node_modules`) is a copy a build writes, not an install.
25939
+ * @param {readonly string[]} segments Path segments relative to the workspace folder.
25940
+ */
25941
+ function isInstallStateFile(segments) {
25942
+ const index = segments.indexOf("node_modules");
25943
+ if (index === -1 || segments.includes("node_modules", index + 1) || segments.slice(0, index).some((segment) => GENERATED_DIRECTORY_NAMES.has(segment))) return false;
25944
+ const rest = segments.slice(index + 1);
25945
+ if (rest.length === 1) return INSTALL_MARKER_FILE_NAMES.has(rest[0]);
25946
+ const name = rest.slice(0, rest[0]?.startsWith("@") ? 2 : 1);
25947
+ return rest.length === name.length + 1 && rest[rest.length - 1] === "package.json" && name.every((segment) => !segment.startsWith("."));
25948
+ }
25949
+ /**
25162
25950
  * @param {string} file_name
25163
25951
  */
25164
25952
  function normalizeFileName(file_name) {
@@ -25191,11 +25979,16 @@ function trackTypeScriptConfigDependencies(config_files, project) {
25191
25979
  /**
25192
25980
  * Classify watched changes before mutating project state. Package changes need
25193
25981
  * a process restart because Node does not expose a supported way to evict a
25194
- * loaded ESM compiler and its transitive module graph.
25982
+ * loaded ESM compiler and its transitive module graph. A file in a generated
25983
+ * directory restarts the server only when it shows that an install finished
25984
+ * (`isInstallStateFile`), and reloads projects only when a project loaded it as a
25985
+ * config: dev servers rewrite such files all the time, and restarting on each one
25986
+ * kept a large workspace restarting the server.
25195
25987
  * @param {import('@volar/language-server').FileEvent[]} changes
25196
25988
  * @param {ReadonlySet<string>} [tracked_config_files]
25989
+ * @param {readonly string[]} [workspace_folders] File system paths of the workspace folders.
25197
25990
  */
25198
- function classifyWorkspaceChanges(changes, tracked_config_files = /* @__PURE__ */ new Set()) {
25991
+ function classifyWorkspaceChanges(changes, tracked_config_files = /* @__PURE__ */ new Set(), workspace_folders = []) {
25199
25992
  let reloadProjects = false;
25200
25993
  let restartLanguageServer = false;
25201
25994
  /** @type {Set<string>} */
@@ -25203,8 +25996,10 @@ function classifyWorkspaceChanges(changes, tracked_config_files = /* @__PURE__ *
25203
25996
  for (const change of changes) {
25204
25997
  const uri = vscode_uri.URI.parse(change.uri);
25205
25998
  const file_name = uri.scheme === "file" ? uri.fsPath : uri.path;
25206
- if (isTypeScriptConfigFile(file_name) || tracked_config_files.has(normalizeFileName(file_name))) reloadProjects = true;
25207
- if (isPackageStateFile(file_name)) restartLanguageServer = true;
25999
+ const segments = workspaceRelativeSegments(file_name, workspace_folders);
26000
+ const generated = segments.some((segment) => GENERATED_DIRECTORY_NAMES.has(segment));
26001
+ if (!generated && isTypeScriptConfigFile(file_name) || tracked_config_files.has(normalizeFileName(file_name))) reloadProjects = true;
26002
+ if (generated ? isInstallStateFile(segments) : isPackageStateFile(file_name)) restartLanguageServer = true;
25208
26003
  else if (isTypeDefinitionFile(file_name)) changedTypeDefinitions.add(file_name);
25209
26004
  }
25210
26005
  return {
@@ -25214,6 +26009,32 @@ function classifyWorkspaceChanges(changes, tracked_config_files = /* @__PURE__ *
25214
26009
  };
25215
26010
  }
25216
26011
  /**
26012
+ * Run `restart` once, after package changes have stopped for `delay` ms, so a burst
26013
+ * of them, such as an install, restarts the server once; or `max_delay` ms after
26014
+ * the first change at the latest, so a steady stream cannot hold it off.
26015
+ * @param {() => void} restart
26016
+ * @param {number} [delay]
26017
+ * @param {number} [max_delay]
26018
+ * @returns {() => void} Call on each change that needs a restart.
26019
+ */
26020
+ function createRestartScheduler(restart, delay = 1e3, max_delay = 1e4) {
26021
+ /** @type {ReturnType<typeof setTimeout> | undefined} */
26022
+ let timer;
26023
+ /** @type {number | undefined} */
26024
+ let first_change;
26025
+ let restarted = false;
26026
+ return () => {
26027
+ if (restarted) return;
26028
+ const now = Date.now();
26029
+ first_change ??= now;
26030
+ clearTimeout(timer);
26031
+ timer = setTimeout(() => {
26032
+ restarted = true;
26033
+ restart();
26034
+ }, Math.min(delay, first_change + max_delay - now));
26035
+ };
26036
+ }
26037
+ /**
25217
26038
  * @param {import('@volar/language-server').FileEvent[]} changes
25218
26039
  * @param {{
25219
26040
  * restartLanguageServer: () => void,
@@ -25223,9 +26044,10 @@ function classifyWorkspaceChanges(changes, tracked_config_files = /* @__PURE__ *
25223
26044
  * invalidateTypeDefinitions: (file_name?: string) => void,
25224
26045
  * }} hooks
25225
26046
  * @param {ReadonlySet<string>} [tracked_config_files]
26047
+ * @param {readonly string[]} [workspace_folders]
25226
26048
  */
25227
- function handleWorkspaceChanges(changes, hooks, tracked_config_files) {
25228
- const effects = classifyWorkspaceChanges(changes, tracked_config_files);
26049
+ function handleWorkspaceChanges(changes, hooks, tracked_config_files, workspace_folders) {
26050
+ const effects = classifyWorkspaceChanges(changes, tracked_config_files, workspace_folders);
25229
26051
  if (effects.restartLanguageServer) {
25230
26052
  hooks.restartLanguageServer();
25231
26053
  return effects;
@@ -25266,6 +26088,7 @@ function createTsrxLanguageServer(options = {}) {
25266
26088
  const server = (0, import_node.createServer)(connection);
25267
26089
  register_formatting(connection, (uri) => server.documents.get(vscode_uri.URI.parse(uri)));
25268
26090
  register_closing_tags(connection, server);
26091
+ register_folding_ranges(connection, server);
25269
26092
  connection.listen();
25270
26093
  /** @type {WeakSet<Function>} */
25271
26094
  const wrappedFunctions = /* @__PURE__ */ new WeakSet();
@@ -25273,8 +26096,9 @@ function createTsrxLanguageServer(options = {}) {
25273
26096
  const trackedTypeScriptConfigFiles = /* @__PURE__ */ new Set();
25274
26097
  /** @type {Set<Set<string>>} */
25275
26098
  const compilerResolutionDependencySets = /* @__PURE__ */ new Set();
25276
- let restartScheduled = false;
25277
26099
  let clientRestarts = false;
26100
+ /** @type {import('./backend.js').TypeScriptBackend} */
26101
+ let activeBackend = "classic";
25278
26102
  /**
25279
26103
  * Shown once the client is initialized, each as its own warning: the classic
25280
26104
  * backend skipped the `typescript.tsdk` option, or did not find a `typescript`
@@ -25283,14 +26107,13 @@ function createTsrxLanguageServer(options = {}) {
25283
26107
  */
25284
26108
  const typescriptNotices = [];
25285
26109
  /**
25286
- * Restart the process so Node drops the complete ESM compiler graph. A
25287
- * client that restarts the server itself stops sending first. When the
25288
- * server exits by itself, the client's next message fails (VS Code showed
25289
- * "Cannot call write after a stream was destroyed").
26110
+ * Restart the process so Node drops the complete ESM compiler graph, once
26111
+ * package state has settled (`createRestartScheduler`). A client that restarts
26112
+ * the server itself stops sending first. When the server exits by itself, the
26113
+ * client's next message fails (VS Code showed "Cannot call write after a stream
26114
+ * was destroyed").
25290
26115
  */
25291
- function restartLanguageServer() {
25292
- if (restartScheduled) return;
25293
- restartScheduled = true;
26116
+ const restartLanguageServer = createRestartScheduler(() => {
25294
26117
  if (clientRestarts) {
25295
26118
  log("Asking the client to restart the server after package state changed.");
25296
26119
  connection.sendNotification(RESTART_NOTIFICATION);
@@ -25298,7 +26121,7 @@ function createTsrxLanguageServer(options = {}) {
25298
26121
  }
25299
26122
  log("Restarting after package state changed.");
25300
26123
  setTimeout(() => process.exit(0), 50);
25301
- }
26124
+ });
25302
26125
  /**
25303
26126
  * Ensure TypeScript hosts always see TSRX compiler defaults.
25304
26127
  * @param {unknown} target
@@ -25375,6 +26198,7 @@ function createTsrxLanguageServer(options = {}) {
25375
26198
  }
25376
26199
  for (const notice of typescriptNotices) logError(notice);
25377
26200
  }
26201
+ activeBackend = backend;
25378
26202
  if (ts === void 0) {
25379
26203
  const compilerResolutionDependencies = /* @__PURE__ */ new Set();
25380
26204
  compilerResolutionDependencySets.add(compilerResolutionDependencies);
@@ -25432,10 +26256,10 @@ function createTsrxLanguageServer(options = {}) {
25432
26256
  server.project.reload();
25433
26257
  },
25434
26258
  requestRefresh: (clearDiagnostics) => server.languageFeatures.requestRefresh(clearDiagnostics)
25435
- }, trackedTypeScriptConfigFiles).reloadProjects) log("Reloaded TypeScript projects after workspace configuration changed.");
26259
+ }, trackedTypeScriptConfigFiles, server.workspaceFolders.all.filter((folder) => folder.scheme === "file").map((folder) => folder.fsPath)).reloadProjects) log("Reloaded TypeScript projects after workspace configuration changed.");
25436
26260
  });
25437
26261
  try {
25438
- await server.fileWatcher.watchFiles(WORKSPACE_FILE_PATTERNS);
26262
+ await server.fileWatcher.watchFiles(getWorkspaceFilePatterns(activeBackend));
25439
26263
  log("Workspace file watchers registered.");
25440
26264
  } catch (err) {
25441
26265
  logError("Failed to register file watchers:", err);
@@ -25454,9 +26278,10 @@ function createTsrxLanguageServer(options = {}) {
25454
26278
  }
25455
26279
  /**
25456
26280
  * Advertise what the server's own handlers serve: the formatters `register_formatting`
25457
- * serves (whole document and range), and the closing tags `register_closing_tags`
25458
- * serves on `>`, unless the client closes tags another way (`closes_tags_on_type`).
25459
- * No Volar service plugin advertises either (`stripFormatting`).
26281
+ * serves (whole document and range), the folds `register_folding_ranges` serves, and the
26282
+ * closing tags `register_closing_tags` serves on `>`, unless the client closes tags another
26283
+ * way (`closes_tags_on_type`). No Volar service plugin advertises any of them
26284
+ * (`stripFormatting`, `stripFoldingRanges`).
25460
26285
  * @template {import('@volar/language-server/node').InitializeResult} T
25461
26286
  * @param {T} initResult
25462
26287
  * @param {import('@volar/language-server/node').InitializeParams} params
@@ -25465,6 +26290,7 @@ function createTsrxLanguageServer(options = {}) {
25465
26290
  function with_own_handlers(initResult, params) {
25466
26291
  initResult.capabilities.documentFormattingProvider = true;
25467
26292
  initResult.capabilities.documentRangeFormattingProvider = true;
26293
+ initResult.capabilities.foldingRangeProvider = true;
25468
26294
  if (closes_tags_on_type(params)) initResult.capabilities.documentOnTypeFormattingProvider = CLOSING_TAGS_ON_TYPE;
25469
26295
  return initResult;
25470
26296
  }
@@ -25502,4 +26328,4 @@ Object.defineProperty(exports, 'createTsrxLanguageServer', {
25502
26328
  return createTsrxLanguageServer;
25503
26329
  }
25504
26330
  });
25505
- //# sourceMappingURL=server-CpRcmosU.js.map
26331
+ //# sourceMappingURL=server-B_LRzE1h.js.map