@enjoys/context-engine 1.2.0 → 1.4.1

package/data/hover/angular.json

@@ -0,0 +1,455 @@
+{
+  "language": "angular",
+  "hovers": {
+    "Component": {
+      "contents": [
+        { "value": "```typescript\n@Component(metadata: ComponentMetadata)\n```\nDecorator that marks a class as an Angular component and supplies configuration metadata including template, styles, selector, and change detection strategy.\n\n```typescript\n@Component({\n  selector: 'app-root',\n  standalone: true,\n  templateUrl: './app.component.html',\n  styleUrls: ['./app.component.css'],\n  changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport class AppComponent {}\n```" }
+      ]
+    },
+    "NgModule": {
+      "contents": [
+        { "value": "```typescript\n@NgModule(metadata: NgModuleMetadata)\n```\nDecorator that marks a class as an NgModule with declarations, imports, providers, exports, and bootstrap arrays.\n\n```typescript\n@NgModule({\n  declarations: [AppComponent],\n  imports: [BrowserModule],\n  providers: [],\n  bootstrap: [AppComponent]\n})\nexport class AppModule {}\n```" }
+      ]
+    },
+    "Injectable": {
+      "contents": [
+        { "value": "```typescript\n@Injectable(options?: { providedIn: 'root' | 'platform' | 'any' | Type<any> | null })\n```\nDecorator that marks a class as available to be provided and injected as a dependency.\n\n```typescript\n@Injectable({ providedIn: 'root' })\nexport class DataService {\n  constructor(private http: HttpClient) {}\n}\n```" }
+      ]
+    },
+    "Directive": {
+      "contents": [
+        { "value": "```typescript\n@Directive(metadata: DirectiveMetadata)\n```\nDecorator that marks a class as an Angular directive with a CSS selector.\n\n```typescript\n@Directive({\n  selector: '[appHighlight]',\n  standalone: true\n})\nexport class HighlightDirective {}\n```" }
+      ]
+    },
+    "Pipe": {
+      "contents": [
+        { "value": "```typescript\n@Pipe(metadata: { name: string; standalone?: boolean; pure?: boolean })\n```\nDecorator that marks a class as a pipe and supplies a name for template use.\n\n```typescript\n@Pipe({ name: 'truncate', standalone: true })\nexport class TruncatePipe implements PipeTransform {\n  transform(value: string, limit: number): string {\n    return value.length > limit ? value.substring(0, limit) + '...' : value;\n  }\n}\n```" }
+      ]
+    },
+    "Input": {
+      "contents": [
+        { "value": "```typescript\n@Input(bindingPropertyName?: string)\n```\nDecorator that marks a class field as an input property. Bound to a DOM property in the template.\n\n```typescript\n@Input() title: string = '';\n@Input({ required: true }) id!: number;\n@Input({ alias: 'userName' }) name = '';\n```" }
+      ]
+    },
+    "Output": {
+      "contents": [
+        { "value": "```typescript\n@Output(bindingPropertyName?: string)\n```\nDecorator that marks a class field as an output property. Used with EventEmitter.\n\n```typescript\n@Output() clicked = new EventEmitter<void>();\n@Output('onSave') saved = new EventEmitter<Data>();\n```" }
+      ]
+    },
+    "ViewChild": {
+      "contents": [
+        { "value": "```typescript\n@ViewChild(selector: Type<any> | string, opts?: { read?: any; static?: boolean })\n```\nConfigures a view query for the first matching element or directive in the view DOM.\n\n```typescript\n@ViewChild('myInput') inputRef!: ElementRef;\n@ViewChild(ChildComponent) child!: ChildComponent;\n```" }
+      ]
+    },
+    "ViewChildren": {
+      "contents": [
+        { "value": "```typescript\n@ViewChildren(selector: Type<any> | string, opts?: { read?: any })\n```\nConfigures a view query for all matching elements or directives.\n\n```typescript\n@ViewChildren(ItemComponent) items!: QueryList<ItemComponent>;\n```" }
+      ]
+    },
+    "ContentChild": {
+      "contents": [
+        { "value": "```typescript\n@ContentChild(selector: Type<any> | string, opts?: { read?: any; static?: boolean })\n```\nConfigures a content query for the first matching element in projected content.\n\n```typescript\n@ContentChild(TemplateRef) template!: TemplateRef<any>;\n```" }
+      ]
+    },
+    "ContentChildren": {
+      "contents": [
+        { "value": "```typescript\n@ContentChildren(selector: Type<any> | string, opts?: { read?: any; descendants?: boolean })\n```\nConfigures a content query for all matching elements in projected content.\n\n```typescript\n@ContentChildren(TabComponent) tabs!: QueryList<TabComponent>;\n```" }
+      ]
+    },
+    "HostBinding": {
+      "contents": [
+        { "value": "```typescript\n@HostBinding(hostPropertyName?: string)\n```\nMarks a DOM property or attribute as a host-binding property.\n\n```typescript\n@HostBinding('class.active') isActive = false;\n@HostBinding('style.color') color = 'red';\n```" }
+      ]
+    },
+    "HostListener": {
+      "contents": [
+        { "value": "```typescript\n@HostListener(eventName: string, args?: string[])\n```\nDeclares a host event listener. Angular invokes the decorated method when the host element emits the event.\n\n```typescript\n@HostListener('click', ['$event'])\nonClick(event: MouseEvent): void { }\n```" }
+      ]
+    },
+    "Inject": {
+      "contents": [
+        { "value": "```typescript\n@Inject(token: any)\n```\nSpecifies a custom provider via an injection token.\n\n```typescript\nconstructor(@Inject(API_URL) private apiUrl: string) {}\n```" }
+      ]
+    },
+    "Optional": {
+      "contents": [
+        { "value": "```typescript\n@Optional()\n```\nMarks a dependency as optional. The injector provides `null` if the dependency is not found.\n\n```typescript\nconstructor(@Optional() private logger?: LoggerService) {}\n```" }
+      ]
+    },
+    "Self": {
+      "contents": [
+        { "value": "```typescript\n@Self()\n```\nInstructs the DI framework to resolve a dependency only from the local injector." }
+      ]
+    },
+    "SkipSelf": {
+      "contents": [
+        { "value": "```typescript\n@SkipSelf()\n```\nInstructs the DI framework to resolve a dependency starting from the parent injector." }
+      ]
+    },
+    "Host": {
+      "contents": [
+        { "value": "```typescript\n@Host()\n```\nInstructs the DI framework to resolve a dependency from the host element's injector." }
+      ]
+    },
+    "OnInit": {
+      "contents": [
+        { "value": "```typescript\ninterface OnInit {\n  ngOnInit(): void;\n}\n```\nLifecycle hook called once after the first `ngOnChanges`. Use for initialization logic.\n\n```typescript\nexport class MyComponent implements OnInit {\n  ngOnInit(): void {\n    // initialization\n  }\n}\n```" }
+      ]
+    },
+    "OnDestroy": {
+      "contents": [
+        { "value": "```typescript\ninterface OnDestroy {\n  ngOnDestroy(): void;\n}\n```\nLifecycle hook called when the directive/component is destroyed. Use for cleanup.\n\n```typescript\nexport class MyComponent implements OnDestroy {\n  ngOnDestroy(): void {\n    this.subscription.unsubscribe();\n  }\n}\n```" }
+      ]
+    },
+    "OnChanges": {
+      "contents": [
+        { "value": "```typescript\ninterface OnChanges {\n  ngOnChanges(changes: SimpleChanges): void;\n}\n```\nLifecycle hook called when any data-bound input property changes. Receives a `SimpleChanges` object." }
+      ]
+    },
+    "AfterViewInit": {
+      "contents": [
+        { "value": "```typescript\ninterface AfterViewInit {\n  ngAfterViewInit(): void;\n}\n```\nLifecycle hook called after the component's view and child views have been fully initialized." }
+      ]
+    },
+    "AfterContentInit": {
+      "contents": [
+        { "value": "```typescript\ninterface AfterContentInit {\n  ngAfterContentInit(): void;\n}\n```\nLifecycle hook called after Angular projects external content into the component." }
+      ]
+    },
+    "DoCheck": {
+      "contents": [
+        { "value": "```typescript\ninterface DoCheck {\n  ngDoCheck(): void;\n}\n```\nLifecycle hook called during every change detection run. Use to detect changes Angular cannot." }
+      ]
+    },
+    "AfterViewChecked": {
+      "contents": [
+        { "value": "```typescript\ninterface AfterViewChecked {\n  ngAfterViewChecked(): void;\n}\n```\nLifecycle hook called after every check of the component's view." }
+      ]
+    },
+    "AfterContentChecked": {
+      "contents": [
+        { "value": "```typescript\ninterface AfterContentChecked {\n  ngAfterContentChecked(): void;\n}\n```\nLifecycle hook called after every check of projected content." }
+      ]
+    },
+    "signal": {
+      "contents": [
+        { "value": "```typescript\nfunction signal<T>(initialValue: T, options?: CreateSignalOptions<T>): WritableSignal<T>\n```\nCreates a writable signal with an initial value. Signals are reactive primitives that notify consumers when they change.\n\n```typescript\nconst count = signal(0);\ncount.set(5);\ncount.update(v => v + 1);\nconsole.log(count()); // 6\n```" }
+      ]
+    },
+    "computed": {
+      "contents": [
+        { "value": "```typescript\nfunction computed<T>(computation: () => T): Signal<T>\n```\nCreates a memoized signal that derives its value from other signals. Re-evaluates only when dependencies change.\n\n```typescript\nconst count = signal(2);\nconst doubled = computed(() => count() * 2);\nconsole.log(doubled()); // 4\n```" }
+      ]
+    },
+    "effect": {
+      "contents": [
+        { "value": "```typescript\nfunction effect(effectFn: () => void, options?: CreateEffectOptions): EffectRef\n```\nCreates an effect that runs a side-effectful function whenever one of the signals it reads changes.\n\n```typescript\neffect(() => {\n  console.log('Count changed:', this.count());\n});\n```" }
+      ]
+    },
+    "input": {
+      "contents": [
+        { "value": "```typescript\nfunction input<T>(initialValue?: T): InputSignal<T>\n```\nSignal-based input property. Alternative to `@Input` decorator with signal semantics.\n\n```typescript\nname = input<string>();          // optional\nid = input.required<number>();   // required\nalias = input('default');        // with default\n```" }
+      ]
+    },
+    "output": {
+      "contents": [
+        { "value": "```typescript\nfunction output<T>(): OutputEmitterRef<T>\n```\nSignal-based output property. Alternative to `@Output` decorator.\n\n```typescript\nclicked = output<void>();\nthis.clicked.emit();\n```" }
+      ]
+    },
+    "model": {
+      "contents": [
+        { "value": "```typescript\nfunction model<T>(initialValue?: T): ModelSignal<T>\n```\nCreates a model signal for two-way data binding. Combines input and output in a single API.\n\n```typescript\nvalue = model<string>('');  // parent uses [(value)]\n```" }
+      ]
+    },
+    "viewChild": {
+      "contents": [
+        { "value": "```typescript\nfunction viewChild<T>(locator: string | Type<T>): Signal<T | undefined>\n```\nSignal-based view child query. Returns a signal that updates when the queried element changes.\n\n```typescript\nmyInput = viewChild<ElementRef>('myInput');\nmyInputRequired = viewChild.required<ElementRef>('myInput');\n```" }
+      ]
+    },
+    "viewChildren": {
+      "contents": [
+        { "value": "```typescript\nfunction viewChildren<T>(locator: string | Type<T>): Signal<ReadonlyArray<T>>\n```\nSignal-based view children query. Returns a signal with all matching elements." }
+      ]
+    },
+    "contentChild": {
+      "contents": [
+        { "value": "```typescript\nfunction contentChild<T>(locator: string | Type<T>): Signal<T | undefined>\n```\nSignal-based content child query. Queries projected content for a single matching element." }
+      ]
+    },
+    "contentChildren": {
+      "contents": [
+        { "value": "```typescript\nfunction contentChildren<T>(locator: string | Type<T>): Signal<ReadonlyArray<T>>\n```\nSignal-based content children query. Queries all matching projected content elements." }
+      ]
+    },
+    "linkedSignal": {
+      "contents": [
+        { "value": "```typescript\nfunction linkedSignal<T>(computation: () => T): WritableSignal<T>\n```\nCreates a writable signal that resets to a computed value whenever a source signal changes.\n\n```typescript\nconst selected = linkedSignal(() => this.items()[0]);\n```" }
+      ]
+    },
+    "resource": {
+      "contents": [
+        { "value": "```typescript\nfunction resource<T, R>(options: ResourceOptions<T, R>): ResourceRef<R>\n```\nCreates a resource that loads data asynchronously based on a reactive request signal.\n\n```typescript\nconst userData = resource({\n  request: () => this.userId(),\n  loader: async ({ request: id }) => fetch(`/api/users/${id}`)\n});\n```" }
+      ]
+    },
+    "toSignal": {
+      "contents": [
+        { "value": "```typescript\nfunction toSignal<T>(source: Observable<T>, options?: ToSignalOptions<T>): Signal<T>\n```\nConverts an Observable to a signal. Values emitted by the Observable update the signal.\n\n```typescript\nconst data = toSignal(this.data$, { initialValue: [] });\n```" }
+      ]
+    },
+    "toObservable": {
+      "contents": [
+        { "value": "```typescript\nfunction toObservable<T>(source: Signal<T>): Observable<T>\n```\nConverts a signal to an Observable that emits whenever the signal value changes." }
+      ]
+    },
+    "EventEmitter": {
+      "contents": [
+        { "value": "```typescript\nclass EventEmitter<T = any> extends Subject<T>\n```\nUse in directives and components to emit custom events.\n\n```typescript\n@Output() clicked = new EventEmitter<MouseEvent>();\nthis.clicked.emit(event);\n```" }
+      ]
+    },
+    "ChangeDetectionStrategy": {
+      "contents": [
+        { "value": "```typescript\nenum ChangeDetectionStrategy {\n  OnPush = 0,\n  Default = 1\n}\n```\nDefines the change detection strategy. `OnPush` checks only when inputs change or events fire.\n\n```typescript\n@Component({\n  changeDetection: ChangeDetectionStrategy.OnPush\n})\n```" }
+      ]
+    },
+    "ViewEncapsulation": {
+      "contents": [
+        { "value": "```typescript\nenum ViewEncapsulation {\n  Emulated = 0,\n  None = 2,\n  ShadowDom = 3\n}\n```\nDefines template and style encapsulation options.\n\n- **Emulated** (default): Scoped styles via attribute selectors\n- **None**: Global styles, no encapsulation\n- **ShadowDom**: Native Shadow DOM" }
+      ]
+    },
+    "ChangeDetectorRef": {
+      "contents": [
+        { "value": "```typescript\nabstract class ChangeDetectorRef\n```\nProvides change detection methods: `detectChanges()`, `markForCheck()`, `detach()`, `reattach()`.\n\n```typescript\nconstructor(private cdr: ChangeDetectorRef) {}\nthis.cdr.markForCheck();\n```" }
+      ]
+    },
+    "ElementRef": {
+      "contents": [
+        { "value": "```typescript\nclass ElementRef<T = any> {\n  nativeElement: T;\n}\n```\nWrapper around a native element. Use with caution as direct DOM access bypasses Angular's templating." }
+      ]
+    },
+    "TemplateRef": {
+      "contents": [
+        { "value": "```typescript\nabstract class TemplateRef<C>\n```\nRepresents an embedded template that can be used to instantiate embedded views." }
+      ]
+    },
+    "ViewContainerRef": {
+      "contents": [
+        { "value": "```typescript\nabstract class ViewContainerRef\n```\nContainer where views can be attached. Provides `createComponent()`, `createEmbeddedView()`, `insert()`, `remove()`, etc." }
+      ]
+    },
+    "Renderer2": {
+      "contents": [
+        { "value": "```typescript\nabstract class Renderer2\n```\nPlatform-agnostic DOM rendering abstraction. Methods include `createElement()`, `setAttribute()`, `setStyle()`, `listen()`." }
+      ]
+    },
+    "NgZone": {
+      "contents": [
+        { "value": "```typescript\nclass NgZone\n```\nService for executing work inside or outside Angular's zone.\n\n```typescript\nthis.ngZone.runOutsideAngular(() => {\n  // No change detection triggered\n});\n```" }
+      ]
+    },
+    "FormControl": {
+      "contents": [
+        { "value": "```typescript\nclass FormControl<T = any> extends AbstractControl\n```\nTracks the value and validation status of an individual form control.\n\n```typescript\nconst name = new FormControl('', Validators.required);\nconsole.log(name.value);  // ''\nconsole.log(name.valid);  // false\n```" }
+      ]
+    },
+    "FormGroup": {
+      "contents": [
+        { "value": "```typescript\nclass FormGroup extends AbstractControl\n```\nTracks the value and validity of a group of FormControl instances.\n\n```typescript\nconst form = new FormGroup({\n  name: new FormControl(''),\n  email: new FormControl('', Validators.email)\n});\n```" }
+      ]
+    },
+    "FormBuilder": {
+      "contents": [
+        { "value": "```typescript\nclass FormBuilder\n```\nReduces boilerplate for creating reactive forms.\n\n```typescript\nconstructor(private fb: FormBuilder) {}\nthis.form = this.fb.group({\n  name: ['', Validators.required],\n  email: ['', [Validators.required, Validators.email]]\n});\n```" }
+      ]
+    },
+    "FormArray": {
+      "contents": [
+        { "value": "```typescript\nclass FormArray extends AbstractControl\n```\nTracks the value and validity of an array of form controls.\n\n```typescript\nconst arr = new FormArray([\n  new FormControl('item1'),\n  new FormControl('item2')\n]);\n```" }
+      ]
+    },
+    "Validators": {
+      "contents": [
+        { "value": "```typescript\nclass Validators\n```\nBuilt-in validators: `required`, `minLength(n)`, `maxLength(n)`, `pattern(regex)`, `email`, `min(n)`, `max(n)`, `requiredTrue`, `compose()`, `composeAsync()`." }
+      ]
+    },
+    "Router": {
+      "contents": [
+        { "value": "```typescript\nclass Router\n```\nService for navigation among views. Key methods: `navigate()`, `navigateByUrl()`, `createUrlTree()`.\n\n```typescript\nconstructor(private router: Router) {}\nthis.router.navigate(['/dashboard']);\n```" }
+      ]
+    },
+    "ActivatedRoute": {
+      "contents": [
+        { "value": "```typescript\nclass ActivatedRoute\n```\nProvides access to route information: `params`, `queryParams`, `data`, `paramMap`, `snapshot`, `url`.\n\n```typescript\nconstructor(private route: ActivatedRoute) {}\nthis.route.params.subscribe(p => console.log(p['id']));\n```" }
+      ]
+    },
+    "RouterOutlet": {
+      "contents": [
+        { "value": "```typescript\n<router-outlet></router-outlet>\n```\nPlaceholder directive that Angular dynamically fills with the component matching the current route." }
+      ]
+    },
+    "HttpClient": {
+      "contents": [
+        { "value": "```typescript\nclass HttpClient\n```\nInjectable service for HTTP requests. Methods: `get()`, `post()`, `put()`, `delete()`, `patch()`, `request()`.\n\n```typescript\nthis.http.get<User[]>('/api/users').subscribe(users => { });\n```" }
+      ]
+    },
+    "HttpInterceptor": {
+      "contents": [
+        { "value": "```typescript\ninterface HttpInterceptor {\n  intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>;\n}\n```\nInterface for interceptors that transform outgoing requests and incoming responses." }
+      ]
+    },
+    "provideRouter": {
+      "contents": [
+        { "value": "```typescript\nfunction provideRouter(routes: Routes, ...features: RouterFeatures[]): EnvironmentProviders\n```\nSets up router providers for standalone apps.\n\n```typescript\nbootstrapApplication(AppComponent, {\n  providers: [provideRouter(routes, withComponentInputBinding())]\n});\n```" }
+      ]
+    },
+    "provideHttpClient": {
+      "contents": [
+        { "value": "```typescript\nfunction provideHttpClient(...features: HttpFeature[]): EnvironmentProviders\n```\nSets up HttpClient providers for standalone apps.\n\n```typescript\nprovideHttpClient(withInterceptors([authInterceptor]), withFetch())\n```" }
+      ]
+    },
+    "bootstrapApplication": {
+      "contents": [
+        { "value": "```typescript\nfunction bootstrapApplication(rootComponent: Type<unknown>, options?: ApplicationConfig): Promise<ApplicationRef>\n```\nBootstraps a standalone Angular application.\n\n```typescript\nbootstrapApplication(AppComponent, appConfig)\n  .catch(err => console.error(err));\n```" }
+      ]
+    },
+    "NgIf": {
+      "contents": [
+        { "value": "```html\n<div *ngIf=\"condition\">...</div>\n<div *ngIf=\"condition; else elseBlock\">...</div>\n```\nStructural directive that conditionally includes a template. Consider using `@if` for new projects." }
+      ]
+    },
+    "NgFor": {
+      "contents": [
+        { "value": "```html\n<li *ngFor=\"let item of items; trackBy: trackById\">{{ item.name }}</li>\n```\nStructural directive that renders a template for each item. Consider using `@for` for new projects." }
+      ]
+    },
+    "AsyncPipe": {
+      "contents": [
+        { "value": "```html\n{{ observable$ | async }}\n```\nSubscribes to an Observable or Promise and returns the latest value. Automatically unsubscribes on destroy." }
+      ]
+    },
+    "inject": {
+      "contents": [
+        { "value": "```typescript\nfunction inject<T>(token: ProviderToken<T>, options?: InjectOptions): T\n```\nInjects a dependency from the current injector context. Must be called in an injection context (constructor, factory, etc.).\n\n```typescript\nconst http = inject(HttpClient);\nconst router = inject(Router);\n```" }
+      ]
+    },
+    "takeUntilDestroyed": {
+      "contents": [
+        { "value": "```typescript\nfunction takeUntilDestroyed(destroyRef?: DestroyRef): MonoTypeOperatorFunction<T>\n```\nRxJS operator that completes an Observable when the component/service is destroyed.\n\n```typescript\nthis.data$.pipe(takeUntilDestroyed()).subscribe(...);\n```" }
+      ]
+    },
+    "DestroyRef": {
+      "contents": [
+        { "value": "```typescript\nabstract class DestroyRef\n```\nAllows registering cleanup callbacks.\n\n```typescript\nconst destroyRef = inject(DestroyRef);\ndestroyRef.onDestroy(() => cleanup());\n```" }
+      ]
+    },
+    "Injector": {
+      "contents": [
+        { "value": "```typescript\nabstract class Injector\n```\nRetrieves instances of dependencies by token. Can be used to manually resolve dependencies." }
+      ]
+    },
+    "InjectionToken": {
+      "contents": [
+        { "value": "```typescript\nclass InjectionToken<T>\n```\nCreates a DI token for cases where the type alone is insufficient to identify a dependency.\n\n```typescript\nexport const API_URL = new InjectionToken<string>('API_URL');\n```" }
+      ]
+    },
+    "ApplicationConfig": {
+      "contents": [
+        { "value": "```typescript\ninterface ApplicationConfig {\n  providers: Array<Provider | EnvironmentProviders>;\n}\n```\nConfiguration for bootstrapping a standalone application." }
+      ]
+    },
+    "RouterModule": {
+      "contents": [
+        { "value": "```typescript\nclass RouterModule\n```\nAdds router directives and providers. Use `RouterModule.forRoot(routes)` in the root module and `RouterModule.forChild(routes)` in feature modules." }
+      ]
+    },
+    "RouterLink": {
+      "contents": [
+        { "value": "```html\n<a [routerLink]=\"['/path']\">Link</a>\n```\nDirective that turns user clicks into router navigations. Can be applied to any element." }
+      ]
+    },
+    "RouterLinkActive": {
+      "contents": [
+        { "value": "```html\n<a routerLink=\"/home\" routerLinkActive=\"active\">Home</a>\n```\nTracks whether the linked route is currently active and sets CSS classes." }
+      ]
+    },
+    "ReactiveFormsModule": {
+      "contents": [
+        { "value": "```typescript\nclass ReactiveFormsModule\n```\nProvides directives for reactive forms: `formControl`, `formGroup`, `formArrayName`, `formControlName`." }
+      ]
+    },
+    "FormsModule": {
+      "contents": [
+        { "value": "```typescript\nclass FormsModule\n```\nProvides `ngModel` and related directives for template-driven forms." }
+      ]
+    },
+    "CommonModule": {
+      "contents": [
+        { "value": "```typescript\nclass CommonModule\n```\nExports all the basic Angular directives and pipes: NgIf, NgFor, NgClass, NgStyle, DatePipe, AsyncPipe, etc." }
+      ]
+    },
+    "NgClass": {
+      "contents": [
+        { "value": "```html\n<div [ngClass]=\"{ 'active': isActive, 'disabled': isDisabled }\">...</div>\n```\nAdds and removes CSS classes based on an expression." }
+      ]
+    },
+    "NgStyle": {
+      "contents": [
+        { "value": "```html\n<div [ngStyle]=\"{ 'color': textColor, 'font-size': fontSize + 'px' }\">...</div>\n```\nUpdates inline styles based on an expression." }
+      ]
+    },
+    "NgSwitch": {
+      "contents": [
+        { "value": "```html\n<div [ngSwitch]=\"value\">\n  <p *ngSwitchCase=\"'a'\">A</p>\n  <p *ngSwitchDefault>Default</p>\n</div>\n```\nSwitches templates based on matching values." }
+      ]
+    },
+    "DatePipe": {
+      "contents": [
+        { "value": "```html\n{{ dateValue | date:'short' }}\n{{ dateValue | date:'yyyy-MM-dd' }}\n```\nFormats a date value according to locale rules and a format string." }
+      ]
+    },
+    "CurrencyPipe": {
+      "contents": [
+        { "value": "```html\n{{ amount | currency:'USD':'symbol':'1.2-2' }}\n```\nTransforms a number to a currency string according to locale rules." }
+      ]
+    },
+    "KeyValuePipe": {
+      "contents": [
+        { "value": "```html\n@for (item of map | keyvalue; track item.key) {\n  {{ item.key }}: {{ item.value }}\n}\n```\nTransforms Object or Map into an array of key-value pairs." }
+      ]
+    },
+    "withInterceptors": {
+      "contents": [
+        { "value": "```typescript\nfunction withInterceptors(interceptors: HttpInterceptorFn[]): HttpFeature\n```\nConfigures functional HTTP interceptors.\n\n```typescript\nprovideHttpClient(withInterceptors([authInterceptor, loggingInterceptor]))\n```" }
+      ]
+    },
+    "withFetch": {
+      "contents": [
+        { "value": "```typescript\nfunction withFetch(): HttpFeature\n```\nConfigures HttpClient to use the Fetch API instead of XMLHttpRequest." }
+      ]
+    },
+    "withComponentInputBinding": {
+      "contents": [
+        { "value": "```typescript\nfunction withComponentInputBinding(): RouterFeature\n```\nBinds route parameters directly to component inputs.\n\n```typescript\nprovideRouter(routes, withComponentInputBinding())\n```" }
+      ]
+    },
+    "importProvidersFrom": {
+      "contents": [
+        { "value": "```typescript\nfunction importProvidersFrom(...sources: ImportProvidersSource[]): EnvironmentProviders\n```\nCollects providers from NgModules for standalone configuration.\n\n```typescript\nimportProvidersFrom(BrowserAnimationsModule)\n```" }
+      ]
+    },
+    "provideZoneChangeDetection": {
+      "contents": [
+        { "value": "```typescript\nfunction provideZoneChangeDetection(options?: { eventCoalescing?: boolean }): EnvironmentProviders\n```\nProvides NgZone-based change detection with optional event coalescing." }
+      ]
+    },
+    "HttpHeaders": {
+      "contents": [
+        { "value": "```typescript\nclass HttpHeaders\n```\nImmutable HTTP headers. Create with `new HttpHeaders({ 'Content-Type': 'application/json' })`." }
+      ]
+    },
+    "HttpParams": {
+      "contents": [
+        { "value": "```typescript\nclass HttpParams\n```\nImmutable URL parameters. Chain with `.set()`, `.append()`, `.delete()`.\n\n```typescript\nnew HttpParams().set('page', '1').set('limit', '10')\n```" }
+      ]
+    }
+  }
+}