@angular/language-server 22.0.0-next.0 → 22.0.0-next.2

package/index.js

@@ -72987,9 +72987,9 @@ var require_source_map_support = __commonJS({
   }
 });
 
-// node_modules/.aspect_rules_js/typescript@6.0.0-beta/node_modules/typescript/lib/typescript.js
+// node_modules/.aspect_rules_js/typescript@6.0.1-rc/node_modules/typescript/lib/typescript.js
 var require_typescript = __commonJS({
-  "node_modules/.aspect_rules_js/typescript@6.0.0-beta/node_modules/typescript/lib/typescript.js"(exports2, module2) {
+  "node_modules/.aspect_rules_js/typescript@6.0.1-rc/node_modules/typescript/lib/typescript.js"(exports2, module2) {
     var ts = {};
     ((module3) => {
       "use strict";
@@ -75263,7 +75263,7 @@ var require_typescript = __commonJS({
       });
       module3.exports = __toCommonJS2(typescript_exports);
       var versionMajorMinor = "6.0";
-      var version = "6.0.0-beta";
+      var version = "6.0.1-rc";
       var Comparison = ((Comparison3) => {
         Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
         Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -83637,6 +83637,7 @@ ${lanes.join("\n")}
         Import_assertions_have_been_replaced_by_import_attributes_Use_with_instead_of_assert: diag(2880, 1, "Import_assertions_have_been_replaced_by_import_attributes_Use_with_instead_of_assert_2880", "Import assertions have been replaced by import attributes. Use 'with' instead of 'assert'."),
         This_expression_is_never_nullish: diag(2881, 1, "This_expression_is_never_nullish_2881", "This expression is never nullish."),
         Cannot_find_module_or_type_declarations_for_side_effect_import_of_0: diag(2882, 1, "Cannot_find_module_or_type_declarations_for_side_effect_import_of_0_2882", "Cannot find module or type declarations for side-effect import of '{0}'."),
+        The_inferred_type_of_0_cannot_be_named_without_a_reference_to_2_from_1_This_is_likely_not_portable_A_type_annotation_is_necessary: diag(2883, 1, "The_inferred_type_of_0_cannot_be_named_without_a_reference_to_2_from_1_This_is_likely_not_portable_A_2883", "The inferred type of '{0}' cannot be named without a reference to '{2}' from '{1}'. This is likely not portable. A type annotation is necessary."),
         Import_declaration_0_is_using_private_name_1: diag(4e3, 1, "Import_declaration_0_is_using_private_name_1_4000", "Import declaration '{0}' is using private name '{1}'."),
         Type_parameter_0_of_exported_class_has_or_is_using_private_name_1: diag(4002, 1, "Type_parameter_0_of_exported_class_has_or_is_using_private_name_1_4002", "Type parameter '{0}' of exported class has or is using private name '{1}'."),
         Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1: diag(4004, 1, "Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1_4004", "Type parameter '{0}' of exported interface has or is using private name '{1}'."),
@@ -132863,7 +132864,7 @@ ${lanes.join("\n")}
                 if (name.includes("/node_modules/")) {
                   context.encounteredError = true;
                   if (context.tracker.reportLikelyUnsafeImportRequiredError) {
-                    context.tracker.reportLikelyUnsafeImportRequiredError(name);
+                    context.tracker.reportLikelyUnsafeImportRequiredError(name, nodeSymbol ? unescapeLeadingUnderscores(nodeSymbol.escapedName) : void 0);
                   }
                 }
                 if (name !== originalName) {
@@ -134763,8 +134764,8 @@ ${lanes.join("\n")}
               reportInaccessibleUniqueSymbolError() {
                 markError(() => oldTracker.reportInaccessibleUniqueSymbolError());
               },
-              reportLikelyUnsafeImportRequiredError(specifier) {
-                markError(() => oldTracker.reportLikelyUnsafeImportRequiredError(specifier));
+              reportLikelyUnsafeImportRequiredError(specifier, symbolName2) {
+                markError(() => oldTracker.reportLikelyUnsafeImportRequiredError(specifier, symbolName2));
               },
               reportNonSerializableProperty(name) {
                 markError(() => oldTracker.reportNonSerializableProperty(name));
@@ -135357,7 +135358,7 @@ ${lanes.join("\n")}
                 if (!attributes) {
                   context.encounteredError = true;
                   if (context.tracker.reportLikelyUnsafeImportRequiredError) {
-                    context.tracker.reportLikelyUnsafeImportRequiredError(oldSpecifier);
+                    context.tracker.reportLikelyUnsafeImportRequiredError(oldSpecifier, unescapeLeadingUnderscores(symbol.escapedName));
                   }
                 }
               }
@@ -150116,9 +150117,12 @@ ${lanes.join("\n")}
             if (relation === identityRelation) {
               return signaturesIdenticalTo(source2, target2, kind);
             }
-            if (target2 === anyFunctionType || source2 === anyFunctionType) {
+            if (source2 === anyFunctionType) {
               return -1;
             }
+            if (target2 === anyFunctionType) {
+              return 0;
+            }
             const sourceIsJSConstructor = source2.symbol && isJSConstructor(source2.symbol.valueDeclaration);
             const targetIsJSConstructor = target2.symbol && isJSConstructor(target2.symbol.valueDeclaration);
             const sourceSignatures = getSignaturesOfType(
@@ -158261,7 +158265,7 @@ ${lanes.join("\n")}
                 spread,
                 createAnonymousType(attributesSymbol, childPropMap, emptyArray, emptyArray, emptyArray),
                 attributesSymbol,
-                objectFlags,
+                objectFlags | getPropagatingFlagsOfTypes(childrenTypes),
                 /*readonly*/
                 false
               );
@@ -161834,6 +161838,14 @@ ${lanes.join("\n")}
                 /* Undefined */
               ), node.arguments[1]);
             }
+            if (compilerOptions.ignoreDeprecations !== "6.0" && isObjectLiteralExpression(node.arguments[1])) {
+              for (const prop of node.arguments[1].properties) {
+                if (isPropertyAssignment(prop) && isIdentifier(prop.name) && prop.name.escapedText === "assert") {
+                  grammarErrorOnNode(prop.name, Diagnostics.Import_assertions_have_been_replaced_by_import_attributes_Use_with_instead_of_assert);
+                  break;
+                }
+              }
+            }
           }
           const moduleSymbol = resolveExternalModuleName(node, specifier);
           if (moduleSymbol) {
@@ -166520,6 +166532,9 @@ ${lanes.join("\n")}
         function checkImportType(node) {
           checkSourceElement(node.argument);
           if (node.attributes) {
+            if (node.attributes.token !== 118 && compilerOptions.ignoreDeprecations !== "6.0") {
+              grammarErrorOnFirstToken(node.attributes, Diagnostics.Import_assertions_have_been_replaced_by_import_attributes_Use_with_instead_of_assert);
+            }
             getResolutionModeOverride(node.attributes, grammarErrorOnNode);
           }
           checkTypeReferenceOrImport(node);
@@ -176136,11 +176151,11 @@ ${lanes.join("\n")}
             this.inner.reportCyclicStructureError();
           }
         }
-        reportLikelyUnsafeImportRequiredError(specifier) {
+        reportLikelyUnsafeImportRequiredError(specifier, symbolName2) {
           var _a3;
           if ((_a3 = this.inner) == null ? void 0 : _a3.reportLikelyUnsafeImportRequiredError) {
             this.onDiagnosticReported();
-            this.inner.reportLikelyUnsafeImportRequiredError(specifier);
+            this.inner.reportLikelyUnsafeImportRequiredError(specifier, symbolName2);
           }
         }
         reportTruncationError() {
@@ -201680,9 +201695,13 @@ ${lanes.join("\n")}
             context.addDiagnostic(createDiagnosticForNode(errorNameNode || errorFallbackNode, Diagnostics.The_inferred_type_of_0_references_an_inaccessible_1_type_A_type_annotation_is_necessary, errorDeclarationNameWithFallback(), "this"));
           }
         }
-        function reportLikelyUnsafeImportRequiredError(specifier) {
+        function reportLikelyUnsafeImportRequiredError(specifier, symbolName2) {
           if (errorNameNode || errorFallbackNode) {
-            context.addDiagnostic(createDiagnosticForNode(errorNameNode || errorFallbackNode, Diagnostics.The_inferred_type_of_0_cannot_be_named_without_a_reference_to_1_This_is_likely_not_portable_A_type_annotation_is_necessary, errorDeclarationNameWithFallback(), specifier));
+            if (symbolName2) {
+              context.addDiagnostic(createDiagnosticForNode(errorNameNode || errorFallbackNode, Diagnostics.The_inferred_type_of_0_cannot_be_named_without_a_reference_to_2_from_1_This_is_likely_not_portable_A_type_annotation_is_necessary, errorDeclarationNameWithFallback(), specifier, symbolName2));
+            } else {
+              context.addDiagnostic(createDiagnosticForNode(errorNameNode || errorFallbackNode, Diagnostics.The_inferred_type_of_0_cannot_be_named_without_a_reference_to_1_This_is_likely_not_portable_A_type_annotation_is_necessary, errorDeclarationNameWithFallback(), specifier));
+            }
           }
         }
         function reportTruncationError() {
@@ -202970,6 +202989,7 @@ ${lanes.join("\n")}
                         continue;
                       if (isBindingPattern(elem.name)) {
                         elems = concatenate(elems, walkBindingPattern(elem.name));
+                        continue;
                       }
                       elems = elems || [];
                       elems.push(factory2.createPropertyDeclaration(
@@ -307880,6 +307900,11 @@ var require_initialization = __commonJS({
             // Find more info
             // [here](https://github.com/angular/vscode-ng-language-service/issues/1828)
             codeActionKinds: [lsp.CodeActionKind.QuickFix]
+          },
+          // Inlay hints provider (LSP 3.17)
+          // Provides type annotations for template variables, $event types, etc.
+          inlayHintProvider: {
+            resolveProvider: true
           }
         },
         serverOptions
@@ -308084,6 +308109,314 @@ var require_did_change_watched_files = __commonJS({
   }
 });
 
+// vscode-ng-language-service/server/src/config.js
+var require_config = __commonJS({
+  "vscode-ng-language-service/server/src/config.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.getWorkspaceConfiguration = getWorkspaceConfiguration;
+    exports2.getWorkspaceConfigurationCached = getWorkspaceConfigurationCached;
+    exports2.clearWorkspaceConfigurationCache = clearWorkspaceConfigurationCache;
+    exports2.flattenConfiguration = flattenConfiguration;
+    var workspaceConfigCache = /* @__PURE__ */ new WeakMap();
+    function getWorkspaceConfiguration(connection, items) {
+      return __async(this, null, function* () {
+        try {
+          return yield connection.workspace.getConfiguration(items);
+        } catch (error) {
+          return items.map(() => ({}));
+        }
+      });
+    }
+    function getWorkspaceConfigurationCached(connection, items) {
+      return __async(this, null, function* () {
+        const key = JSON.stringify(items);
+        let cache = workspaceConfigCache.get(connection);
+        if (!cache) {
+          cache = /* @__PURE__ */ new Map();
+          workspaceConfigCache.set(connection, cache);
+        }
+        const cached = cache.get(key);
+        if (cached !== void 0) {
+          return cached;
+        }
+        const value = yield getWorkspaceConfiguration(connection, items);
+        cache.set(key, value);
+        return value;
+      });
+    }
+    function clearWorkspaceConfigurationCache(connection) {
+      workspaceConfigCache.delete(connection);
+    }
+    function flattenConfiguration(config, prefix) {
+      const result = {};
+      function flatten(obj, currentPrefix) {
+        for (const [key, value] of Object.entries(obj)) {
+          const newKey = `${currentPrefix}.${key}`;
+          if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+            flatten(value, newKey);
+          } else {
+            result[newKey] = value;
+          }
+        }
+      }
+      flatten(config, prefix);
+      return result;
+    }
+  }
+});
+
+// vscode-ng-language-service/server/src/handlers/inlay_hints.js
+var require_inlay_hints = __commonJS({
+  "vscode-ng-language-service/server/src/handlers/inlay_hints.js"(exports2) {
+    "use strict";
+    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0)
+        k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    } : function(o, m, k, k2) {
+      if (k2 === void 0)
+        k2 = k;
+      o[k2] = m[k];
+    });
+    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    } : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports2 && exports2.__importStar || /* @__PURE__ */ function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2)
+            if (Object.prototype.hasOwnProperty.call(o2, k))
+              ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule)
+          return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++)
+            if (k[i] !== "default")
+              __createBinding(result, mod, k[i]);
+        }
+        __setModuleDefault(result, mod);
+        return result;
+      };
+    }();
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.onInlayHint = onInlayHint;
+    exports2.onInlayHintResolve = onInlayHintResolve;
+    var lsp = __importStar(require_node3());
+    var ts = __importStar(require("typescript/lib/tsserverlibrary"));
+    var utils_1 = require_utils();
+    var utils_2 = require_utils();
+    var config_1 = require_config();
+    var api_1 = require_api_bundle();
+    function isEditorInlayHintsEnabled(vsCodeConfig) {
+      const editorEnabled = vsCodeConfig["editor.inlayHints.enabled"];
+      return !(editorEnabled === "off" || editorEnabled === false);
+    }
+    function mapAngularInlayHintsConfig(vsCodeConfig) {
+      const config = {};
+      const getConfigValue = (...keys) => {
+        for (const key of keys) {
+          if (vsCodeConfig[key] !== void 0 && vsCodeConfig[key] !== null) {
+            return vsCodeConfig[key];
+          }
+        }
+        return void 0;
+      };
+      const forLoopVariableTypes = getConfigValue("angular.inlayHints.variableTypes.forLoopVariableTypes");
+      if (forLoopVariableTypes !== void 0)
+        config.forLoopVariableTypes = forLoopVariableTypes;
+      const ifAliasTypes = getConfigValue("angular.inlayHints.variableTypes.ifAliasTypes");
+      if (ifAliasTypes !== void 0)
+        config.ifAliasTypes = ifAliasTypes;
+      const letDeclarationTypes = getConfigValue("angular.inlayHints.variableTypes.letDeclarationTypes");
+      if (letDeclarationTypes !== void 0)
+        config.letDeclarationTypes = letDeclarationTypes;
+      const referenceVariableTypes = getConfigValue("angular.inlayHints.variableTypes.referenceVariableTypes");
+      if (referenceVariableTypes !== void 0)
+        config.referenceVariableTypes = referenceVariableTypes;
+      const suppressWhenTypeMatchesName = getConfigValue("angular.inlayHints.variableTypes.suppressWhenTypeMatchesName");
+      if (suppressWhenTypeMatchesName !== void 0) {
+        config.variableTypeHintsWhenTypeMatchesName = !suppressWhenTypeMatchesName;
+      }
+      const arrowFunctionParameterTypes = getConfigValue("angular.inlayHints.functionTypes.arrowFunctionParameterTypes");
+      if (arrowFunctionParameterTypes !== void 0) {
+        config.arrowFunctionParameterTypes = arrowFunctionParameterTypes;
+      }
+      const arrowFunctionReturnTypes = getConfigValue("angular.inlayHints.functionTypes.arrowFunctionReturnTypes");
+      if (arrowFunctionReturnTypes !== void 0) {
+        config.arrowFunctionReturnTypes = arrowFunctionReturnTypes;
+      }
+      const parameterNameHints = getConfigValue("angular.inlayHints.parameterHints.nameHints");
+      if (parameterNameHints !== void 0)
+        config.parameterNameHints = parameterNameHints;
+      const suppressWhenArgumentMatchesName = getConfigValue("angular.inlayHints.parameterHints.suppressWhenArgumentMatchesName");
+      if (suppressWhenArgumentMatchesName !== void 0) {
+        config.parameterNameHintsWhenArgumentMatchesName = !suppressWhenArgumentMatchesName;
+      }
+      const eventParameterTypes = getConfigValue("angular.inlayHints.eventHints.parameterTypes");
+      if (eventParameterTypes !== void 0)
+        config.eventParameterTypes = eventParameterTypes;
+      const propertyBindingTypes = getConfigValue("angular.inlayHints.bindingHints.propertyBindingTypes");
+      if (propertyBindingTypes !== void 0)
+        config.propertyBindingTypes = propertyBindingTypes;
+      const pipeOutputTypes = getConfigValue("angular.inlayHints.bindingHints.pipeOutputTypes");
+      if (pipeOutputTypes !== void 0)
+        config.pipeOutputTypes = pipeOutputTypes;
+      const twoWayBindingSignalTypes = getConfigValue("angular.inlayHints.bindingHints.twoWayBindingSignalTypes");
+      if (twoWayBindingSignalTypes !== void 0) {
+        config.twoWayBindingSignalTypes = twoWayBindingSignalTypes;
+      }
+      const requiredInputIndicator = getConfigValue("angular.inlayHints.bindingHints.requiredInputIndicator");
+      if (requiredInputIndicator !== void 0) {
+        config.requiredInputIndicator = requiredInputIndicator;
+      }
+      const interactiveInlayHints = getConfigValue("angular.inlayHints.interaction.interactiveInlayHints");
+      if (interactiveInlayHints !== void 0)
+        config.interactiveInlayHints = interactiveInlayHints;
+      const hostListenerArgumentTypes = getConfigValue("angular.inlayHints.eventHints.hostListenerArgumentTypes");
+      if (hostListenerArgumentTypes !== void 0) {
+        config.hostListenerArgumentTypes = hostListenerArgumentTypes;
+      }
+      const switchExpressionTypes = getConfigValue("angular.inlayHints.controlFlowHints.switchExpressionTypes");
+      if (switchExpressionTypes !== void 0)
+        config.switchExpressionTypes = switchExpressionTypes;
+      const deferTriggerTypes = getConfigValue("angular.inlayHints.controlFlowHints.deferTriggerTypes");
+      if (deferTriggerTypes !== void 0)
+        config.deferTriggerTypes = deferTriggerTypes;
+      return config;
+    }
+    function onInlayHint(session, params) {
+      return __async(this, null, function* () {
+        var _a3, _b;
+        const lsInfo = session.getLSAndScriptInfo(params.textDocument);
+        if (!lsInfo) {
+          return null;
+        }
+        const { languageService, scriptInfo } = lsInfo;
+        const hints = [];
+        const [startOffset, endOffset] = (0, utils_1.lspRangeToTsPositions)(scriptInfo, params.range);
+        const span = { start: startOffset, length: endOffset - startOffset };
+        let angularConfig = {};
+        try {
+          const configResult = yield (0, config_1.getWorkspaceConfigurationCached)(session.connection, [
+            { section: "angular.inlayHints", scopeUri: params.textDocument.uri },
+            { section: "editor.inlayHints", scopeUri: params.textDocument.uri }
+          ]);
+          if (configResult && configResult.length >= 2) {
+            const flatConfig = Object.assign(Object.assign({}, (0, config_1.flattenConfiguration)((_a3 = configResult[0]) !== null && _a3 !== void 0 ? _a3 : {}, "angular.inlayHints")), (0, config_1.flattenConfiguration)((_b = configResult[1]) !== null && _b !== void 0 ? _b : {}, "editor.inlayHints"));
+            if (!isEditorInlayHintsEnabled(flatConfig)) {
+              return null;
+            }
+            angularConfig = mapAngularInlayHintsConfig(flatConfig);
+          }
+        } catch (_c) {
+        }
+        if ((0, api_1.isNgLanguageService)(languageService)) {
+          try {
+            const angularHints = languageService.getAngularInlayHints(scriptInfo.fileName, span, angularConfig);
+            for (const angularHint of angularHints) {
+              const position = scriptInfo.positionToLineOffset(angularHint.position);
+              hints.push(convertAngularInlayHint(session, angularHint, position));
+            }
+          } catch (e) {
+          }
+        }
+        return hints.length > 0 ? hints : null;
+      });
+    }
+    function onInlayHintResolve(session, hint) {
+      return hint;
+    }
+    function convertAngularInlayHint(session, angularHint, position) {
+      const lspPosition = {
+        line: position.line - 1,
+        character: position.offset - 1
+      };
+      const kind = angularHint.kind === "Type" ? lsp.InlayHintKind.Type : lsp.InlayHintKind.Parameter;
+      let label;
+      if (angularHint.displayParts && angularHint.displayParts.length > 0) {
+        label = angularHint.displayParts.map((part) => {
+          const labelPart = {
+            value: part.text
+          };
+          const location = getDisplayPartLocation(session, part);
+          if (location) {
+            labelPart.location = location;
+          }
+          return labelPart;
+        });
+      } else {
+        label = angularHint.text;
+      }
+      const hint = {
+        position: lspPosition,
+        label,
+        kind,
+        paddingLeft: angularHint.paddingLeft,
+        paddingRight: angularHint.paddingRight
+      };
+      if (angularHint.tooltip) {
+        hint.tooltip = angularHint.tooltip;
+      }
+      return hint;
+    }
+    function getDisplayPartLocation(session, part) {
+      if (!part.span || !part.file) {
+        return void 0;
+      }
+      const scriptInfo = session.projectService.getScriptInfo(part.file);
+      if (scriptInfo) {
+        const start2 = scriptInfo.positionToLineOffset(part.span.start);
+        const end2 = scriptInfo.positionToLineOffset(part.span.start + part.span.length);
+        return {
+          uri: (0, utils_2.filePathToUri)(part.file),
+          range: {
+            start: { line: start2.line - 1, character: start2.offset - 1 },
+            end: { line: end2.line - 1, character: end2.offset - 1 }
+          }
+        };
+      }
+      const text = readFileText(session, part.file);
+      if (text === void 0) {
+        return void 0;
+      }
+      const sourceFile = ts.createSourceFile(part.file, text, ts.ScriptTarget.Latest, true);
+      const start = ts.getLineAndCharacterOfPosition(sourceFile, part.span.start);
+      const end = ts.getLineAndCharacterOfPosition(sourceFile, part.span.start + part.span.length);
+      return {
+        uri: (0, utils_2.filePathToUri)(part.file),
+        range: {
+          start: { line: start.line, character: start.character },
+          end: { line: end.line, character: end.character }
+        }
+      };
+    }
+    function readFileText(session, fileName) {
+      const scriptInfo = session.projectService.getScriptInfo(fileName);
+      if (scriptInfo) {
+        const snapshot = scriptInfo.getSnapshot();
+        return snapshot.getText(0, snapshot.getLength());
+      }
+      return ts.sys.readFile(fileName);
+    }
+  }
+});
+
 // vscode-ng-language-service/server/src/session.js
 var require_session = __commonJS({
   "vscode-ng-language-service/server/src/session.js"(exports2) {
@@ -308155,6 +308488,8 @@ var require_session = __commonJS({
     var tcb_1 = require_tcb();
     var template_info_1 = require_template_info();
     var did_change_watched_files_1 = require_did_change_watched_files();
+    var inlay_hints_1 = require_inlay_hints();
+    var config_1 = require_config();
     var LanguageId;
     (function(LanguageId2) {
       LanguageId2["TS"] = "typescript";
@@ -308173,6 +308508,7 @@ var require_session = __commonJS({
         this.renameDisabledProjects = /* @__PURE__ */ new WeakSet();
         this.clientCapabilities = {};
         this.defaultPreferences = {};
+        this.inlayHintsConfig = {};
         this.includeAutomaticOptionalChainCompletions = options2.includeAutomaticOptionalChainCompletions;
         this.includeCompletionsWithSnippetText = options2.includeCompletionsWithSnippetText;
         this.includeCompletionsForModuleExports = options2.includeCompletionsForModuleExports;
@@ -308283,6 +308619,11 @@ var require_session = __commonJS({
         conn.onDidCloseTextDocument((p) => this.onDidCloseTextDocument(p));
         conn.onDidChangeTextDocument((p) => this.onDidChangeTextDocument(p));
         conn.onDidSaveTextDocument((p) => this.onDidSaveTextDocument(p));
+        conn.onDidChangeConfiguration(() => {
+          (0, config_1.clearWorkspaceConfigurationCache)(this.connection);
+          void this.connection.languages.inlayHint.refresh().catch(() => {
+          });
+        });
         conn.onDefinition((p) => (0, definitions_1.onDefinition)(this, p));
         conn.onTypeDefinition((p) => (0, definitions_1.onTypeDefinition)(this, p));
         conn.onReferences((p) => (0, definitions_1.onReferences)(this, p));
@@ -308304,6 +308645,8 @@ var require_session = __commonJS({
         conn.onCodeActionResolve((p) => __async(this, null, function* () {
           return yield (0, code_actions_1.onCodeActionResolve)(this, p);
         }));
+        conn.onRequest(lsp.InlayHintRequest.type, (p) => (0, inlay_hints_1.onInlayHint)(this, p));
+        conn.onRequest(lsp.InlayHintResolveRequest.type, (p) => (0, inlay_hints_1.onInlayHintResolve)(this, p));
       }
       enableLanguageServiceForProject(project) {
         const projectName = project.getProjectName();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@angular/language-server",
   "description": "LSP server for Angular Language Service",
-  "version": "22.0.0-next.0",
+  "version": "22.0.0-next.2",
   "repository": {
     "type": "git",
     "url": "https://github.com/angular/angular.git",
@@ -17,8 +17,8 @@
     "ngserver": "./bin/ngserver"
   },
   "dependencies": {
-    "@angular/language-service": "22.0.0-next.0",
-    "typescript": "6.0.0-beta"
+    "@angular/language-service": "22.0.0-next.2",
+    "typescript": "6.0.1-rc"
   },
   "devDependencies": {
     "@types/node": "^24.5.2",