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

package/api.d.ts

@@ -85,6 +85,202 @@ export interface LinkedEditingRanges {
     /** An optional word pattern to describe valid tag names. */
     wordPattern?: string;
 }
+/**
+ * A display part for interactive inlay hints.
+ * When clicked, can navigate to the definition of the type/parameter.
+ */
+export interface InlayHintDisplayPart {
+    /** The text to display */
+    text: string;
+    /** Optional navigation target span */
+    span?: {
+        /** Start offset in the target file */
+        start: number;
+        /** Length of the span */
+        length: number;
+    };
+    /** Optional target file path for navigation */
+    file?: string;
+}
+/**
+ * Represents an Angular-specific inlay hint to be displayed in the editor.
+ */
+export interface AngularInlayHint {
+    /** Offset position where the hint should appear */
+    position: number;
+    /**
+     * The text to display.
+     * For non-interactive hints, this contains the full hint text.
+     * For interactive hints, this may be empty and displayParts is used instead.
+     */
+    text: string;
+    /** Kind of hint: 'Type' for type annotations, 'Parameter' for parameter names */
+    kind: 'Type' | 'Parameter';
+    /** Whether to add padding before the hint */
+    paddingLeft?: boolean;
+    /** Whether to add padding after the hint */
+    paddingRight?: boolean;
+    /** Optional tooltip documentation */
+    tooltip?: string;
+    /**
+     * Display parts for interactive hints.
+     * When present, these parts can be clicked to navigate to type/parameter definitions.
+     * Used when interactiveInlayHints is enabled.
+     */
+    displayParts?: InlayHintDisplayPart[];
+}
+/**
+ * Configuration for which Angular inlay hints to show.
+ * These options are designed to align with TypeScript's inlay hints configuration
+ * where applicable to Angular templates.
+ */
+export interface InlayHintsConfig {
+    /** Show type hints for @for loop variables: `@for (item: Item of items)` */
+    forLoopVariableTypes?: boolean;
+    /**
+     * Show type hints for @if alias variables: `@if (data; as result: Data)`
+     *
+     * Can be a boolean to enable/disable all @if alias hints, or an object for fine-grained control:
+     * - `simpleExpressions`: Show hints for simple variable references like `@if (data; as result)`
+     * - `complexExpressions`: Show hints for complex expressions like `@if (data == 2; as b)` or `@if (data.prop; as p)`
+     *
+     * When set to true, shows hints for all @if aliases.
+     * When set to 'complex', only shows hints for complex expressions (property access, comparisons, calls, etc.)
+     */
+    ifAliasTypes?: boolean | 'complex' | {
+        /** Show hints for simple variable references: @if (data; as result). Default: true */
+        simpleExpressions?: boolean;
+        /** Show hints for complex expressions: @if (data.prop; as p), @if (a == b; as c). Default: true */
+        complexExpressions?: boolean;
+    };
+    /** Show type hints for @let declarations: `@let count: number = items.length` */
+    letDeclarationTypes?: boolean;
+    /** Show type hints for template reference variables: `#ref: HTMLInputElement` */
+    referenceVariableTypes?: boolean;
+    /**
+     * Suppress hints when variable name matches the type name (case-insensitive).
+     * Equivalent to TypeScript's `includeInlayVariableTypeHintsWhenTypeMatchesName`.
+     * When false, skips hints like `@let user: User = getUser()` where name matches type.
+     * @default true
+     */
+    variableTypeHintsWhenTypeMatchesName?: boolean;
+    /**
+     * Show type hints for arrow function parameters in templates.
+     * Equivalent to TypeScript's `includeInlayFunctionParameterTypeHints`.
+     *
+     * When enabled, shows: `(a: number, b: string) => a + b` where types are inferred.
+     * @default true
+     */
+    arrowFunctionParameterTypes?: boolean;
+    /**
+     * Show return type hints for arrow functions in templates.
+     * Equivalent to TypeScript's `includeInlayFunctionLikeReturnTypeHints`.
+     *
+     * When enabled, shows: `(a, b): number => a + b` where return type is inferred.
+     * @default true
+     */
+    arrowFunctionReturnTypes?: boolean;
+    /**
+     * Show parameter name hints for function/method arguments in expressions.
+     * Equivalent to TypeScript's `includeInlayParameterNameHints`.
+     *
+     * When enabled, shows: `handleClick(event: $event)` where 'event' is the parameter name.
+     * Options:
+     * - 'none': No parameter name hints
+     * - 'literals': Only for literal arguments (strings, numbers, booleans)
+     * - 'all': For all arguments
+     * @default 'all'
+     */
+    parameterNameHints?: 'none' | 'literals' | 'all';
+    /**
+     * Show parameter hints even when argument name matches parameter name.
+     * Equivalent to TypeScript's `includeInlayParameterNameHintsWhenArgumentMatchesName`.
+     * When false, skips hints like `onClick(event)` where arg name matches param name.
+     * @default false
+     */
+    parameterNameHintsWhenArgumentMatchesName?: boolean;
+    /**
+     * Show type hints for event binding $event parameter.
+     * Works with @Output() EventEmitter<T>, output() OutputEmitterRef<T>, and model() changes.
+     * Example: `(click: MouseEvent)`, `(valueChange: string)`
+     *
+     * Can be a boolean to enable/disable all event hints, or an object for fine-grained control:
+     * - `nativeEvents`: Show hints for native HTML events (click, input, etc.)
+     * - `componentEvents`: Show hints for custom component/directive events
+     * - `animationEvents`: Show hints for animation events (@trigger.done)
+     */
+    eventParameterTypes?: boolean | {
+        /** Show hints for native HTML events (click, input, keydown, etc.). Default: true */
+        nativeEvents?: boolean;
+        /** Show hints for custom component/directive output events. Default: true */
+        componentEvents?: boolean;
+        /** Show hints for animation events (@trigger.start, @trigger.done). Default: true */
+        animationEvents?: boolean;
+    };
+    /** Show type hints for pipe output types: `{{ value | async: Observable<T> }}` */
+    pipeOutputTypes?: boolean;
+    /**
+     * Show type hints for property/input binding types.
+     * Works with @Input(), input(), input.required(), and model() inputs.
+     * Example: `[disabled: boolean]="isDisabled"`
+     *
+     * Can be a boolean to enable/disable all property hints, or an object for fine-grained control:
+     * - `nativeProperties`: Show hints for native DOM properties ([disabled], [hidden], etc.)
+     * - `componentInputs`: Show hints for component/directive @Input() and input() bindings
+     */
+    propertyBindingTypes?: boolean | {
+        /** Show hints for native DOM properties. Default: true */
+        nativeProperties?: boolean;
+        /** Show hints for component/directive inputs. Default: true */
+        componentInputs?: boolean;
+    };
+    /**
+     * Show WritableSignal<T> type for two-way bindings with model() signals.
+     * When true: `[(checked: WritableSignal<boolean>)]="checkboxSignal"`
+     * When false: `[(checked: boolean)]="checkboxSignal"`
+     * @default true
+     */
+    twoWayBindingSignalTypes?: boolean;
+    /**
+     * Add visual indicator for input.required() bindings.
+     * Options:
+     * - 'none': No special indicator
+     * - 'asterisk': Add asterisk suffix `[user*: User]`
+     * - 'exclamation': Add exclamation suffix `[user: User!]`
+     * @default 'none'
+     */
+    requiredInputIndicator?: 'none' | 'asterisk' | 'exclamation';
+    /**
+     * Enable clickable hints that navigate to type/parameter definitions.
+     * Equivalent to TypeScript's `interactiveInlayHints`.
+     * @default false
+     */
+    interactiveInlayHints?: boolean;
+    /**
+     * Show type hints for @HostListener argument expressions.
+     * Example: `@HostListener('click', ['$event.target: EventTarget | null', '$event.clientX: number'])`
+     *
+     * When enabled, shows the inferred type for each expression passed in the decorator arguments.
+     * @default true
+     */
+    hostListenerArgumentTypes?: boolean;
+    /**
+     * Show type hints for @switch block expressions.
+     * Example: `@switch (status: Status) { @case (Status.Active) { ... } }`
+     *
+     * When enabled, shows the inferred type of the switch expression value.
+     * @default true
+     */
+    switchExpressionTypes?: boolean;
+    /**
+     * Show type hints for @defer block trigger expressions.
+     * Example: `@defer (when isVisible: boolean) { ... }`
+     *
+     * When enabled, shows the inferred type for 'when' trigger conditions.
+     * @default true
+     */
+    deferTriggerTypes?: boolean;
+}
 /**
  * `NgLanguageService` describes an instance of an Angular language service,
  * whose API surface is a strict superset of TypeScript's language service.
@@ -113,6 +309,21 @@ export interface NgLanguageService extends ts.LanguageService {
     getComponentLocationsForTemplate(fileName: string): GetComponentLocationsForTemplateResponse;
     getTemplateLocationForComponent(fileName: string, position: number): GetTemplateLocationForComponentResponse;
     getTypescriptLanguageService(): ts.LanguageService;
+    /**
+     * Provide Angular-specific inlay hints for templates.
+     *
+     * Returns hints for:
+     * - @for loop variable types: `@for (user: User of users)`
+     * - @if alias types: `@if (data; as result: ApiResult)`
+     * - Event parameter types: `(click)="onClick($event: MouseEvent)"`
+     * - Pipe output types
+     * - @let declaration types
+     *
+     * @param fileName The file to get inlay hints for
+     * @param span The text span to get hints within
+     * @param config Optional configuration for which hints to show
+     */
+    getAngularInlayHints(fileName: string, span: ts.TextSpan, config?: InlayHintsConfig): AngularInlayHint[];
     applyRefactoring(fileName: string, positionOrRange: number | ts.TextRange, refactorName: string, reportProgress: ApplyRefactoringProgressFn): Promise<ApplyRefactoringResult | undefined>;
     hasCodeFixesForErrorCode(errorCode: number): boolean;
     getTokenTypeFromClassification(classification: number): number | undefined;

package/api_bundle.js.map

@@ -1,6 +1,6 @@
 {
   "version": 3,
   "sources": ["api.ts"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAuJO,SAAS,oBACd,IACyB;AACzB,SAAO,YAAY;AACrB;",
+  "mappings": ";;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AA8aO,SAAS,oBACd,IACyB;AACzB,SAAO,YAAY;AACrB;",
   "names": []
 }