@magicx-eng/ai-autocomplete-angular 0.27.0 → 0.28.0

package/esm2020/lib/controller/ai-autocomplete.controller.mjs

@@ -262,6 +262,16 @@ export class AIAutocompleteController {
             return;
         this.core.setActiveDropdownIndex(index);
     }
+    /**
+     * The pointer left option `index`: clear the highlight if it is still on it,
+     * so Enter afterwards submits instead of picking an option the pointer is no
+     * longer on. A highlight the keyboard has since moved is left alone.
+     */
+    clearHighlight(index) {
+        if (this.isDestroyed)
+            return;
+        this.core.clearHighlight(index);
+    }
     /** Page the datepicker back one month. No-op unless a date pill is active. */
     showPreviousMonth() {
         if (this.isDestroyed)
@@ -400,4 +410,4 @@ function computeDropdown(s, optionsPosition) {
         optionsPosition,
     };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ai-autocomplete.controller.js","sourceRoot":"","sources":["../../../../src/lib/controller/ai-autocomplete.controller.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  type AutocompleteResult,\n  type CompletedParamState,\n  AIAutocomplete as CoreAIAutocomplete,\n  type CoreState,\n  type CustomFieldsReport,\n  dateSelectionFor,\n  type IdentifiedParamState,\n  identifiedParamLabel,\n  type Product,\n  type Segment,\n  type SkippedParamState,\n  type Suggestion,\n  type SuggestionOption,\n} from \"@magicx-eng/ai-autocomplete-vanilla\";\nimport { BehaviorSubject, combineLatest, map, type Observable, shareReplay } from \"rxjs\";\nimport type {\n  AIAutocompleteControllerOptions,\n  AIAutocompleteControllerState,\n  AIAutocompleteControllerUpdate,\n  AIAutocompleteDropdownState,\n} from \"../shared/types\";\nimport { deriveField } from \"./observables\";\n\n/**\n * Tier 2 logic surface for `@magicx-eng/ai-autocomplete-angular` — the Angular\n * equivalent of React's `useAIAutocomplete()` hook. Wraps a headless\n * `@magicx-eng/ai-autocomplete-vanilla` core and exposes its state as RxJS\n * observables plus thin action methods.\n *\n * The controller is consumer-managed — the consumer creates it\n * with `new`, holds the reference, and **must call `destroy()`** in their\n * own `ngOnDestroy`. The Tier 1 `<ai-autocomplete>` component does this\n * automatically; Tier 2 consumers do not get auto-cleanup.\n *\n * @public\n */\nexport class AIAutocompleteController {\n  private readonly core: CoreAIAutocomplete;\n  private readonly rawState$: BehaviorSubject<CoreState>;\n  // optionsPosition isn't part of CoreState (it's a core option), so track it\n  // here and fold it into `dropdown$` so the dropdown can read placement from\n  // the controller — configured once, kept in sync through update().\n  private readonly optionsPosition$ = new BehaviorSubject<\"above\" | \"below\">(\"below\");\n  private readonly unsubscribeCore: () => void;\n  private isDestroyed = false;\n\n  // === Per-field observables ===\n  // Each one runs through deriveField, which bakes in distinctUntilChanged\n  // and shareReplay({ bufferSize: 1, refCount: true }) per §19.4.\n\n  /** Plain-text content of the editor. */\n  readonly text$: Observable<string>;\n  /** Completed (bold) params currently in the editor. */\n  readonly completedParams$: Observable<CompletedParamState[]>;\n  /**\n   * Suggestions the user dismissed with the skip key (→). Nothing renders\n   * them; they exist so a hand-rolled submit can pass them to\n   * `buildSubmitResult` and carry the same `text: \"skipped\"` entries the\n   * SDK's own requests do.\n   */\n  readonly skippedParams$: Observable<SkippedParamState[]>;\n  /**\n   * Params the server identified in the user's own words. Already rendered\n   * through `segments$`; exposed so a hand-rolled submit can pass them to\n   * `buildSubmitResult` and report the same `identified_params` the SDK's\n   * own results carry.\n   */\n  readonly identifiedParams$: Observable<IdentifiedParamState[]>;\n  /** Actionable suggestion pills (first one is the active pill). */\n  readonly suggestionPills$: Observable<Suggestion[]>;\n  /** Text + completed-param segments for rendering the editor body. */\n  readonly segments$: Observable<Segment[]>;\n  /** ID of the most-recently-promoted param (drives shimmer animation). */\n  readonly newParamId$: Observable<string | null>;\n  /** All suggestions from the server (including non-actionable ones). */\n  readonly suggestions$: Observable<Suggestion[]>;\n  /**\n   * What the product strip shows: the items the latest `/suggest` response\n   * reported as matching the query, or — with `products` configured on the\n   * controller — the results of that custom search.\n   */\n  readonly products$: Observable<Product[]>;\n  /**\n   * The catalog grounding report the latest response carried, or null when it\n   * carried none: which of the query's constraints the catalog applied, which\n   * it dropped, and how many items (and which) the applied ones left\n   * standing. Null is \"no news\", not an empty catalog.\n   */\n  readonly customFields$: Observable<CustomFieldsReport | null>;\n  /** Currently highlighted dropdown option index. -1 = none. */\n  readonly activeIndex$: Observable<number>;\n  /**\n   * UI-visible loading flag — suppressed during the post-select press\n   * animation and during re-edit (cached options stay visible there). Use\n   * this instead of the raw core state for any loading-skeleton binding.\n   */\n  readonly isLoading$: Observable<boolean>;\n  /** Server-reported \"query is complete\" flag. */\n  readonly isReady$: Observable<boolean>;\n  /** Whether the editor currently has focus. */\n  readonly isFocused$: Observable<boolean>;\n  /** Whether the dropdown should currently be visible. */\n  readonly isDropdownOpen$: Observable<boolean>;\n  /**\n   * Whether the active (leading) pill should render selected (full opacity)\n   * rather than the de-emphasized `first` tier. Auto trigger ⇒ true only while\n   * a dropdown option is highlighted; manual ⇒ true once the pill is tapped.\n   */\n  readonly isActivePillSelected$: Observable<boolean>;\n  /** Server-suggested placeholder text for the editor. */\n  readonly placeholderText$: Observable<string>;\n  /** Last fetch error, or null. */\n  readonly error$: Observable<Error | null>;\n  /** Param currently being re-edited, or null. */\n  readonly editingParam$: Observable<CompletedParamState | null>;\n  /** Plain-text offset where the edit region starts, or null. */\n  readonly editingAnchor$: Observable<number | null>;\n  /** Live caret offset within the editor. */\n  readonly caretOffset$: Observable<number | null>;\n\n  // === Composite observables ===\n\n  /**\n   * Snapshot of every public field in one object. Convenient for\n   * `*ngIf=\"ctrl.state$ | async as state\"` templating — aliases all fields\n   * under a single subscription instead of multiple `| async` pipes.\n   */\n  readonly state$: Observable<AIAutocompleteControllerState>;\n\n  /**\n   * Composite state for the dropdown view. Tier 2 consumers spread this into\n   * `<ai-autocomplete-dropdown>`; Tier 1 uses the same shape internally.\n   */\n  readonly dropdown$: Observable<AIAutocompleteDropdownState>;\n\n  /**\n   * Throws if invoked outside a browser environment. For SSR / Angular\n   * Universal, gate construction with `isPlatformBrowser`.\n   */\n  constructor(opts: AIAutocompleteControllerOptions = {}) {\n    if (typeof document === \"undefined\") {\n      throw new Error(\n        \"AIAutocompleteController requires a browser environment. \" +\n          \"For SSR / Angular Universal, gate construction with isPlatformBrowser.\",\n      );\n    }\n\n    // Headless mode never renders to the host, so a throwaway div is fine —\n    // it's required by the core's signature for symmetry with full mode.\n    const host = document.createElement(\"div\");\n\n    this.core = new CoreAIAutocomplete(host, {\n      ...opts,\n      renderMode: \"headless\",\n      source: opts.source ?? \"headless-sdk\",\n      // Headless mode never renders the dropdown DOM, but the keyboard\n      // controller still reads `optionsPosition` to decide which vertical\n      // arrow opens the dropdown from the input.\n      optionsPosition: opts.optionsPosition ?? \"below\",\n    });\n\n    this.rawState$ = new BehaviorSubject<CoreState>(this.core.getState());\n    // Push the store's *current* state, not the snapshot the listener was\n    // handed. The core notifies listeners synchronously, and some actions\n    // trigger reentrant `store.set` calls (e.g. typing a non-matching char\n    // during re-edit makes the core synchronously exit re-edit and kick off a\n    // fetch).\n    //\n    // The core's store used to deliver such a nested set inline and then\n    // resume the outer listener loop, so a listener could be handed an older\n    // state (still in re-edit) *after* a newer one (re-edit exited) — which\n    // resurrected a stale `editingParam` and retriggered the editor's re-edit\n    // caret-park, yanking the caret back to where re-editing started. The\n    // store now queues notifications and drains them in order, so that\n    // out-of-order delivery can no longer happen at the source.\n    //\n    // Reading `getState()` at emission time is kept as belt-and-braces: it\n    // costs nothing (distinctUntilChanged downstream drops the duplicate\n    // emissions) and keeps this bridge correct for any future consumer that\n    // emits mid-cascade. React needs neither, since it batches renders and\n    // gates its caret effects on dependencies.\n    this.unsubscribeCore = this.core.subscribe(() => {\n      if (!this.isDestroyed) this.rawState$.next(this.core.getState());\n    });\n\n    // === Per-field observables ===\n    // Array-valued fields use shallow equality. The vanilla store spreads on\n    // every write (`store.set({ completedParams: [...] })`), so reference\n    // equality would re-fire downstream subscribers on every state tick even\n    // when the array's contents are unchanged. The other fields are\n    // primitives or stable object references, so default identity equality\n    // works fine.\n    this.text$ = deriveField(this.rawState$, (s) => s.text);\n    this.completedParams$ = deriveField(this.rawState$, (s) => s.completedParams, arrEq);\n    this.skippedParams$ = deriveField(this.rawState$, (s) => s.skippedParams, arrEq);\n    this.identifiedParams$ = deriveField(this.rawState$, (s) => s.identifiedParams, arrEq);\n    this.suggestionPills$ = deriveField(this.rawState$, (s) => s.actionableSuggestions, arrEq);\n    this.segments$ = deriveField(this.rawState$, (s) => s.segments, arrEq);\n    this.newParamId$ = deriveField(this.rawState$, (s) => s.newParamId);\n    this.suggestions$ = deriveField(this.rawState$, (s) => s.suggestions, arrEq);\n    this.products$ = deriveField(this.rawState$, (s) => s.products, arrEq);\n    this.customFields$ = deriveField(this.rawState$, (s) => s.customFields);\n    this.activeIndex$ = deriveField(this.rawState$, (s) => s.activeDropdownIndex);\n    this.isLoading$ = deriveField(this.rawState$, computeUiLoading);\n    this.isReady$ = deriveField(this.rawState$, (s) => s.isReady);\n    this.isFocused$ = deriveField(this.rawState$, (s) => s.isFocused);\n    this.isDropdownOpen$ = deriveField(this.rawState$, (s) => s.isDropdownOpen);\n    this.isActivePillSelected$ = deriveField(this.rawState$, (s) => s.isActivePillSelected);\n    this.placeholderText$ = deriveField(this.rawState$, (s) => s.placeholderText);\n    this.error$ = deriveField(this.rawState$, (s) => s.error);\n    this.editingParam$ = deriveField(this.rawState$, (s) => s.editingParam);\n    this.editingAnchor$ = deriveField(this.rawState$, (s) => s.editingAnchor);\n    this.caretOffset$ = deriveField(this.rawState$, (s) => s.caretOffset);\n\n    // === Composite observables ===\n    // Project directly off `rawState$` with a single map() so each store\n    // tick produces exactly ONE coherent state$ emission. Using\n    // `combineLatest` over the per-field observables here would fire one\n    // emission per inner-source tick (up to N per store update), and the\n    // editor-host directive's post-promote refocus would run against an\n    // intermediate state where `newParamId` was set but `segments` /\n    // `caretOffset` still held their old values — leaving the caret stuck\n    // at the pre-click position.\n    this.state$ = this.rawState$.pipe(\n      map(computeState),\n      shareReplay({ bufferSize: 1, refCount: true }),\n    );\n\n    this.optionsPosition$.next(opts.optionsPosition ?? \"below\");\n    this.dropdown$ = combineLatest([this.rawState$, this.optionsPosition$]).pipe(\n      map(([s, optionsPosition]) => computeDropdown(s, optionsPosition)),\n      shareReplay({ bufferSize: 1, refCount: true }),\n    );\n  }\n\n  // === Read-only accessors ===\n\n  /** Stable ARIA listbox ID for the dropdown. Pass to `<textarea aria-controls=\"...\">`. */\n  get listboxId(): string {\n    return this.core.listboxId;\n  }\n\n  /** Whether `destroy()` has been called. After destruction all action methods no-op. */\n  get destroyed(): boolean {\n    return this.isDestroyed;\n  }\n\n  /**\n   * Synchronous snapshot of the controller's current public state. Mirrors\n   * the latest emission of `state$`. Useful in callbacks where you can't\n   * `subscribe` (e.g. inside an event handler).\n   */\n  getState(): AIAutocompleteControllerState {\n    return computeState(this.rawState$.value);\n  }\n\n  /**\n   * The structured query as the SDK understands it right now — the same\n   * object `onResult` delivers after each response and `onSubmit` delivers\n   * on submit. Read it on demand from a place that has no event handy (a\n   * custom submit button, a \"save draft\" action).\n   */\n  getResult(): AutocompleteResult {\n    return this.core.getResult();\n  }\n\n  // === Action methods (pass-through to the core) ===\n  //\n  // Every action method begins with an `isDestroyed` guard so that callers\n  // who hold a stale reference after `destroy()` don't accidentally trigger\n  // work on a torn-down core. The vanilla core does not gate its own methods\n  // post-dispose — `reset()`, `handleTextChange()`, and friends would still\n  // schedule fetches or fire HTTP requests against an aborted controller,\n  // and the responses would have nowhere to surface (rawState$ is already\n  // complete). The guard makes the JSDoc-promised \"no-op silently\"\n  // semantics actually true.\n\n  /** Clear all state, rotate `session_id`, and re-fetch. Call after submit. */\n  reset(): void {\n    if (this.isDestroyed) return;\n    this.core.reset();\n  }\n\n  /** Pick a dropdown option (or replace the re-edited param if in re-edit mode). */\n  selectOption(option: SuggestionOption): void {\n    if (this.isDestroyed) return;\n    this.core.selectOption(option);\n  }\n\n  /**\n   * Announce a product selection — fires the `onProductSelect` callback the\n   * controller was constructed with. `<ai-autocomplete-dropdown>` calls this\n   * for you; consumers rendering their own strip call it themselves.\n   *\n   * Emitting is the whole behaviour: the SDK deliberately does not navigate to\n   * `product.url`, because only the integration knows whether a selection\n   * means \"open the PDP\", \"add to cart\", or \"fill the input\".\n   */\n  selectProduct(product: Product): void {\n    if (this.isDestroyed) return;\n    this.core.selectProduct(product);\n  }\n\n  /** Promote the pill at `index` to active (front of the list). */\n  setActivePill(index: number): void {\n    if (this.isDestroyed) return;\n    this.core.setActivePill(index);\n  }\n\n  /**\n   * Skip the active pill — same action as pressing → at the end of the input.\n   * The dropdown's skip button calls this; consumers rendering their own skip\n   * affordance call it directly. The skipped suggestion joins `skippedParams$`.\n   */\n  skipActivePill(): void {\n    if (this.isDestroyed) return;\n    this.core.skipActivePill();\n  }\n\n  /** Drop the last completed param's \"completed\" status. Text stays as plain text. */\n  removeLastParam(): void {\n    if (this.isDestroyed) return;\n    this.core.removeLastParam();\n  }\n\n  /** Clear the shimmer animation state for the most-recently-added param. */\n  clearNewParamId(): void {\n    if (this.isDestroyed) return;\n    this.core.clearNewParamId();\n  }\n\n  /** Controlled-mode setter for editor text. */\n  setValue(text: string): void {\n    if (this.isDestroyed) return;\n    this.core.setValue(text);\n  }\n\n  /** Controlled-mode setter for completed params. */\n  setCompletedParams(params: CompletedParamState[]): void {\n    if (this.isDestroyed) return;\n    this.core.setCompletedParams(params);\n  }\n\n  /** Forward plain-text input from the consumer's `<textarea>` to the core. */\n  handleTextChange(value: string): void {\n    if (this.isDestroyed) return;\n    this.core.handleTextChange(value);\n  }\n\n  /** Forward keyboard events from the consumer's `<textarea>` to the core. */\n  handleKeyDown(event: KeyboardEvent): void {\n    if (this.isDestroyed) return;\n    this.core.handleKeyDown(event);\n  }\n\n  /** Notify the core of focus state. */\n  setFocused(focused: boolean): void {\n    if (this.isDestroyed) return;\n    this.core.setFocused(focused);\n  }\n\n  /** Enter re-edit mode for the bold param with the given id. */\n  startEditingParam(paramId: string): void {\n    if (this.isDestroyed) return;\n    this.core.startEditingParam(paramId);\n  }\n\n  /** Exit re-edit mode without changing the bold param. */\n  exitEditMode(): void {\n    if (this.isDestroyed) return;\n    this.core.exitEditMode();\n  }\n\n  /** Forward post-input caret position (extends the edit tail). */\n  handleCaretAfterInput(offset: number | null): void {\n    if (this.isDestroyed) return;\n    this.core.handleCaretAfterInput(offset);\n  }\n\n  /** Forward selection-only caret moves (may exit re-edit). */\n  handleCaretMove(offset: number | null): void {\n    if (this.isDestroyed) return;\n    this.core.handleCaretMove(offset);\n  }\n\n  /** Replace the bold param being re-edited. Returns true when applied. */\n  replaceEditingRange(replacement: string): boolean {\n    if (this.isDestroyed) return false;\n    return this.core.replaceEditingRange(replacement);\n  }\n\n  /** Set the highlighted option index (typically driven by hover). */\n  setActiveDropdownIndex(index: number): void {\n    if (this.isDestroyed) return;\n    this.core.setActiveDropdownIndex(index);\n  }\n\n  /** Page the datepicker back one month. No-op unless a date pill is active. */\n  showPreviousMonth(): void {\n    if (this.isDestroyed) return;\n    this.core.showPreviousMonth();\n  }\n\n  /** Page the datepicker forward one month. No-op unless a date pill is active. */\n  showNextMonth(): void {\n    if (this.isDestroyed) return;\n    this.core.showNextMonth();\n  }\n\n  // === Lifecycle ===\n\n  /**\n   * Apply runtime changes to a subset of options. Event callbacks\n   * (`onSubmit`, `onResult`, `onError`, etc.) cannot be swapped this way — they are\n   * registered once at construction (matches the React hook's design). For\n   * dynamic event reactivity, subscribe to the corresponding observable\n   * (e.g. `text$` instead of `onChange`).\n   */\n  update(opts: AIAutocompleteControllerUpdate): void {\n    if (this.isDestroyed) return;\n    this.core.update(opts);\n    if (opts.optionsPosition !== undefined) {\n      this.optionsPosition$.next(opts.optionsPosition);\n    }\n  }\n\n  /**\n   * Release all resources — unsubscribes from the core, destroys the core,\n   * and completes the internal state subject. Safe to call multiple times.\n   * After destruction, action methods no-op silently.\n   */\n  destroy(): void {\n    if (this.isDestroyed) return;\n    this.isDestroyed = true;\n    this.unsubscribeCore();\n    this.core.destroy();\n    this.rawState$.complete();\n  }\n}\n\n// ===== Pure helpers — not part of the public surface =====\n\n/**\n * Shallow array equality. The vanilla store reassigns array fields on every\n * write (`store.set({ completedParams: [...prev, x] })`), so reference\n * equality alone would re-emit downstream even when the contents are\n * identical. Used for `completedParams$`, `suggestions$`, `suggestionPills$`,\n * and `segments$`.\n */\nfunction arrEq<T>(a: readonly T[], b: readonly T[]): boolean {\n  if (a === b) return true;\n  if (a.length !== b.length) return false;\n  for (let i = 0; i < a.length; i++) {\n    if (a[i] !== b[i]) return false;\n  }\n  return true;\n}\n\n/** UI-visible loading — the core's `dropdownLoading` (see its docs). */\nfunction computeUiLoading(s: CoreState): boolean {\n  return s.dropdownLoading;\n}\n\nfunction computeState(s: CoreState): AIAutocompleteControllerState {\n  return {\n    text: s.text,\n    completedParams: s.completedParams,\n    skippedParams: s.skippedParams,\n    identifiedParams: s.identifiedParams,\n    suggestionPills: s.actionableSuggestions,\n    segments: s.segments,\n    newParamId: s.newParamId,\n    suggestions: s.suggestions,\n    products: s.products,\n    customFields: s.customFields,\n    activeIndex: s.activeDropdownIndex,\n    isLoading: computeUiLoading(s),\n    isReady: s.isReady,\n    isFocused: s.isFocused,\n    isDropdownOpen: s.isDropdownOpen,\n    placeholderText: s.placeholderText,\n    error: s.error,\n    editingParam: s.editingParam,\n    editingIdentified: s.editingIdentified,\n    editingAnchor: s.editingAnchor,\n    caretOffset: s.caretOffset,\n  };\n}\n\nfunction computeDropdown(\n  s: CoreState,\n  optionsPosition: \"above\" | \"below\",\n): AIAutocompleteDropdownState {\n  const editingParam = s.editingParam;\n  const editingIdentified = s.editingIdentified;\n  const dateSelection = dateSelectionFor(s);\n  const activeSuggestion = s.actionableSuggestions[0];\n  const dropdownPill: Suggestion | null = editingParam\n    ? {\n        type: editingParam.suggestionType,\n        text: editingParam.suggestionPlaceholder,\n        required: true,\n        options: editingParam.options,\n      }\n    : editingIdentified\n      ? // Answering a span the user wrote themselves: the pill names the\n        // parameter the server matched it to, so the calendar isn't unlabelled.\n        {\n          type: editingIdentified.type,\n          text: identifiedParamLabel(editingIdentified.type),\n          required: true,\n          options: [],\n        }\n      : null;\n  const dropdownActivePill = s.dropdownSuggestion ?? dropdownPill ?? activeSuggestion;\n  const dropdownPills = dropdownPill ? [dropdownPill] : s.actionableSuggestions;\n  return {\n    suggestions: dropdownActivePill ? [{ ...dropdownActivePill, options: s.dropdownOptions }] : [],\n    activeIndex: s.activeDropdownIndex,\n    isOpen: s.isDropdownOpen,\n    pills: dropdownPills,\n    isActivePillSelected: s.isActivePillSelected,\n    isLoading: computeUiLoading(s),\n    skeletonExiting: s.skeletonExiting,\n    isInputEmpty: s.text.trim().length === 0,\n    products: s.products,\n    isEditing: Boolean(editingParam) || Boolean(editingIdentified),\n    inSelectionAnimation: s.inSelectionAnimation,\n    // Datepicker. `s.filteredOptions` above already carries the visible\n    // month's cells rather than the suggestion's own options when this is\n    // \"date\" — the core swapped them in its derive layer, so the dropdown only\n    // has to know which body to draw.\n    formatType: s.activeFormatType,\n    dateView: s.dateView,\n    selectedDateIso: dateSelection.selectedIso,\n    selectedDateRange: dateSelection.selectedRange,\n    dateRangeStart: dateSelection.rangeStart,\n    optionsPosition,\n  };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ai-autocomplete.controller.js","sourceRoot":"","sources":["../../../../src/lib/controller/ai-autocomplete.controller.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  type AutocompleteResult,\n  type CompletedParamState,\n  AIAutocomplete as CoreAIAutocomplete,\n  type CoreState,\n  type CustomFieldsReport,\n  dateSelectionFor,\n  type IdentifiedParamState,\n  identifiedParamLabel,\n  type Product,\n  type Segment,\n  type SkippedParamState,\n  type Suggestion,\n  type SuggestionOption,\n} from \"@magicx-eng/ai-autocomplete-vanilla\";\nimport { BehaviorSubject, combineLatest, map, type Observable, shareReplay } from \"rxjs\";\nimport type {\n  AIAutocompleteControllerOptions,\n  AIAutocompleteControllerState,\n  AIAutocompleteControllerUpdate,\n  AIAutocompleteDropdownState,\n} from \"../shared/types\";\nimport { deriveField } from \"./observables\";\n\n/**\n * Tier 2 logic surface for `@magicx-eng/ai-autocomplete-angular` — the Angular\n * equivalent of React's `useAIAutocomplete()` hook. Wraps a headless\n * `@magicx-eng/ai-autocomplete-vanilla` core and exposes its state as RxJS\n * observables plus thin action methods.\n *\n * The controller is consumer-managed — the consumer creates it\n * with `new`, holds the reference, and **must call `destroy()`** in their\n * own `ngOnDestroy`. The Tier 1 `<ai-autocomplete>` component does this\n * automatically; Tier 2 consumers do not get auto-cleanup.\n *\n * @public\n */\nexport class AIAutocompleteController {\n  private readonly core: CoreAIAutocomplete;\n  private readonly rawState$: BehaviorSubject<CoreState>;\n  // optionsPosition isn't part of CoreState (it's a core option), so track it\n  // here and fold it into `dropdown$` so the dropdown can read placement from\n  // the controller — configured once, kept in sync through update().\n  private readonly optionsPosition$ = new BehaviorSubject<\"above\" | \"below\">(\"below\");\n  private readonly unsubscribeCore: () => void;\n  private isDestroyed = false;\n\n  // === Per-field observables ===\n  // Each one runs through deriveField, which bakes in distinctUntilChanged\n  // and shareReplay({ bufferSize: 1, refCount: true }) per §19.4.\n\n  /** Plain-text content of the editor. */\n  readonly text$: Observable<string>;\n  /** Completed (bold) params currently in the editor. */\n  readonly completedParams$: Observable<CompletedParamState[]>;\n  /**\n   * Suggestions the user dismissed with the skip key (→). Nothing renders\n   * them; they exist so a hand-rolled submit can pass them to\n   * `buildSubmitResult` and carry the same `text: \"skipped\"` entries the\n   * SDK's own requests do.\n   */\n  readonly skippedParams$: Observable<SkippedParamState[]>;\n  /**\n   * Params the server identified in the user's own words. Already rendered\n   * through `segments$`; exposed so a hand-rolled submit can pass them to\n   * `buildSubmitResult` and report the same `identified_params` the SDK's\n   * own results carry.\n   */\n  readonly identifiedParams$: Observable<IdentifiedParamState[]>;\n  /** Actionable suggestion pills (first one is the active pill). */\n  readonly suggestionPills$: Observable<Suggestion[]>;\n  /** Text + completed-param segments for rendering the editor body. */\n  readonly segments$: Observable<Segment[]>;\n  /** ID of the most-recently-promoted param (drives shimmer animation). */\n  readonly newParamId$: Observable<string | null>;\n  /** All suggestions from the server (including non-actionable ones). */\n  readonly suggestions$: Observable<Suggestion[]>;\n  /**\n   * What the product strip shows: the items the latest `/suggest` response\n   * reported as matching the query, or — with `products` configured on the\n   * controller — the results of that custom search.\n   */\n  readonly products$: Observable<Product[]>;\n  /**\n   * The catalog grounding report the latest response carried, or null when it\n   * carried none: which of the query's constraints the catalog applied, which\n   * it dropped, and how many items (and which) the applied ones left\n   * standing. Null is \"no news\", not an empty catalog.\n   */\n  readonly customFields$: Observable<CustomFieldsReport | null>;\n  /** Currently highlighted dropdown option index. -1 = none. */\n  readonly activeIndex$: Observable<number>;\n  /**\n   * UI-visible loading flag — suppressed during the post-select press\n   * animation and during re-edit (cached options stay visible there). Use\n   * this instead of the raw core state for any loading-skeleton binding.\n   */\n  readonly isLoading$: Observable<boolean>;\n  /** Server-reported \"query is complete\" flag. */\n  readonly isReady$: Observable<boolean>;\n  /** Whether the editor currently has focus. */\n  readonly isFocused$: Observable<boolean>;\n  /** Whether the dropdown should currently be visible. */\n  readonly isDropdownOpen$: Observable<boolean>;\n  /**\n   * Whether the active (leading) pill should render selected (full opacity)\n   * rather than the de-emphasized `first` tier. Auto trigger ⇒ true only while\n   * a dropdown option is highlighted; manual ⇒ true once the pill is tapped.\n   */\n  readonly isActivePillSelected$: Observable<boolean>;\n  /** Server-suggested placeholder text for the editor. */\n  readonly placeholderText$: Observable<string>;\n  /** Last fetch error, or null. */\n  readonly error$: Observable<Error | null>;\n  /** Param currently being re-edited, or null. */\n  readonly editingParam$: Observable<CompletedParamState | null>;\n  /** Plain-text offset where the edit region starts, or null. */\n  readonly editingAnchor$: Observable<number | null>;\n  /** Live caret offset within the editor. */\n  readonly caretOffset$: Observable<number | null>;\n\n  // === Composite observables ===\n\n  /**\n   * Snapshot of every public field in one object. Convenient for\n   * `*ngIf=\"ctrl.state$ | async as state\"` templating — aliases all fields\n   * under a single subscription instead of multiple `| async` pipes.\n   */\n  readonly state$: Observable<AIAutocompleteControllerState>;\n\n  /**\n   * Composite state for the dropdown view. Tier 2 consumers spread this into\n   * `<ai-autocomplete-dropdown>`; Tier 1 uses the same shape internally.\n   */\n  readonly dropdown$: Observable<AIAutocompleteDropdownState>;\n\n  /**\n   * Throws if invoked outside a browser environment. For SSR / Angular\n   * Universal, gate construction with `isPlatformBrowser`.\n   */\n  constructor(opts: AIAutocompleteControllerOptions = {}) {\n    if (typeof document === \"undefined\") {\n      throw new Error(\n        \"AIAutocompleteController requires a browser environment. \" +\n          \"For SSR / Angular Universal, gate construction with isPlatformBrowser.\",\n      );\n    }\n\n    // Headless mode never renders to the host, so a throwaway div is fine —\n    // it's required by the core's signature for symmetry with full mode.\n    const host = document.createElement(\"div\");\n\n    this.core = new CoreAIAutocomplete(host, {\n      ...opts,\n      renderMode: \"headless\",\n      source: opts.source ?? \"headless-sdk\",\n      // Headless mode never renders the dropdown DOM, but the keyboard\n      // controller still reads `optionsPosition` to decide which vertical\n      // arrow opens the dropdown from the input.\n      optionsPosition: opts.optionsPosition ?? \"below\",\n    });\n\n    this.rawState$ = new BehaviorSubject<CoreState>(this.core.getState());\n    // Push the store's *current* state, not the snapshot the listener was\n    // handed. The core notifies listeners synchronously, and some actions\n    // trigger reentrant `store.set` calls (e.g. typing a non-matching char\n    // during re-edit makes the core synchronously exit re-edit and kick off a\n    // fetch).\n    //\n    // The core's store used to deliver such a nested set inline and then\n    // resume the outer listener loop, so a listener could be handed an older\n    // state (still in re-edit) *after* a newer one (re-edit exited) — which\n    // resurrected a stale `editingParam` and retriggered the editor's re-edit\n    // caret-park, yanking the caret back to where re-editing started. The\n    // store now queues notifications and drains them in order, so that\n    // out-of-order delivery can no longer happen at the source.\n    //\n    // Reading `getState()` at emission time is kept as belt-and-braces: it\n    // costs nothing (distinctUntilChanged downstream drops the duplicate\n    // emissions) and keeps this bridge correct for any future consumer that\n    // emits mid-cascade. React needs neither, since it batches renders and\n    // gates its caret effects on dependencies.\n    this.unsubscribeCore = this.core.subscribe(() => {\n      if (!this.isDestroyed) this.rawState$.next(this.core.getState());\n    });\n\n    // === Per-field observables ===\n    // Array-valued fields use shallow equality. The vanilla store spreads on\n    // every write (`store.set({ completedParams: [...] })`), so reference\n    // equality would re-fire downstream subscribers on every state tick even\n    // when the array's contents are unchanged. The other fields are\n    // primitives or stable object references, so default identity equality\n    // works fine.\n    this.text$ = deriveField(this.rawState$, (s) => s.text);\n    this.completedParams$ = deriveField(this.rawState$, (s) => s.completedParams, arrEq);\n    this.skippedParams$ = deriveField(this.rawState$, (s) => s.skippedParams, arrEq);\n    this.identifiedParams$ = deriveField(this.rawState$, (s) => s.identifiedParams, arrEq);\n    this.suggestionPills$ = deriveField(this.rawState$, (s) => s.actionableSuggestions, arrEq);\n    this.segments$ = deriveField(this.rawState$, (s) => s.segments, arrEq);\n    this.newParamId$ = deriveField(this.rawState$, (s) => s.newParamId);\n    this.suggestions$ = deriveField(this.rawState$, (s) => s.suggestions, arrEq);\n    this.products$ = deriveField(this.rawState$, (s) => s.products, arrEq);\n    this.customFields$ = deriveField(this.rawState$, (s) => s.customFields);\n    this.activeIndex$ = deriveField(this.rawState$, (s) => s.activeDropdownIndex);\n    this.isLoading$ = deriveField(this.rawState$, computeUiLoading);\n    this.isReady$ = deriveField(this.rawState$, (s) => s.isReady);\n    this.isFocused$ = deriveField(this.rawState$, (s) => s.isFocused);\n    this.isDropdownOpen$ = deriveField(this.rawState$, (s) => s.isDropdownOpen);\n    this.isActivePillSelected$ = deriveField(this.rawState$, (s) => s.isActivePillSelected);\n    this.placeholderText$ = deriveField(this.rawState$, (s) => s.placeholderText);\n    this.error$ = deriveField(this.rawState$, (s) => s.error);\n    this.editingParam$ = deriveField(this.rawState$, (s) => s.editingParam);\n    this.editingAnchor$ = deriveField(this.rawState$, (s) => s.editingAnchor);\n    this.caretOffset$ = deriveField(this.rawState$, (s) => s.caretOffset);\n\n    // === Composite observables ===\n    // Project directly off `rawState$` with a single map() so each store\n    // tick produces exactly ONE coherent state$ emission. Using\n    // `combineLatest` over the per-field observables here would fire one\n    // emission per inner-source tick (up to N per store update), and the\n    // editor-host directive's post-promote refocus would run against an\n    // intermediate state where `newParamId` was set but `segments` /\n    // `caretOffset` still held their old values — leaving the caret stuck\n    // at the pre-click position.\n    this.state$ = this.rawState$.pipe(\n      map(computeState),\n      shareReplay({ bufferSize: 1, refCount: true }),\n    );\n\n    this.optionsPosition$.next(opts.optionsPosition ?? \"below\");\n    this.dropdown$ = combineLatest([this.rawState$, this.optionsPosition$]).pipe(\n      map(([s, optionsPosition]) => computeDropdown(s, optionsPosition)),\n      shareReplay({ bufferSize: 1, refCount: true }),\n    );\n  }\n\n  // === Read-only accessors ===\n\n  /** Stable ARIA listbox ID for the dropdown. Pass to `<textarea aria-controls=\"...\">`. */\n  get listboxId(): string {\n    return this.core.listboxId;\n  }\n\n  /** Whether `destroy()` has been called. After destruction all action methods no-op. */\n  get destroyed(): boolean {\n    return this.isDestroyed;\n  }\n\n  /**\n   * Synchronous snapshot of the controller's current public state. Mirrors\n   * the latest emission of `state$`. Useful in callbacks where you can't\n   * `subscribe` (e.g. inside an event handler).\n   */\n  getState(): AIAutocompleteControllerState {\n    return computeState(this.rawState$.value);\n  }\n\n  /**\n   * The structured query as the SDK understands it right now — the same\n   * object `onResult` delivers after each response and `onSubmit` delivers\n   * on submit. Read it on demand from a place that has no event handy (a\n   * custom submit button, a \"save draft\" action).\n   */\n  getResult(): AutocompleteResult {\n    return this.core.getResult();\n  }\n\n  // === Action methods (pass-through to the core) ===\n  //\n  // Every action method begins with an `isDestroyed` guard so that callers\n  // who hold a stale reference after `destroy()` don't accidentally trigger\n  // work on a torn-down core. The vanilla core does not gate its own methods\n  // post-dispose — `reset()`, `handleTextChange()`, and friends would still\n  // schedule fetches or fire HTTP requests against an aborted controller,\n  // and the responses would have nowhere to surface (rawState$ is already\n  // complete). The guard makes the JSDoc-promised \"no-op silently\"\n  // semantics actually true.\n\n  /** Clear all state, rotate `session_id`, and re-fetch. Call after submit. */\n  reset(): void {\n    if (this.isDestroyed) return;\n    this.core.reset();\n  }\n\n  /** Pick a dropdown option (or replace the re-edited param if in re-edit mode). */\n  selectOption(option: SuggestionOption): void {\n    if (this.isDestroyed) return;\n    this.core.selectOption(option);\n  }\n\n  /**\n   * Announce a product selection — fires the `onProductSelect` callback the\n   * controller was constructed with. `<ai-autocomplete-dropdown>` calls this\n   * for you; consumers rendering their own strip call it themselves.\n   *\n   * Emitting is the whole behaviour: the SDK deliberately does not navigate to\n   * `product.url`, because only the integration knows whether a selection\n   * means \"open the PDP\", \"add to cart\", or \"fill the input\".\n   */\n  selectProduct(product: Product): void {\n    if (this.isDestroyed) return;\n    this.core.selectProduct(product);\n  }\n\n  /** Promote the pill at `index` to active (front of the list). */\n  setActivePill(index: number): void {\n    if (this.isDestroyed) return;\n    this.core.setActivePill(index);\n  }\n\n  /**\n   * Skip the active pill — same action as pressing → at the end of the input.\n   * The dropdown's skip button calls this; consumers rendering their own skip\n   * affordance call it directly. The skipped suggestion joins `skippedParams$`.\n   */\n  skipActivePill(): void {\n    if (this.isDestroyed) return;\n    this.core.skipActivePill();\n  }\n\n  /** Drop the last completed param's \"completed\" status. Text stays as plain text. */\n  removeLastParam(): void {\n    if (this.isDestroyed) return;\n    this.core.removeLastParam();\n  }\n\n  /** Clear the shimmer animation state for the most-recently-added param. */\n  clearNewParamId(): void {\n    if (this.isDestroyed) return;\n    this.core.clearNewParamId();\n  }\n\n  /** Controlled-mode setter for editor text. */\n  setValue(text: string): void {\n    if (this.isDestroyed) return;\n    this.core.setValue(text);\n  }\n\n  /** Controlled-mode setter for completed params. */\n  setCompletedParams(params: CompletedParamState[]): void {\n    if (this.isDestroyed) return;\n    this.core.setCompletedParams(params);\n  }\n\n  /** Forward plain-text input from the consumer's `<textarea>` to the core. */\n  handleTextChange(value: string): void {\n    if (this.isDestroyed) return;\n    this.core.handleTextChange(value);\n  }\n\n  /** Forward keyboard events from the consumer's `<textarea>` to the core. */\n  handleKeyDown(event: KeyboardEvent): void {\n    if (this.isDestroyed) return;\n    this.core.handleKeyDown(event);\n  }\n\n  /** Notify the core of focus state. */\n  setFocused(focused: boolean): void {\n    if (this.isDestroyed) return;\n    this.core.setFocused(focused);\n  }\n\n  /** Enter re-edit mode for the bold param with the given id. */\n  startEditingParam(paramId: string): void {\n    if (this.isDestroyed) return;\n    this.core.startEditingParam(paramId);\n  }\n\n  /** Exit re-edit mode without changing the bold param. */\n  exitEditMode(): void {\n    if (this.isDestroyed) return;\n    this.core.exitEditMode();\n  }\n\n  /** Forward post-input caret position (extends the edit tail). */\n  handleCaretAfterInput(offset: number | null): void {\n    if (this.isDestroyed) return;\n    this.core.handleCaretAfterInput(offset);\n  }\n\n  /** Forward selection-only caret moves (may exit re-edit). */\n  handleCaretMove(offset: number | null): void {\n    if (this.isDestroyed) return;\n    this.core.handleCaretMove(offset);\n  }\n\n  /** Replace the bold param being re-edited. Returns true when applied. */\n  replaceEditingRange(replacement: string): boolean {\n    if (this.isDestroyed) return false;\n    return this.core.replaceEditingRange(replacement);\n  }\n\n  /** Set the highlighted option index (typically driven by hover). */\n  setActiveDropdownIndex(index: number): void {\n    if (this.isDestroyed) return;\n    this.core.setActiveDropdownIndex(index);\n  }\n\n  /**\n   * The pointer left option `index`: clear the highlight if it is still on it,\n   * so Enter afterwards submits instead of picking an option the pointer is no\n   * longer on. A highlight the keyboard has since moved is left alone.\n   */\n  clearHighlight(index: number): void {\n    if (this.isDestroyed) return;\n    this.core.clearHighlight(index);\n  }\n\n  /** Page the datepicker back one month. No-op unless a date pill is active. */\n  showPreviousMonth(): void {\n    if (this.isDestroyed) return;\n    this.core.showPreviousMonth();\n  }\n\n  /** Page the datepicker forward one month. No-op unless a date pill is active. */\n  showNextMonth(): void {\n    if (this.isDestroyed) return;\n    this.core.showNextMonth();\n  }\n\n  // === Lifecycle ===\n\n  /**\n   * Apply runtime changes to a subset of options. Event callbacks\n   * (`onSubmit`, `onResult`, `onError`, etc.) cannot be swapped this way — they are\n   * registered once at construction (matches the React hook's design). For\n   * dynamic event reactivity, subscribe to the corresponding observable\n   * (e.g. `text$` instead of `onChange`).\n   */\n  update(opts: AIAutocompleteControllerUpdate): void {\n    if (this.isDestroyed) return;\n    this.core.update(opts);\n    if (opts.optionsPosition !== undefined) {\n      this.optionsPosition$.next(opts.optionsPosition);\n    }\n  }\n\n  /**\n   * Release all resources — unsubscribes from the core, destroys the core,\n   * and completes the internal state subject. Safe to call multiple times.\n   * After destruction, action methods no-op silently.\n   */\n  destroy(): void {\n    if (this.isDestroyed) return;\n    this.isDestroyed = true;\n    this.unsubscribeCore();\n    this.core.destroy();\n    this.rawState$.complete();\n  }\n}\n\n// ===== Pure helpers — not part of the public surface =====\n\n/**\n * Shallow array equality. The vanilla store reassigns array fields on every\n * write (`store.set({ completedParams: [...prev, x] })`), so reference\n * equality alone would re-emit downstream even when the contents are\n * identical. Used for `completedParams$`, `suggestions$`, `suggestionPills$`,\n * and `segments$`.\n */\nfunction arrEq<T>(a: readonly T[], b: readonly T[]): boolean {\n  if (a === b) return true;\n  if (a.length !== b.length) return false;\n  for (let i = 0; i < a.length; i++) {\n    if (a[i] !== b[i]) return false;\n  }\n  return true;\n}\n\n/** UI-visible loading — the core's `dropdownLoading` (see its docs). */\nfunction computeUiLoading(s: CoreState): boolean {\n  return s.dropdownLoading;\n}\n\nfunction computeState(s: CoreState): AIAutocompleteControllerState {\n  return {\n    text: s.text,\n    completedParams: s.completedParams,\n    skippedParams: s.skippedParams,\n    identifiedParams: s.identifiedParams,\n    suggestionPills: s.actionableSuggestions,\n    segments: s.segments,\n    newParamId: s.newParamId,\n    suggestions: s.suggestions,\n    products: s.products,\n    customFields: s.customFields,\n    activeIndex: s.activeDropdownIndex,\n    isLoading: computeUiLoading(s),\n    isReady: s.isReady,\n    isFocused: s.isFocused,\n    isDropdownOpen: s.isDropdownOpen,\n    placeholderText: s.placeholderText,\n    error: s.error,\n    editingParam: s.editingParam,\n    editingIdentified: s.editingIdentified,\n    editingAnchor: s.editingAnchor,\n    caretOffset: s.caretOffset,\n  };\n}\n\nfunction computeDropdown(\n  s: CoreState,\n  optionsPosition: \"above\" | \"below\",\n): AIAutocompleteDropdownState {\n  const editingParam = s.editingParam;\n  const editingIdentified = s.editingIdentified;\n  const dateSelection = dateSelectionFor(s);\n  const activeSuggestion = s.actionableSuggestions[0];\n  const dropdownPill: Suggestion | null = editingParam\n    ? {\n        type: editingParam.suggestionType,\n        text: editingParam.suggestionPlaceholder,\n        required: true,\n        options: editingParam.options,\n      }\n    : editingIdentified\n      ? // Answering a span the user wrote themselves: the pill names the\n        // parameter the server matched it to, so the calendar isn't unlabelled.\n        {\n          type: editingIdentified.type,\n          text: identifiedParamLabel(editingIdentified.type),\n          required: true,\n          options: [],\n        }\n      : null;\n  const dropdownActivePill = s.dropdownSuggestion ?? dropdownPill ?? activeSuggestion;\n  const dropdownPills = dropdownPill ? [dropdownPill] : s.actionableSuggestions;\n  return {\n    suggestions: dropdownActivePill ? [{ ...dropdownActivePill, options: s.dropdownOptions }] : [],\n    activeIndex: s.activeDropdownIndex,\n    isOpen: s.isDropdownOpen,\n    pills: dropdownPills,\n    isActivePillSelected: s.isActivePillSelected,\n    isLoading: computeUiLoading(s),\n    skeletonExiting: s.skeletonExiting,\n    isInputEmpty: s.text.trim().length === 0,\n    products: s.products,\n    isEditing: Boolean(editingParam) || Boolean(editingIdentified),\n    inSelectionAnimation: s.inSelectionAnimation,\n    // Datepicker. `s.filteredOptions` above already carries the visible\n    // month's cells rather than the suggestion's own options when this is\n    // \"date\" — the core swapped them in its derive layer, so the dropdown only\n    // has to know which body to draw.\n    formatType: s.activeFormatType,\n    dateView: s.dateView,\n    selectedDateIso: dateSelection.selectedIso,\n    selectedDateRange: dateSelection.selectedRange,\n    dateRangeStart: dateSelection.rangeStart,\n    optionsPosition,\n  };\n}\n"]}

package/esm2020/lib/internal/date-grid/date-grid.component.mjs

@@ -29,6 +29,8 @@ export class DateGridComponent {
         this.selection = { selectedIso: null, selectedRange: null, rangeStart: null };
         this.select = new EventEmitter();
         this.highlight = new EventEmitter();
+        /** The pointer left cell `index` — the dropdown clears a highlight still on it. */
+        this.unhighlight = new EventEmitter();
         this.previousMonth = new EventEmitter();
         this.nextMonth = new EventEmitter();
         this.weekdays = WEEKDAY_LABELS;
@@ -99,10 +101,10 @@ export class DateGridComponent {
     }
 }
 DateGridComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: DateGridComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
-DateGridComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.10", type: DateGridComponent, isStandalone: true, selector: "aia-date-grid", inputs: { options: "options", activeIndex: "activeIndex", listboxId: "listboxId", view: "view", selection: "selection" }, outputs: { select: "select", highlight: "highlight", previousMonth: "previousMonth", nextMonth: "nextMonth" }, ngImport: i0, template: "<div class=\"magicx-aia-datepicker\" data-aia-datepicker=\"\">\n  <div class=\"magicx-aia-datepicker-header\">\n    <!-- tabIndex -1 for the same reason the skip button is: Tab is already\n         bound to walking the dropdown's options. -->\n    <button\n      type=\"button\"\n      tabindex=\"-1\"\n      class=\"magicx-aia-datepicker-nav\"\n      data-aia-date-prev=\"\"\n      aria-label=\"Previous month\"\n      (mousedown)=\"preventBlur($event)\"\n      (click)=\"previousMonth.emit()\"\n    >\n      &lsaquo;\n    </button>\n    <span class=\"magicx-aia-datepicker-month\" data-aia-date-month=\"\" aria-live=\"polite\">\n      {{ monthLabel }}\n    </span>\n    <button\n      type=\"button\"\n      tabindex=\"-1\"\n      class=\"magicx-aia-datepicker-nav\"\n      data-aia-date-next=\"\"\n      aria-label=\"Next month\"\n      (mousedown)=\"preventBlur($event)\"\n      (click)=\"nextMonth.emit()\"\n    >\n      &rsaquo;\n    </button>\n  </div>\n\n  <!-- Decorative: each cell announces its own full date, so repeating the\n       column letters to AT adds noise \u2014 and the duplicate T/S would be\n       meaningless read aloud anyway. -->\n  <div class=\"magicx-aia-datepicker-weekdays\" aria-hidden=\"true\">\n    <span class=\"magicx-aia-datepicker-weekday\" *ngFor=\"let label of weekdays\">{{ label }}</span>\n  </div>\n\n  <div class=\"magicx-aia-datepicker-grid\" data-aia-date-grid=\"\">\n    <ng-container *ngFor=\"let option of options; trackBy: trackByCell; let i = index\">\n      <!-- Padding for the days before the 1st / after the last. Non-tappable,\n           so arrow navigation skips it; hidden from AT so the month reads as\n           its own days and nothing else. -->\n      <div\n        *ngIf=\"dayOf(option) === null; else dayCell\"\n        [id]=\"listboxId + '-option-' + i\"\n        role=\"option\"\n        data-aia-option=\"\"\n        data-aia-date-cell=\"\"\n        aria-hidden=\"true\"\n        [attr.aria-selected]=\"false\"\n        tabindex=\"-1\"\n        class=\"magicx-aia-date-cell magicx-aia-date-cell--blank\"\n      ></div>\n\n      <ng-template #dayCell>\n        <!-- A day already gone by is de-emphasized, not disabled: it renders\n             dimmed but stays every bit as pickable as the rest of the month. -->\n        <div\n          [id]=\"listboxId + '-option-' + i\"\n          role=\"option\"\n          data-aia-option=\"\"\n          data-aia-date-cell=\"\"\n          [attr.aria-selected]=\"i === activeIndex\"\n          [attr.aria-label]=\"option.text\"\n          tabindex=\"0\"\n          class=\"magicx-aia-date-cell magicx-aia-date-cell--day\"\n          [class.magicx-aia-date-cell--past]=\"isPast(option)\"\n          [class.magicx-aia-date-cell--highlighted]=\"i === activeIndex\"\n          [class.magicx-aia-date-cell--today]=\"isToday(option)\"\n          [class.magicx-aia-date-cell--in-range]=\"isInRange(option)\"\n          [class.magicx-aia-date-cell--selected]=\"isSelected(option)\"\n          [class.magicx-aia-date-cell--pressed]=\"i === pressedIndex\"\n          (click)=\"onSelect(option, i)\"\n          (keydown)=\"onKeyDown($event, option, i)\"\n          (mouseenter)=\"highlight.emit(i)\"\n        >\n          <!-- The cell paints the day number; `option.text` is the full\n               committed value (\"March 23 2026\") and is what AT announces,\n               since that is what selecting it puts in the input. -->\n          <span class=\"magicx-aia-date-cell-number\">{{ dayOf(option) }}</span>\n        </div>\n      </ng-template>\n    </ng-container>\n  </div>\n</div>\n", styles: [".magicx-aia-datepicker{display:flex;flex-direction:column;gap:4px;padding:4px 2px}.magicx-aia-datepicker-header{display:flex;align-items:center;justify-content:space-between;gap:8px;padding:2px 6px 6px}.magicx-aia-datepicker-month{font-family:inherit;font-size:var(--aia-date-month-font-size, 14px);font-weight:500;line-height:20px;color:var(--aia-option-color-selected, var(--aia-color-text-default, #fff))}.magicx-aia-datepicker-nav{display:inline-flex;align-items:center;justify-content:center;width:24px;height:24px;padding:0;border:none;border-radius:6px;background:transparent;font-family:inherit;font-size:16px;line-height:1;color:var(--aia-option-color, var(--aia-color-text-muted, #c1c4cb));cursor:pointer;transition:color .15s ease-out,background-color .15s ease-out}.magicx-aia-datepicker-nav:hover{color:var(--aia-option-color-selected, var(--aia-color-text-default, #fff));background:var(--aia-option-bg, transparent)}.magicx-aia-datepicker-weekdays,.magicx-aia-datepicker-grid{display:grid;grid-template-columns:repeat(7,minmax(0,1fr))}.magicx-aia-datepicker-weekday{padding:2px 0;text-align:center;font-family:inherit;font-size:var(--aia-date-weekday-font-size, 11px);font-weight:500;line-height:16px;color:var(--aia-option-color, var(--aia-color-text-muted, #c1c4cb));opacity:.7}.magicx-aia-date-cell{display:flex;align-items:center;justify-content:center;min-width:0;height:var(--aia-date-row-height, 28px);font-family:inherit;font-size:var(--aia-date-cell-font-size, 13px);font-weight:450;line-height:20px;color:var(--aia-option-color, var(--aia-color-text-muted, #c1c4cb))}.magicx-aia-date-cell-number{display:flex;align-items:center;justify-content:center;width:var(--aia-date-cell-size, 26px);height:var(--aia-date-cell-size, 26px);border-radius:6px}.magicx-aia-date-cell--day{cursor:pointer}.magicx-aia-date-cell--blank{cursor:default}.magicx-aia-date-cell--past{opacity:.35}.magicx-aia-date-cell--day:hover .magicx-aia-date-cell-number,.magicx-aia-date-cell--highlighted .magicx-aia-date-cell-number{color:var(--aia-option-color-selected, var(--aia-color-text-default, #fff));background:var(--aia-option-bg, transparent);font-weight:500}.magicx-aia-date-cell--today .magicx-aia-date-cell-number{box-shadow:inset 0 0 0 1px var(--aia-date-today-ring, var(--aia-option-color, var(--aia-color-text-muted, #c1c4cb)))}.magicx-aia-date-cell--in-range{background:var(--aia-date-range-bg, rgba(var(--aia-streak-rgb, 255, 255, 255), .06))}.magicx-aia-date-cell--selected .magicx-aia-date-cell-number{color:var(--aia-option-color-selected, var(--aia-color-text-default, #fff));background:var(--aia-date-selected-bg, rgba(var(--aia-streak-rgb, 255, 255, 255), .12));font-weight:500}.magicx-aia-date-cell--pressed .magicx-aia-date-cell-number{opacity:.8;background:rgba(var(--aia-streak-rgb, 255, 255, 255),.06)}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });
+DateGridComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.10", type: DateGridComponent, isStandalone: true, selector: "aia-date-grid", inputs: { options: "options", activeIndex: "activeIndex", listboxId: "listboxId", view: "view", selection: "selection" }, outputs: { select: "select", highlight: "highlight", unhighlight: "unhighlight", previousMonth: "previousMonth", nextMonth: "nextMonth" }, ngImport: i0, template: "<div class=\"magicx-aia-datepicker\" data-aia-datepicker=\"\">\n  <div class=\"magicx-aia-datepicker-header\">\n    <!-- tabIndex -1 for the same reason the skip button is: Tab is already\n         bound to walking the dropdown's options. -->\n    <button\n      type=\"button\"\n      tabindex=\"-1\"\n      class=\"magicx-aia-datepicker-nav\"\n      data-aia-date-prev=\"\"\n      aria-label=\"Previous month\"\n      (mousedown)=\"preventBlur($event)\"\n      (click)=\"previousMonth.emit()\"\n    >\n      &lsaquo;\n    </button>\n    <span class=\"magicx-aia-datepicker-month\" data-aia-date-month=\"\" aria-live=\"polite\">\n      {{ monthLabel }}\n    </span>\n    <button\n      type=\"button\"\n      tabindex=\"-1\"\n      class=\"magicx-aia-datepicker-nav\"\n      data-aia-date-next=\"\"\n      aria-label=\"Next month\"\n      (mousedown)=\"preventBlur($event)\"\n      (click)=\"nextMonth.emit()\"\n    >\n      &rsaquo;\n    </button>\n  </div>\n\n  <!-- Decorative: each cell announces its own full date, so repeating the\n       column letters to AT adds noise \u2014 and the duplicate T/S would be\n       meaningless read aloud anyway. -->\n  <div class=\"magicx-aia-datepicker-weekdays\" aria-hidden=\"true\">\n    <span class=\"magicx-aia-datepicker-weekday\" *ngFor=\"let label of weekdays\">{{ label }}</span>\n  </div>\n\n  <div class=\"magicx-aia-datepicker-grid\" data-aia-date-grid=\"\">\n    <ng-container *ngFor=\"let option of options; trackBy: trackByCell; let i = index\">\n      <!-- Padding for the days before the 1st / after the last. Non-tappable,\n           so arrow navigation skips it; hidden from AT so the month reads as\n           its own days and nothing else. -->\n      <div\n        *ngIf=\"dayOf(option) === null; else dayCell\"\n        [id]=\"listboxId + '-option-' + i\"\n        role=\"option\"\n        data-aia-option=\"\"\n        data-aia-date-cell=\"\"\n        aria-hidden=\"true\"\n        [attr.aria-selected]=\"false\"\n        tabindex=\"-1\"\n        class=\"magicx-aia-date-cell magicx-aia-date-cell--blank\"\n      ></div>\n\n      <ng-template #dayCell>\n        <!-- A day already gone by is de-emphasized, not disabled: it renders\n             dimmed but stays every bit as pickable as the rest of the month. -->\n        <div\n          [id]=\"listboxId + '-option-' + i\"\n          role=\"option\"\n          data-aia-option=\"\"\n          data-aia-date-cell=\"\"\n          [attr.aria-selected]=\"i === activeIndex\"\n          [attr.aria-label]=\"option.text\"\n          tabindex=\"0\"\n          class=\"magicx-aia-date-cell magicx-aia-date-cell--day\"\n          [class.magicx-aia-date-cell--past]=\"isPast(option)\"\n          [class.magicx-aia-date-cell--highlighted]=\"i === activeIndex\"\n          [class.magicx-aia-date-cell--today]=\"isToday(option)\"\n          [class.magicx-aia-date-cell--in-range]=\"isInRange(option)\"\n          [class.magicx-aia-date-cell--selected]=\"isSelected(option)\"\n          [class.magicx-aia-date-cell--pressed]=\"i === pressedIndex\"\n          (click)=\"onSelect(option, i)\"\n          (keydown)=\"onKeyDown($event, option, i)\"\n          (mouseenter)=\"highlight.emit(i)\"\n          (mouseleave)=\"unhighlight.emit(i)\"\n        >\n          <!-- The cell paints the day number; `option.text` is the full\n               committed value (\"March 23 2026\") and is what AT announces,\n               since that is what selecting it puts in the input. -->\n          <span class=\"magicx-aia-date-cell-number\">{{ dayOf(option) }}</span>\n        </div>\n      </ng-template>\n    </ng-container>\n  </div>\n</div>\n", styles: [".magicx-aia-datepicker{display:flex;flex-direction:column;gap:4px;padding:4px 2px}.magicx-aia-datepicker-header{display:flex;align-items:center;justify-content:space-between;gap:8px;padding:2px 6px 6px}.magicx-aia-datepicker-month{font-family:inherit;font-size:var(--aia-date-month-font-size, 14px);font-weight:500;line-height:20px;color:var(--aia-option-color-selected, var(--aia-color-text-default, #fff))}.magicx-aia-datepicker-nav{display:inline-flex;align-items:center;justify-content:center;width:24px;height:24px;padding:0;border:none;border-radius:6px;background:transparent;font-family:inherit;font-size:16px;line-height:1;color:var(--aia-option-color, var(--aia-color-text-muted, #c1c4cb));cursor:pointer;transition:color .15s ease-out,background-color .15s ease-out}.magicx-aia-datepicker-nav:hover{color:var(--aia-option-color-selected, var(--aia-color-text-default, #fff));background:var(--aia-option-bg, transparent)}.magicx-aia-datepicker-weekdays,.magicx-aia-datepicker-grid{display:grid;grid-template-columns:repeat(7,minmax(0,1fr))}.magicx-aia-datepicker-weekday{padding:2px 0;text-align:center;font-family:inherit;font-size:var(--aia-date-weekday-font-size, 11px);font-weight:500;line-height:16px;color:var(--aia-option-color, var(--aia-color-text-muted, #c1c4cb));opacity:.7}.magicx-aia-date-cell{display:flex;align-items:center;justify-content:center;min-width:0;height:var(--aia-date-row-height, 28px);font-family:inherit;font-size:var(--aia-date-cell-font-size, 13px);font-weight:450;line-height:20px;color:var(--aia-option-color, var(--aia-color-text-muted, #c1c4cb))}.magicx-aia-date-cell-number{display:flex;align-items:center;justify-content:center;width:var(--aia-date-cell-size, 26px);height:var(--aia-date-cell-size, 26px);border-radius:6px}.magicx-aia-date-cell--day{cursor:pointer}.magicx-aia-date-cell--blank{cursor:default}.magicx-aia-date-cell--past{opacity:.35}.magicx-aia-date-cell--day:hover .magicx-aia-date-cell-number,.magicx-aia-date-cell--highlighted .magicx-aia-date-cell-number{color:var(--aia-option-color-selected, var(--aia-color-text-default, #fff));background:var(--aia-option-bg, transparent);font-weight:500}.magicx-aia-date-cell--today .magicx-aia-date-cell-number{box-shadow:inset 0 0 0 1px var(--aia-date-today-ring, var(--aia-option-color, var(--aia-color-text-muted, #c1c4cb)))}.magicx-aia-date-cell--in-range{background:var(--aia-date-range-bg, rgba(var(--aia-streak-rgb, 255, 255, 255), .06))}.magicx-aia-date-cell--selected .magicx-aia-date-cell-number{color:var(--aia-option-color-selected, var(--aia-color-text-default, #fff));background:var(--aia-date-selected-bg, rgba(var(--aia-streak-rgb, 255, 255, 255), .12));font-weight:500}.magicx-aia-date-cell--pressed .magicx-aia-date-cell-number{opacity:.8;background:rgba(var(--aia-streak-rgb, 255, 255, 255),.06)}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: DateGridComponent, decorators: [{
             type: Component,
-            args: [{ selector: "aia-date-grid", standalone: true, imports: [CommonModule], changeDetection: ChangeDetectionStrategy.OnPush, encapsulation: ViewEncapsulation.None, template: "<div class=\"magicx-aia-datepicker\" data-aia-datepicker=\"\">\n  <div class=\"magicx-aia-datepicker-header\">\n    <!-- tabIndex -1 for the same reason the skip button is: Tab is already\n         bound to walking the dropdown's options. -->\n    <button\n      type=\"button\"\n      tabindex=\"-1\"\n      class=\"magicx-aia-datepicker-nav\"\n      data-aia-date-prev=\"\"\n      aria-label=\"Previous month\"\n      (mousedown)=\"preventBlur($event)\"\n      (click)=\"previousMonth.emit()\"\n    >\n      &lsaquo;\n    </button>\n    <span class=\"magicx-aia-datepicker-month\" data-aia-date-month=\"\" aria-live=\"polite\">\n      {{ monthLabel }}\n    </span>\n    <button\n      type=\"button\"\n      tabindex=\"-1\"\n      class=\"magicx-aia-datepicker-nav\"\n      data-aia-date-next=\"\"\n      aria-label=\"Next month\"\n      (mousedown)=\"preventBlur($event)\"\n      (click)=\"nextMonth.emit()\"\n    >\n      &rsaquo;\n    </button>\n  </div>\n\n  <!-- Decorative: each cell announces its own full date, so repeating the\n       column letters to AT adds noise \u2014 and the duplicate T/S would be\n       meaningless read aloud anyway. -->\n  <div class=\"magicx-aia-datepicker-weekdays\" aria-hidden=\"true\">\n    <span class=\"magicx-aia-datepicker-weekday\" *ngFor=\"let label of weekdays\">{{ label }}</span>\n  </div>\n\n  <div class=\"magicx-aia-datepicker-grid\" data-aia-date-grid=\"\">\n    <ng-container *ngFor=\"let option of options; trackBy: trackByCell; let i = index\">\n      <!-- Padding for the days before the 1st / after the last. Non-tappable,\n           so arrow navigation skips it; hidden from AT so the month reads as\n           its own days and nothing else. -->\n      <div\n        *ngIf=\"dayOf(option) === null; else dayCell\"\n        [id]=\"listboxId + '-option-' + i\"\n        role=\"option\"\n        data-aia-option=\"\"\n        data-aia-date-cell=\"\"\n        aria-hidden=\"true\"\n        [attr.aria-selected]=\"false\"\n        tabindex=\"-1\"\n        class=\"magicx-aia-date-cell magicx-aia-date-cell--blank\"\n      ></div>\n\n      <ng-template #dayCell>\n        <!-- A day already gone by is de-emphasized, not disabled: it renders\n             dimmed but stays every bit as pickable as the rest of the month. -->\n        <div\n          [id]=\"listboxId + '-option-' + i\"\n          role=\"option\"\n          data-aia-option=\"\"\n          data-aia-date-cell=\"\"\n          [attr.aria-selected]=\"i === activeIndex\"\n          [attr.aria-label]=\"option.text\"\n          tabindex=\"0\"\n          class=\"magicx-aia-date-cell magicx-aia-date-cell--day\"\n          [class.magicx-aia-date-cell--past]=\"isPast(option)\"\n          [class.magicx-aia-date-cell--highlighted]=\"i === activeIndex\"\n          [class.magicx-aia-date-cell--today]=\"isToday(option)\"\n          [class.magicx-aia-date-cell--in-range]=\"isInRange(option)\"\n          [class.magicx-aia-date-cell--selected]=\"isSelected(option)\"\n          [class.magicx-aia-date-cell--pressed]=\"i === pressedIndex\"\n          (click)=\"onSelect(option, i)\"\n          (keydown)=\"onKeyDown($event, option, i)\"\n          (mouseenter)=\"highlight.emit(i)\"\n        >\n          <!-- The cell paints the day number; `option.text` is the full\n               committed value (\"March 23 2026\") and is what AT announces,\n               since that is what selecting it puts in the input. -->\n          <span class=\"magicx-aia-date-cell-number\">{{ dayOf(option) }}</span>\n        </div>\n      </ng-template>\n    </ng-container>\n  </div>\n</div>\n", styles: [".magicx-aia-datepicker{display:flex;flex-direction:column;gap:4px;padding:4px 2px}.magicx-aia-datepicker-header{display:flex;align-items:center;justify-content:space-between;gap:8px;padding:2px 6px 6px}.magicx-aia-datepicker-month{font-family:inherit;font-size:var(--aia-date-month-font-size, 14px);font-weight:500;line-height:20px;color:var(--aia-option-color-selected, var(--aia-color-text-default, #fff))}.magicx-aia-datepicker-nav{display:inline-flex;align-items:center;justify-content:center;width:24px;height:24px;padding:0;border:none;border-radius:6px;background:transparent;font-family:inherit;font-size:16px;line-height:1;color:var(--aia-option-color, var(--aia-color-text-muted, #c1c4cb));cursor:pointer;transition:color .15s ease-out,background-color .15s ease-out}.magicx-aia-datepicker-nav:hover{color:var(--aia-option-color-selected, var(--aia-color-text-default, #fff));background:var(--aia-option-bg, transparent)}.magicx-aia-datepicker-weekdays,.magicx-aia-datepicker-grid{display:grid;grid-template-columns:repeat(7,minmax(0,1fr))}.magicx-aia-datepicker-weekday{padding:2px 0;text-align:center;font-family:inherit;font-size:var(--aia-date-weekday-font-size, 11px);font-weight:500;line-height:16px;color:var(--aia-option-color, var(--aia-color-text-muted, #c1c4cb));opacity:.7}.magicx-aia-date-cell{display:flex;align-items:center;justify-content:center;min-width:0;height:var(--aia-date-row-height, 28px);font-family:inherit;font-size:var(--aia-date-cell-font-size, 13px);font-weight:450;line-height:20px;color:var(--aia-option-color, var(--aia-color-text-muted, #c1c4cb))}.magicx-aia-date-cell-number{display:flex;align-items:center;justify-content:center;width:var(--aia-date-cell-size, 26px);height:var(--aia-date-cell-size, 26px);border-radius:6px}.magicx-aia-date-cell--day{cursor:pointer}.magicx-aia-date-cell--blank{cursor:default}.magicx-aia-date-cell--past{opacity:.35}.magicx-aia-date-cell--day:hover .magicx-aia-date-cell-number,.magicx-aia-date-cell--highlighted .magicx-aia-date-cell-number{color:var(--aia-option-color-selected, var(--aia-color-text-default, #fff));background:var(--aia-option-bg, transparent);font-weight:500}.magicx-aia-date-cell--today .magicx-aia-date-cell-number{box-shadow:inset 0 0 0 1px var(--aia-date-today-ring, var(--aia-option-color, var(--aia-color-text-muted, #c1c4cb)))}.magicx-aia-date-cell--in-range{background:var(--aia-date-range-bg, rgba(var(--aia-streak-rgb, 255, 255, 255), .06))}.magicx-aia-date-cell--selected .magicx-aia-date-cell-number{color:var(--aia-option-color-selected, var(--aia-color-text-default, #fff));background:var(--aia-date-selected-bg, rgba(var(--aia-streak-rgb, 255, 255, 255), .12));font-weight:500}.magicx-aia-date-cell--pressed .magicx-aia-date-cell-number{opacity:.8;background:rgba(var(--aia-streak-rgb, 255, 255, 255),.06)}\n"] }]
+            args: [{ selector: "aia-date-grid", standalone: true, imports: [CommonModule], changeDetection: ChangeDetectionStrategy.OnPush, encapsulation: ViewEncapsulation.None, template: "<div class=\"magicx-aia-datepicker\" data-aia-datepicker=\"\">\n  <div class=\"magicx-aia-datepicker-header\">\n    <!-- tabIndex -1 for the same reason the skip button is: Tab is already\n         bound to walking the dropdown's options. -->\n    <button\n      type=\"button\"\n      tabindex=\"-1\"\n      class=\"magicx-aia-datepicker-nav\"\n      data-aia-date-prev=\"\"\n      aria-label=\"Previous month\"\n      (mousedown)=\"preventBlur($event)\"\n      (click)=\"previousMonth.emit()\"\n    >\n      &lsaquo;\n    </button>\n    <span class=\"magicx-aia-datepicker-month\" data-aia-date-month=\"\" aria-live=\"polite\">\n      {{ monthLabel }}\n    </span>\n    <button\n      type=\"button\"\n      tabindex=\"-1\"\n      class=\"magicx-aia-datepicker-nav\"\n      data-aia-date-next=\"\"\n      aria-label=\"Next month\"\n      (mousedown)=\"preventBlur($event)\"\n      (click)=\"nextMonth.emit()\"\n    >\n      &rsaquo;\n    </button>\n  </div>\n\n  <!-- Decorative: each cell announces its own full date, so repeating the\n       column letters to AT adds noise \u2014 and the duplicate T/S would be\n       meaningless read aloud anyway. -->\n  <div class=\"magicx-aia-datepicker-weekdays\" aria-hidden=\"true\">\n    <span class=\"magicx-aia-datepicker-weekday\" *ngFor=\"let label of weekdays\">{{ label }}</span>\n  </div>\n\n  <div class=\"magicx-aia-datepicker-grid\" data-aia-date-grid=\"\">\n    <ng-container *ngFor=\"let option of options; trackBy: trackByCell; let i = index\">\n      <!-- Padding for the days before the 1st / after the last. Non-tappable,\n           so arrow navigation skips it; hidden from AT so the month reads as\n           its own days and nothing else. -->\n      <div\n        *ngIf=\"dayOf(option) === null; else dayCell\"\n        [id]=\"listboxId + '-option-' + i\"\n        role=\"option\"\n        data-aia-option=\"\"\n        data-aia-date-cell=\"\"\n        aria-hidden=\"true\"\n        [attr.aria-selected]=\"false\"\n        tabindex=\"-1\"\n        class=\"magicx-aia-date-cell magicx-aia-date-cell--blank\"\n      ></div>\n\n      <ng-template #dayCell>\n        <!-- A day already gone by is de-emphasized, not disabled: it renders\n             dimmed but stays every bit as pickable as the rest of the month. -->\n        <div\n          [id]=\"listboxId + '-option-' + i\"\n          role=\"option\"\n          data-aia-option=\"\"\n          data-aia-date-cell=\"\"\n          [attr.aria-selected]=\"i === activeIndex\"\n          [attr.aria-label]=\"option.text\"\n          tabindex=\"0\"\n          class=\"magicx-aia-date-cell magicx-aia-date-cell--day\"\n          [class.magicx-aia-date-cell--past]=\"isPast(option)\"\n          [class.magicx-aia-date-cell--highlighted]=\"i === activeIndex\"\n          [class.magicx-aia-date-cell--today]=\"isToday(option)\"\n          [class.magicx-aia-date-cell--in-range]=\"isInRange(option)\"\n          [class.magicx-aia-date-cell--selected]=\"isSelected(option)\"\n          [class.magicx-aia-date-cell--pressed]=\"i === pressedIndex\"\n          (click)=\"onSelect(option, i)\"\n          (keydown)=\"onKeyDown($event, option, i)\"\n          (mouseenter)=\"highlight.emit(i)\"\n          (mouseleave)=\"unhighlight.emit(i)\"\n        >\n          <!-- The cell paints the day number; `option.text` is the full\n               committed value (\"March 23 2026\") and is what AT announces,\n               since that is what selecting it puts in the input. -->\n          <span class=\"magicx-aia-date-cell-number\">{{ dayOf(option) }}</span>\n        </div>\n      </ng-template>\n    </ng-container>\n  </div>\n</div>\n", styles: [".magicx-aia-datepicker{display:flex;flex-direction:column;gap:4px;padding:4px 2px}.magicx-aia-datepicker-header{display:flex;align-items:center;justify-content:space-between;gap:8px;padding:2px 6px 6px}.magicx-aia-datepicker-month{font-family:inherit;font-size:var(--aia-date-month-font-size, 14px);font-weight:500;line-height:20px;color:var(--aia-option-color-selected, var(--aia-color-text-default, #fff))}.magicx-aia-datepicker-nav{display:inline-flex;align-items:center;justify-content:center;width:24px;height:24px;padding:0;border:none;border-radius:6px;background:transparent;font-family:inherit;font-size:16px;line-height:1;color:var(--aia-option-color, var(--aia-color-text-muted, #c1c4cb));cursor:pointer;transition:color .15s ease-out,background-color .15s ease-out}.magicx-aia-datepicker-nav:hover{color:var(--aia-option-color-selected, var(--aia-color-text-default, #fff));background:var(--aia-option-bg, transparent)}.magicx-aia-datepicker-weekdays,.magicx-aia-datepicker-grid{display:grid;grid-template-columns:repeat(7,minmax(0,1fr))}.magicx-aia-datepicker-weekday{padding:2px 0;text-align:center;font-family:inherit;font-size:var(--aia-date-weekday-font-size, 11px);font-weight:500;line-height:16px;color:var(--aia-option-color, var(--aia-color-text-muted, #c1c4cb));opacity:.7}.magicx-aia-date-cell{display:flex;align-items:center;justify-content:center;min-width:0;height:var(--aia-date-row-height, 28px);font-family:inherit;font-size:var(--aia-date-cell-font-size, 13px);font-weight:450;line-height:20px;color:var(--aia-option-color, var(--aia-color-text-muted, #c1c4cb))}.magicx-aia-date-cell-number{display:flex;align-items:center;justify-content:center;width:var(--aia-date-cell-size, 26px);height:var(--aia-date-cell-size, 26px);border-radius:6px}.magicx-aia-date-cell--day{cursor:pointer}.magicx-aia-date-cell--blank{cursor:default}.magicx-aia-date-cell--past{opacity:.35}.magicx-aia-date-cell--day:hover .magicx-aia-date-cell-number,.magicx-aia-date-cell--highlighted .magicx-aia-date-cell-number{color:var(--aia-option-color-selected, var(--aia-color-text-default, #fff));background:var(--aia-option-bg, transparent);font-weight:500}.magicx-aia-date-cell--today .magicx-aia-date-cell-number{box-shadow:inset 0 0 0 1px var(--aia-date-today-ring, var(--aia-option-color, var(--aia-color-text-muted, #c1c4cb)))}.magicx-aia-date-cell--in-range{background:var(--aia-date-range-bg, rgba(var(--aia-streak-rgb, 255, 255, 255), .06))}.magicx-aia-date-cell--selected .magicx-aia-date-cell-number{color:var(--aia-option-color-selected, var(--aia-color-text-default, #fff));background:var(--aia-date-selected-bg, rgba(var(--aia-streak-rgb, 255, 255, 255), .12));font-weight:500}.magicx-aia-date-cell--pressed .magicx-aia-date-cell-number{opacity:.8;background:rgba(var(--aia-streak-rgb, 255, 255, 255),.06)}\n"] }]
         }], propDecorators: { options: [{
                 type: Input
             }], activeIndex: [{
@@ -117,9 +119,11 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImpo
                 type: Output
             }], highlight: [{
                 type: Output
+            }], unhighlight: [{
+                type: Output
             }], previousMonth: [{
                 type: Output
             }], nextMonth: [{
                 type: Output
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"date-grid.component.js","sourceRoot":"","sources":["../../../../../src/lib/internal/date-grid/date-grid.component.ts","../../../../../src/lib/internal/date-grid/date-grid.component.html"],"names":[],"mappings":"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","sourcesContent":["import { CommonModule } from \"@angular/common\";\nimport {\n  ChangeDetectionStrategy,\n  Component,\n  EventEmitter,\n  Input,\n  Output,\n  ViewEncapsulation,\n} from \"@angular/core\";\nimport {\n  cellDay,\n  cellIso,\n  type DateMonthView,\n  type DateRange,\n  type DateSelection,\n  dateCellMarks,\n  isoDate,\n  monthLabel,\n  type SuggestionOption,\n  visibleDateRange,\n  WEEKDAY_LABELS,\n} from \"@magicx-eng/ai-autocomplete-vanilla\";\n\n/**\n * The dropdown's calendar body, rendered in place of the options grid when the\n * active parameter is a date. Angular analogue of vanilla's `renderDateGrid`\n * and React's `<DateGrid>`.\n *\n * The cells carry the same `${listboxId}-option-${i}` ids, `role=\"option\"` and\n * `aria-selected` the options grid emits, and that is load-bearing rather than\n * cosmetic: the keyboard controller lives in the vanilla core for all three\n * packages, navigates by index into `filteredOptions`, and commits by clicking\n * `#${listboxId}-option-${i}`. `getEffectiveColumns` also measures the live\n * `grid-template-columns` of option-0's parent, which is why the 7 columns sit\n * on the cell container itself and not on an ancestor.\n *\n * @internal\n */\n@Component({\n  selector: \"aia-date-grid\",\n  standalone: true,\n  imports: [CommonModule],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  encapsulation: ViewEncapsulation.None,\n  templateUrl: \"./date-grid.component.html\",\n  styleUrls: [\"./date-grid.component.css\"],\n})\nexport class DateGridComponent {\n  /** The visible month's cells. These ARE `filteredOptions` — see `buildDateOptions`. */\n  @Input() options: SuggestionOption[] = [];\n  @Input() activeIndex = -1;\n  @Input() listboxId = \"\";\n  @Input() view: DateMonthView | null = null;\n  /** What the calendar paints as answered — see the core's `dateSelectionFor`. */\n  @Input() selection: DateSelection = { selectedIso: null, selectedRange: null, rangeStart: null };\n\n  @Output() readonly select = new EventEmitter<SuggestionOption>();\n  @Output() readonly highlight = new EventEmitter<number>();\n  @Output() readonly previousMonth = new EventEmitter<void>();\n  @Output() readonly nextMonth = new EventEmitter<void>();\n\n  readonly weekdays = WEEKDAY_LABELS;\n\n  /** Index of the cell showing a 170ms press animation, or -1. */\n  pressedIndex = -1;\n\n  get monthLabel(): string {\n    return this.view ? monthLabel(this.view) : \"\";\n  }\n\n  dayOf(option: SuggestionOption): number | null {\n    return cellDay(option);\n  }\n\n  isToday(option: SuggestionOption): boolean {\n    return cellIso(option) === isoDate(new Date());\n  }\n\n  /** Before today: rendered dimmed, but every bit as pickable as the rest. */\n  isPast(option: SuggestionOption): boolean {\n    const iso = cellIso(option);\n    // ISO strings order the same way the dates they name do.\n    return iso != null && iso < isoDate(new Date());\n  }\n\n  isSelected(option: SuggestionOption): boolean {\n    return dateCellMarks(cellIso(option), {\n      selectedIso: this.selection.selectedIso,\n      range: this.paintedRange,\n    }).selected;\n  }\n\n  /** Between the two ends of the painted span — banded, not filled. */\n  isInRange(option: SuggestionOption): boolean {\n    return dateCellMarks(cellIso(option), {\n      selectedIso: this.selection.selectedIso,\n      range: this.paintedRange,\n    }).inRange;\n  }\n\n  /**\n   * While a start is pending, the span runs to whatever cell is highlighted —\n   * the hover/arrow preview that tells the user the first tap registered.\n   *\n   * A getter rather than a cached field: `OnPush` re-runs the template's\n   * bindings whenever `options`, `activeIndex` or `selection` changes, and each\n   * of those changes this answer.\n   */\n  private get paintedRange(): DateRange | null {\n    return visibleDateRange({\n      pendingStart: this.selection.rangeStart,\n      highlightedIso: cellIso(this.options[this.activeIndex]),\n      selected: this.selection.selectedRange,\n    });\n  }\n\n  onSelect(option: SuggestionOption, index: number): void {\n    this.pressedIndex = index;\n    this.select.emit(option);\n    setTimeout(() => {\n      this.pressedIndex = -1;\n    }, 170);\n  }\n\n  onKeyDown(event: KeyboardEvent, option: SuggestionOption, index: number): void {\n    if (event.key === \"Enter\" || event.key === \" \") {\n      event.preventDefault();\n      this.onSelect(option, index);\n    }\n  }\n\n  /** Keeps the input focused, which the dropdown's visibility gate depends on. */\n  preventBlur(event: MouseEvent): void {\n    event.preventDefault();\n  }\n\n  // Padding cells have no date of their own, so they key off position.\n  trackByCell = (index: number, option: SuggestionOption): string =>\n    cellIso(option) ?? `pad-${index}`;\n}\n","<div class=\"magicx-aia-datepicker\" data-aia-datepicker=\"\">\n  <div class=\"magicx-aia-datepicker-header\">\n    <!-- tabIndex -1 for the same reason the skip button is: Tab is already\n         bound to walking the dropdown's options. -->\n    <button\n      type=\"button\"\n      tabindex=\"-1\"\n      class=\"magicx-aia-datepicker-nav\"\n      data-aia-date-prev=\"\"\n      aria-label=\"Previous month\"\n      (mousedown)=\"preventBlur($event)\"\n      (click)=\"previousMonth.emit()\"\n    >\n      &lsaquo;\n    </button>\n    <span class=\"magicx-aia-datepicker-month\" data-aia-date-month=\"\" aria-live=\"polite\">\n      {{ monthLabel }}\n    </span>\n    <button\n      type=\"button\"\n      tabindex=\"-1\"\n      class=\"magicx-aia-datepicker-nav\"\n      data-aia-date-next=\"\"\n      aria-label=\"Next month\"\n      (mousedown)=\"preventBlur($event)\"\n      (click)=\"nextMonth.emit()\"\n    >\n      &rsaquo;\n    </button>\n  </div>\n\n  <!-- Decorative: each cell announces its own full date, so repeating the\n       column letters to AT adds noise — and the duplicate T/S would be\n       meaningless read aloud anyway. -->\n  <div class=\"magicx-aia-datepicker-weekdays\" aria-hidden=\"true\">\n    <span class=\"magicx-aia-datepicker-weekday\" *ngFor=\"let label of weekdays\">{{ label }}</span>\n  </div>\n\n  <div class=\"magicx-aia-datepicker-grid\" data-aia-date-grid=\"\">\n    <ng-container *ngFor=\"let option of options; trackBy: trackByCell; let i = index\">\n      <!-- Padding for the days before the 1st / after the last. Non-tappable,\n           so arrow navigation skips it; hidden from AT so the month reads as\n           its own days and nothing else. -->\n      <div\n        *ngIf=\"dayOf(option) === null; else dayCell\"\n        [id]=\"listboxId + '-option-' + i\"\n        role=\"option\"\n        data-aia-option=\"\"\n        data-aia-date-cell=\"\"\n        aria-hidden=\"true\"\n        [attr.aria-selected]=\"false\"\n        tabindex=\"-1\"\n        class=\"magicx-aia-date-cell magicx-aia-date-cell--blank\"\n      ></div>\n\n      <ng-template #dayCell>\n        <!-- A day already gone by is de-emphasized, not disabled: it renders\n             dimmed but stays every bit as pickable as the rest of the month. -->\n        <div\n          [id]=\"listboxId + '-option-' + i\"\n          role=\"option\"\n          data-aia-option=\"\"\n          data-aia-date-cell=\"\"\n          [attr.aria-selected]=\"i === activeIndex\"\n          [attr.aria-label]=\"option.text\"\n          tabindex=\"0\"\n          class=\"magicx-aia-date-cell magicx-aia-date-cell--day\"\n          [class.magicx-aia-date-cell--past]=\"isPast(option)\"\n          [class.magicx-aia-date-cell--highlighted]=\"i === activeIndex\"\n          [class.magicx-aia-date-cell--today]=\"isToday(option)\"\n          [class.magicx-aia-date-cell--in-range]=\"isInRange(option)\"\n          [class.magicx-aia-date-cell--selected]=\"isSelected(option)\"\n          [class.magicx-aia-date-cell--pressed]=\"i === pressedIndex\"\n          (click)=\"onSelect(option, i)\"\n          (keydown)=\"onKeyDown($event, option, i)\"\n          (mouseenter)=\"highlight.emit(i)\"\n        >\n          <!-- The cell paints the day number; `option.text` is the full\n               committed value (\"March 23 2026\") and is what AT announces,\n               since that is what selecting it puts in the input. -->\n          <span class=\"magicx-aia-date-cell-number\">{{ dayOf(option) }}</span>\n        </div>\n      </ng-template>\n    </ng-container>\n  </div>\n</div>\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"date-grid.component.js","sourceRoot":"","sources":["../../../../../src/lib/internal/date-grid/date-grid.component.ts","../../../../../src/lib/internal/date-grid/date-grid.component.html"],"names":[],"mappings":"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","sourcesContent":["import { CommonModule } from \"@angular/common\";\nimport {\n  ChangeDetectionStrategy,\n  Component,\n  EventEmitter,\n  Input,\n  Output,\n  ViewEncapsulation,\n} from \"@angular/core\";\nimport {\n  cellDay,\n  cellIso,\n  type DateMonthView,\n  type DateRange,\n  type DateSelection,\n  dateCellMarks,\n  isoDate,\n  monthLabel,\n  type SuggestionOption,\n  visibleDateRange,\n  WEEKDAY_LABELS,\n} from \"@magicx-eng/ai-autocomplete-vanilla\";\n\n/**\n * The dropdown's calendar body, rendered in place of the options grid when the\n * active parameter is a date. Angular analogue of vanilla's `renderDateGrid`\n * and React's `<DateGrid>`.\n *\n * The cells carry the same `${listboxId}-option-${i}` ids, `role=\"option\"` and\n * `aria-selected` the options grid emits, and that is load-bearing rather than\n * cosmetic: the keyboard controller lives in the vanilla core for all three\n * packages, navigates by index into `filteredOptions`, and commits by clicking\n * `#${listboxId}-option-${i}`. `getEffectiveColumns` also measures the live\n * `grid-template-columns` of option-0's parent, which is why the 7 columns sit\n * on the cell container itself and not on an ancestor.\n *\n * @internal\n */\n@Component({\n  selector: \"aia-date-grid\",\n  standalone: true,\n  imports: [CommonModule],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  encapsulation: ViewEncapsulation.None,\n  templateUrl: \"./date-grid.component.html\",\n  styleUrls: [\"./date-grid.component.css\"],\n})\nexport class DateGridComponent {\n  /** The visible month's cells. These ARE `filteredOptions` — see `buildDateOptions`. */\n  @Input() options: SuggestionOption[] = [];\n  @Input() activeIndex = -1;\n  @Input() listboxId = \"\";\n  @Input() view: DateMonthView | null = null;\n  /** What the calendar paints as answered — see the core's `dateSelectionFor`. */\n  @Input() selection: DateSelection = { selectedIso: null, selectedRange: null, rangeStart: null };\n\n  @Output() readonly select = new EventEmitter<SuggestionOption>();\n  @Output() readonly highlight = new EventEmitter<number>();\n\n  /** The pointer left cell `index` — the dropdown clears a highlight still on it. */\n  @Output() readonly unhighlight = new EventEmitter<number>();\n  @Output() readonly previousMonth = new EventEmitter<void>();\n  @Output() readonly nextMonth = new EventEmitter<void>();\n\n  readonly weekdays = WEEKDAY_LABELS;\n\n  /** Index of the cell showing a 170ms press animation, or -1. */\n  pressedIndex = -1;\n\n  get monthLabel(): string {\n    return this.view ? monthLabel(this.view) : \"\";\n  }\n\n  dayOf(option: SuggestionOption): number | null {\n    return cellDay(option);\n  }\n\n  isToday(option: SuggestionOption): boolean {\n    return cellIso(option) === isoDate(new Date());\n  }\n\n  /** Before today: rendered dimmed, but every bit as pickable as the rest. */\n  isPast(option: SuggestionOption): boolean {\n    const iso = cellIso(option);\n    // ISO strings order the same way the dates they name do.\n    return iso != null && iso < isoDate(new Date());\n  }\n\n  isSelected(option: SuggestionOption): boolean {\n    return dateCellMarks(cellIso(option), {\n      selectedIso: this.selection.selectedIso,\n      range: this.paintedRange,\n    }).selected;\n  }\n\n  /** Between the two ends of the painted span — banded, not filled. */\n  isInRange(option: SuggestionOption): boolean {\n    return dateCellMarks(cellIso(option), {\n      selectedIso: this.selection.selectedIso,\n      range: this.paintedRange,\n    }).inRange;\n  }\n\n  /**\n   * While a start is pending, the span runs to whatever cell is highlighted —\n   * the hover/arrow preview that tells the user the first tap registered.\n   *\n   * A getter rather than a cached field: `OnPush` re-runs the template's\n   * bindings whenever `options`, `activeIndex` or `selection` changes, and each\n   * of those changes this answer.\n   */\n  private get paintedRange(): DateRange | null {\n    return visibleDateRange({\n      pendingStart: this.selection.rangeStart,\n      highlightedIso: cellIso(this.options[this.activeIndex]),\n      selected: this.selection.selectedRange,\n    });\n  }\n\n  onSelect(option: SuggestionOption, index: number): void {\n    this.pressedIndex = index;\n    this.select.emit(option);\n    setTimeout(() => {\n      this.pressedIndex = -1;\n    }, 170);\n  }\n\n  onKeyDown(event: KeyboardEvent, option: SuggestionOption, index: number): void {\n    if (event.key === \"Enter\" || event.key === \" \") {\n      event.preventDefault();\n      this.onSelect(option, index);\n    }\n  }\n\n  /** Keeps the input focused, which the dropdown's visibility gate depends on. */\n  preventBlur(event: MouseEvent): void {\n    event.preventDefault();\n  }\n\n  // Padding cells have no date of their own, so they key off position.\n  trackByCell = (index: number, option: SuggestionOption): string =>\n    cellIso(option) ?? `pad-${index}`;\n}\n","<div class=\"magicx-aia-datepicker\" data-aia-datepicker=\"\">\n  <div class=\"magicx-aia-datepicker-header\">\n    <!-- tabIndex -1 for the same reason the skip button is: Tab is already\n         bound to walking the dropdown's options. -->\n    <button\n      type=\"button\"\n      tabindex=\"-1\"\n      class=\"magicx-aia-datepicker-nav\"\n      data-aia-date-prev=\"\"\n      aria-label=\"Previous month\"\n      (mousedown)=\"preventBlur($event)\"\n      (click)=\"previousMonth.emit()\"\n    >\n      &lsaquo;\n    </button>\n    <span class=\"magicx-aia-datepicker-month\" data-aia-date-month=\"\" aria-live=\"polite\">\n      {{ monthLabel }}\n    </span>\n    <button\n      type=\"button\"\n      tabindex=\"-1\"\n      class=\"magicx-aia-datepicker-nav\"\n      data-aia-date-next=\"\"\n      aria-label=\"Next month\"\n      (mousedown)=\"preventBlur($event)\"\n      (click)=\"nextMonth.emit()\"\n    >\n      &rsaquo;\n    </button>\n  </div>\n\n  <!-- Decorative: each cell announces its own full date, so repeating the\n       column letters to AT adds noise — and the duplicate T/S would be\n       meaningless read aloud anyway. -->\n  <div class=\"magicx-aia-datepicker-weekdays\" aria-hidden=\"true\">\n    <span class=\"magicx-aia-datepicker-weekday\" *ngFor=\"let label of weekdays\">{{ label }}</span>\n  </div>\n\n  <div class=\"magicx-aia-datepicker-grid\" data-aia-date-grid=\"\">\n    <ng-container *ngFor=\"let option of options; trackBy: trackByCell; let i = index\">\n      <!-- Padding for the days before the 1st / after the last. Non-tappable,\n           so arrow navigation skips it; hidden from AT so the month reads as\n           its own days and nothing else. -->\n      <div\n        *ngIf=\"dayOf(option) === null; else dayCell\"\n        [id]=\"listboxId + '-option-' + i\"\n        role=\"option\"\n        data-aia-option=\"\"\n        data-aia-date-cell=\"\"\n        aria-hidden=\"true\"\n        [attr.aria-selected]=\"false\"\n        tabindex=\"-1\"\n        class=\"magicx-aia-date-cell magicx-aia-date-cell--blank\"\n      ></div>\n\n      <ng-template #dayCell>\n        <!-- A day already gone by is de-emphasized, not disabled: it renders\n             dimmed but stays every bit as pickable as the rest of the month. -->\n        <div\n          [id]=\"listboxId + '-option-' + i\"\n          role=\"option\"\n          data-aia-option=\"\"\n          data-aia-date-cell=\"\"\n          [attr.aria-selected]=\"i === activeIndex\"\n          [attr.aria-label]=\"option.text\"\n          tabindex=\"0\"\n          class=\"magicx-aia-date-cell magicx-aia-date-cell--day\"\n          [class.magicx-aia-date-cell--past]=\"isPast(option)\"\n          [class.magicx-aia-date-cell--highlighted]=\"i === activeIndex\"\n          [class.magicx-aia-date-cell--today]=\"isToday(option)\"\n          [class.magicx-aia-date-cell--in-range]=\"isInRange(option)\"\n          [class.magicx-aia-date-cell--selected]=\"isSelected(option)\"\n          [class.magicx-aia-date-cell--pressed]=\"i === pressedIndex\"\n          (click)=\"onSelect(option, i)\"\n          (keydown)=\"onKeyDown($event, option, i)\"\n          (mouseenter)=\"highlight.emit(i)\"\n          (mouseleave)=\"unhighlight.emit(i)\"\n        >\n          <!-- The cell paints the day number; `option.text` is the full\n               committed value (\"March 23 2026\") and is what AT announces,\n               since that is what selecting it puts in the input. -->\n          <span class=\"magicx-aia-date-cell-number\">{{ dayOf(option) }}</span>\n        </div>\n      </ng-template>\n    </ng-container>\n  </div>\n</div>\n"]}

package/esm2020/lib/internal/suggestion-grid/suggestion-grid.component.mjs

@@ -39,6 +39,8 @@ export class SuggestionGridComponent {
         this.showCounts = true;
         this.select = new EventEmitter();
         this.highlight = new EventEmitter();
+        /** The pointer left option `index` — the dropdown clears a highlight still on it. */
+        this.unhighlight = new EventEmitter();
         this.cdr = inject(ChangeDetectorRef);
         /**
          * The measured layout plan. Starts as the measurement-free baseline (one
@@ -121,10 +123,10 @@ export class SuggestionGridComponent {
     }
 }
 SuggestionGridComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: SuggestionGridComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
-SuggestionGridComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.10", type: SuggestionGridComponent, isStandalone: true, selector: "aia-suggestion-grid", inputs: { options: "options", activeIndex: "activeIndex", listboxId: "listboxId", loading: "loading", groupKey: "groupKey", optionsPosition: "optionsPosition", showIcons: "showIcons", showImages: "showImages", showCounts: "showCounts" }, outputs: { select: "select", highlight: "highlight" }, host: { listeners: { "window:resize": "onResize()" } }, viewQueries: [{ propertyName: "gridComp", first: true, predicate: GridComponent, descendants: true }], usesOnChanges: true, ngImport: i0, template: "<!-- max=\"1fr\": columns share out the full width, so a lone column spans the\n     whole options box instead of stopping at 250px. -->\n<aia-grid\n  min=\"250px\"\n  max=\"1fr\"\n  gap=\"0\"\n  [scroll]=\"true\"\n  [scrollResetKey]=\"groupKey\"\n  [template]=\"plan.template\"\n  [maxHeight]=\"plan.maxHeight\"\n  [group]=\"groupKey\"\n>\n  <aia-suggestion-item\n    *ngFor=\"let option of options; trackBy: trackByOptionText; let i = index\"\n    [option]=\"option\"\n    [isHighlighted]=\"i === activeIndex\"\n    [id]=\"listboxId + '-option-' + i\"\n    [loading]=\"loading\"\n    [showIcon]=\"showIcons\"\n    [showImage]=\"showImages\"\n    [showCount]=\"showCounts\"\n    [scrollHint]=\"isScrollHint(i)\"\n    [enterDelayMs]=\"enterDelayMs(i)\"\n    (select)=\"select.emit($event)\"\n    (highlight)=\"highlight.emit(i)\"\n  ></aia-suggestion-item>\n</aia-grid>\n", dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "component", type: GridComponent, selector: "aia-grid", inputs: ["min", "max", "gap", "scroll", "maxHeight", "scrollResetKey", "cols", "template", "group"] }, { kind: "component", type: SuggestionItemComponent, selector: "aia-suggestion-item", inputs: ["option", "isHighlighted", "id", "loading", "showIcon", "showImage", "showCount", "scrollHint", "enterDelayMs"], outputs: ["select", "highlight"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });
+SuggestionGridComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.10", type: SuggestionGridComponent, isStandalone: true, selector: "aia-suggestion-grid", inputs: { options: "options", activeIndex: "activeIndex", listboxId: "listboxId", loading: "loading", groupKey: "groupKey", optionsPosition: "optionsPosition", showIcons: "showIcons", showImages: "showImages", showCounts: "showCounts" }, outputs: { select: "select", highlight: "highlight", unhighlight: "unhighlight" }, host: { listeners: { "window:resize": "onResize()" } }, viewQueries: [{ propertyName: "gridComp", first: true, predicate: GridComponent, descendants: true }], usesOnChanges: true, ngImport: i0, template: "<!-- max=\"1fr\": columns share out the full width, so a lone column spans the\n     whole options box instead of stopping at 250px. -->\n<aia-grid\n  min=\"250px\"\n  max=\"1fr\"\n  gap=\"0\"\n  [scroll]=\"true\"\n  [scrollResetKey]=\"groupKey\"\n  [template]=\"plan.template\"\n  [maxHeight]=\"plan.maxHeight\"\n  [group]=\"groupKey\"\n>\n  <aia-suggestion-item\n    *ngFor=\"let option of options; trackBy: trackByOptionText; let i = index\"\n    [option]=\"option\"\n    [isHighlighted]=\"i === activeIndex\"\n    [id]=\"listboxId + '-option-' + i\"\n    [loading]=\"loading\"\n    [showIcon]=\"showIcons\"\n    [showImage]=\"showImages\"\n    [showCount]=\"showCounts\"\n    [scrollHint]=\"isScrollHint(i)\"\n    [enterDelayMs]=\"enterDelayMs(i)\"\n    (select)=\"select.emit($event)\"\n    (highlight)=\"highlight.emit(i)\"\n    (unhighlight)=\"unhighlight.emit(i)\"\n  ></aia-suggestion-item>\n</aia-grid>\n", dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "component", type: GridComponent, selector: "aia-grid", inputs: ["min", "max", "gap", "scroll", "maxHeight", "scrollResetKey", "cols", "template", "group"] }, { kind: "component", type: SuggestionItemComponent, selector: "aia-suggestion-item", inputs: ["option", "isHighlighted", "id", "loading", "showIcon", "showImage", "showCount", "scrollHint", "enterDelayMs"], outputs: ["select", "highlight", "unhighlight"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: SuggestionGridComponent, decorators: [{
             type: Component,
-            args: [{ selector: "aia-suggestion-grid", standalone: true, imports: [CommonModule, GridComponent, SuggestionItemComponent], changeDetection: ChangeDetectionStrategy.OnPush, encapsulation: ViewEncapsulation.None, template: "<!-- max=\"1fr\": columns share out the full width, so a lone column spans the\n     whole options box instead of stopping at 250px. -->\n<aia-grid\n  min=\"250px\"\n  max=\"1fr\"\n  gap=\"0\"\n  [scroll]=\"true\"\n  [scrollResetKey]=\"groupKey\"\n  [template]=\"plan.template\"\n  [maxHeight]=\"plan.maxHeight\"\n  [group]=\"groupKey\"\n>\n  <aia-suggestion-item\n    *ngFor=\"let option of options; trackBy: trackByOptionText; let i = index\"\n    [option]=\"option\"\n    [isHighlighted]=\"i === activeIndex\"\n    [id]=\"listboxId + '-option-' + i\"\n    [loading]=\"loading\"\n    [showIcon]=\"showIcons\"\n    [showImage]=\"showImages\"\n    [showCount]=\"showCounts\"\n    [scrollHint]=\"isScrollHint(i)\"\n    [enterDelayMs]=\"enterDelayMs(i)\"\n    (select)=\"select.emit($event)\"\n    (highlight)=\"highlight.emit(i)\"\n  ></aia-suggestion-item>\n</aia-grid>\n" }]
+            args: [{ selector: "aia-suggestion-grid", standalone: true, imports: [CommonModule, GridComponent, SuggestionItemComponent], changeDetection: ChangeDetectionStrategy.OnPush, encapsulation: ViewEncapsulation.None, template: "<!-- max=\"1fr\": columns share out the full width, so a lone column spans the\n     whole options box instead of stopping at 250px. -->\n<aia-grid\n  min=\"250px\"\n  max=\"1fr\"\n  gap=\"0\"\n  [scroll]=\"true\"\n  [scrollResetKey]=\"groupKey\"\n  [template]=\"plan.template\"\n  [maxHeight]=\"plan.maxHeight\"\n  [group]=\"groupKey\"\n>\n  <aia-suggestion-item\n    *ngFor=\"let option of options; trackBy: trackByOptionText; let i = index\"\n    [option]=\"option\"\n    [isHighlighted]=\"i === activeIndex\"\n    [id]=\"listboxId + '-option-' + i\"\n    [loading]=\"loading\"\n    [showIcon]=\"showIcons\"\n    [showImage]=\"showImages\"\n    [showCount]=\"showCounts\"\n    [scrollHint]=\"isScrollHint(i)\"\n    [enterDelayMs]=\"enterDelayMs(i)\"\n    (select)=\"select.emit($event)\"\n    (highlight)=\"highlight.emit(i)\"\n    (unhighlight)=\"unhighlight.emit(i)\"\n  ></aia-suggestion-item>\n</aia-grid>\n" }]
         }], propDecorators: { options: [{
                 type: Input
             }], activeIndex: [{
@@ -147,6 +149,8 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImpo
                 type: Output
             }], highlight: [{
                 type: Output
+            }], unhighlight: [{
+                type: Output
             }], gridComp: [{
                 type: ViewChild,
                 args: [GridComponent, { static: false }]
@@ -154,4 +158,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImpo
                 type: HostListener,
                 args: ["window:resize"]
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"suggestion-grid.component.js","sourceRoot":"","sources":["../../../../../src/lib/internal/suggestion-grid/suggestion-grid.component.ts","../../../../../src/lib/internal/suggestion-grid/suggestion-grid.component.html"],"names":[],"mappings":"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","sourcesContent":["import { CommonModule } from \"@angular/common\";\nimport {\n  type AfterViewChecked,\n  ChangeDetectionStrategy,\n  ChangeDetectorRef,\n  Component,\n  EventEmitter,\n  HostListener,\n  Input,\n  inject,\n  type OnChanges,\n  Output,\n  type SimpleChanges,\n  ViewChild,\n  ViewEncapsulation,\n} from \"@angular/core\";\nimport {\n  isOptionsGridMobileViewport,\n  measureOptionsGrid,\n  needsOptionsGridMeasurement,\n  type OptionsGridPlan,\n  optionEnterDelayMs,\n  planOptionsGrid,\n  type SuggestionOption,\n  sameOptionRows,\n} from \"@magicx-eng/ai-autocomplete-vanilla\";\nimport { GridComponent } from \"../layout/grid.component\";\nimport { SuggestionItemComponent } from \"../suggestion-item/suggestion-item.component\";\n\n/**\n * Internal grid of suggestion options. Mirrors\n * `packages/react/src/components/SuggestionGrid.tsx` — a thin wrapper over the\n * `Grid` layout primitive (which owns the auto-fit columns and the\n * capped-height scroll). It only wires each option to its\n * select/highlight handlers and listbox-scoped id.\n *\n * @internal\n */\n@Component({\n  selector: \"aia-suggestion-grid\",\n  standalone: true,\n  imports: [CommonModule, GridComponent, SuggestionItemComponent],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  encapsulation: ViewEncapsulation.None,\n  templateUrl: \"./suggestion-grid.component.html\",\n})\nexport class SuggestionGridComponent implements OnChanges, AfterViewChecked {\n  @Input() options: SuggestionOption[] = [];\n  @Input() activeIndex = -1;\n  @Input() listboxId = \"\";\n  @Input() loading = false;\n  /**\n   * Identity of the suggestion these options belong to. When it changes the\n   * grid scrolls back to the top, so the next parameter's options are read\n   * from the first one instead of from the previous list's scroll offset.\n   */\n  @Input() groupKey = \"\";\n  /**\n   * Which side of the input the dropdown opens on. The rows' entrance starts\n   * from the input's side outward, so \"above\" reverses the order.\n   */\n  @Input() optionsPosition: \"above\" | \"below\" = \"below\";\n  /** Whether rows draw their `icon_svg` before the text. Default: true. */\n  @Input() showIcons = true;\n  /** Whether rows draw their `image_url` as a thumbnail before the text. Default: true. */\n  @Input() showImages = true;\n  /** Whether rows show their `item_count` at the trailing edge. Default: true. */\n  @Input() showCounts = true;\n\n  @Output() readonly select = new EventEmitter<SuggestionOption>();\n  @Output() readonly highlight = new EventEmitter<number>();\n\n  private readonly cdr = inject(ChangeDetectorRef);\n\n  @ViewChild(GridComponent, { static: false }) private gridComp?: GridComponent;\n\n  /**\n   * The measured layout plan. Starts as the measurement-free baseline (one\n   * column); after each view update the rendered rows are measured and the\n   * plan upgrades to two columns when they provably fit — same two-pass the\n   * React grid does with its layout effect, all through `planOptionsGrid`.\n   */\n  plan: OptionsGridPlan = planOptionsGrid(0, false, null, null);\n  private needsMeasure = true;\n  /**\n   * The rows the current plan was measured from. A skeleton mirroring them\n   * keeps that plan — see `sameOptionRows`.\n   */\n  private measuredRows: SuggestionOption[] | null = null;\n\n  // Re-measure when the viewport changes (breakpoint or width both matter to\n  // the two-column fit).\n  @HostListener(\"window:resize\")\n  onResize(): void {\n    this.needsMeasure = true;\n    this.cdr.markForCheck();\n  }\n\n  ngOnChanges(changes: SimpleChanges): void {\n    // Only the inputs the plan depends on reset it — activeIndex changes on\n    // every arrow key and must not knock a measured two-column grid back to\n    // the baseline (the React grid's layout effect excludes it the same way).\n    if (!changes[\"options\"] && !changes[\"loading\"]) return;\n    if (this.loading && sameOptionRows(this.measuredRows, this.options)) return;\n    this.measuredRows = this.loading ? null : this.options;\n    this.needsMeasure = true;\n    // The pre-measure baseline for the new inputs, so the first paint is the\n    // same one-column layout the other packages start from.\n    this.plan = planOptionsGrid(this.options.length, isOptionsGridMobileViewport(), null, null);\n  }\n\n  ngAfterViewChecked(): void {\n    if (!this.needsMeasure) return;\n    this.needsMeasure = false;\n    const isMobile = isOptionsGridMobileViewport();\n    const grid = this.gridComp?.gridRef?.nativeElement;\n    // Measuring clones every row and forces a layout — skip it whenever the\n    // plan would ignore the result (mobile, fewer than five options).\n    const shouldMeasure =\n      grid && !this.loading && needsOptionsGridMeasurement(this.options.length, isMobile);\n    const measured = shouldMeasure ? measureOptionsGrid(grid) : null;\n    const next = planOptionsGrid(\n      this.options.length,\n      isMobile,\n      measured?.rowWidths ?? null,\n      measured?.gridWidth ?? null,\n    );\n    const unchanged =\n      next.template === this.plan.template &&\n      next.maxHeight === this.plan.maxHeight &&\n      next.scrollHintIndices.join() === this.plan.scrollHintIndices.join();\n    if (unchanged) return;\n    // The view was already checked this cycle — apply the measured plan in a\n    // fresh microtask so OnPush picks it up without an\n    // ExpressionChangedAfterItHasBeenChecked error.\n    queueMicrotask(() => {\n      this.plan = next;\n      this.cdr.markForCheck();\n    });\n  }\n\n  isScrollHint(index: number): boolean {\n    return !this.loading && this.plan.scrollHintIndices.includes(index);\n  }\n\n  /**\n   * Start delay of row `index`'s entrance — each row rises in a beat after\n   * the one nearer the input. Skeleton rows fade in together (they're\n   * placeholders, not content arriving).\n   */\n  enterDelayMs(index: number): number {\n    if (this.loading) return 0;\n    // Across the columns the measured plan settled on — the two-column\n    // upgrade only decides that after the rows exist.\n    return optionEnterDelayMs(index, this.plan.cols, this.options.length, this.optionsPosition);\n  }\n\n  /**\n   * The group is part of the identity: a new suggestion's options are new\n   * rows and get the entrance animation even when one spells the same as a\n   * row already on screen.\n   */\n  trackByOptionText = (_: number, opt: SuggestionOption): string => `${this.groupKey}\\0${opt.text}`;\n}\n","<!-- max=\"1fr\": columns share out the full width, so a lone column spans the\n     whole options box instead of stopping at 250px. -->\n<aia-grid\n  min=\"250px\"\n  max=\"1fr\"\n  gap=\"0\"\n  [scroll]=\"true\"\n  [scrollResetKey]=\"groupKey\"\n  [template]=\"plan.template\"\n  [maxHeight]=\"plan.maxHeight\"\n  [group]=\"groupKey\"\n>\n  <aia-suggestion-item\n    *ngFor=\"let option of options; trackBy: trackByOptionText; let i = index\"\n    [option]=\"option\"\n    [isHighlighted]=\"i === activeIndex\"\n    [id]=\"listboxId + '-option-' + i\"\n    [loading]=\"loading\"\n    [showIcon]=\"showIcons\"\n    [showImage]=\"showImages\"\n    [showCount]=\"showCounts\"\n    [scrollHint]=\"isScrollHint(i)\"\n    [enterDelayMs]=\"enterDelayMs(i)\"\n    (select)=\"select.emit($event)\"\n    (highlight)=\"highlight.emit(i)\"\n  ></aia-suggestion-item>\n</aia-grid>\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"suggestion-grid.component.js","sourceRoot":"","sources":["../../../../../src/lib/internal/suggestion-grid/suggestion-grid.component.ts","../../../../../src/lib/internal/suggestion-grid/suggestion-grid.component.html"],"names":[],"mappings":"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","sourcesContent":["import { CommonModule } from \"@angular/common\";\nimport {\n  type AfterViewChecked,\n  ChangeDetectionStrategy,\n  ChangeDetectorRef,\n  Component,\n  EventEmitter,\n  HostListener,\n  Input,\n  inject,\n  type OnChanges,\n  Output,\n  type SimpleChanges,\n  ViewChild,\n  ViewEncapsulation,\n} from \"@angular/core\";\nimport {\n  isOptionsGridMobileViewport,\n  measureOptionsGrid,\n  needsOptionsGridMeasurement,\n  type OptionsGridPlan,\n  optionEnterDelayMs,\n  planOptionsGrid,\n  type SuggestionOption,\n  sameOptionRows,\n} from \"@magicx-eng/ai-autocomplete-vanilla\";\nimport { GridComponent } from \"../layout/grid.component\";\nimport { SuggestionItemComponent } from \"../suggestion-item/suggestion-item.component\";\n\n/**\n * Internal grid of suggestion options. Mirrors\n * `packages/react/src/components/SuggestionGrid.tsx` — a thin wrapper over the\n * `Grid` layout primitive (which owns the auto-fit columns and the\n * capped-height scroll). It only wires each option to its\n * select/highlight handlers and listbox-scoped id.\n *\n * @internal\n */\n@Component({\n  selector: \"aia-suggestion-grid\",\n  standalone: true,\n  imports: [CommonModule, GridComponent, SuggestionItemComponent],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  encapsulation: ViewEncapsulation.None,\n  templateUrl: \"./suggestion-grid.component.html\",\n})\nexport class SuggestionGridComponent implements OnChanges, AfterViewChecked {\n  @Input() options: SuggestionOption[] = [];\n  @Input() activeIndex = -1;\n  @Input() listboxId = \"\";\n  @Input() loading = false;\n  /**\n   * Identity of the suggestion these options belong to. When it changes the\n   * grid scrolls back to the top, so the next parameter's options are read\n   * from the first one instead of from the previous list's scroll offset.\n   */\n  @Input() groupKey = \"\";\n  /**\n   * Which side of the input the dropdown opens on. The rows' entrance starts\n   * from the input's side outward, so \"above\" reverses the order.\n   */\n  @Input() optionsPosition: \"above\" | \"below\" = \"below\";\n  /** Whether rows draw their `icon_svg` before the text. Default: true. */\n  @Input() showIcons = true;\n  /** Whether rows draw their `image_url` as a thumbnail before the text. Default: true. */\n  @Input() showImages = true;\n  /** Whether rows show their `item_count` at the trailing edge. Default: true. */\n  @Input() showCounts = true;\n\n  @Output() readonly select = new EventEmitter<SuggestionOption>();\n  @Output() readonly highlight = new EventEmitter<number>();\n  /** The pointer left option `index` — the dropdown clears a highlight still on it. */\n  @Output() readonly unhighlight = new EventEmitter<number>();\n\n  private readonly cdr = inject(ChangeDetectorRef);\n\n  @ViewChild(GridComponent, { static: false }) private gridComp?: GridComponent;\n\n  /**\n   * The measured layout plan. Starts as the measurement-free baseline (one\n   * column); after each view update the rendered rows are measured and the\n   * plan upgrades to two columns when they provably fit — same two-pass the\n   * React grid does with its layout effect, all through `planOptionsGrid`.\n   */\n  plan: OptionsGridPlan = planOptionsGrid(0, false, null, null);\n  private needsMeasure = true;\n  /**\n   * The rows the current plan was measured from. A skeleton mirroring them\n   * keeps that plan — see `sameOptionRows`.\n   */\n  private measuredRows: SuggestionOption[] | null = null;\n\n  // Re-measure when the viewport changes (breakpoint or width both matter to\n  // the two-column fit).\n  @HostListener(\"window:resize\")\n  onResize(): void {\n    this.needsMeasure = true;\n    this.cdr.markForCheck();\n  }\n\n  ngOnChanges(changes: SimpleChanges): void {\n    // Only the inputs the plan depends on reset it — activeIndex changes on\n    // every arrow key and must not knock a measured two-column grid back to\n    // the baseline (the React grid's layout effect excludes it the same way).\n    if (!changes[\"options\"] && !changes[\"loading\"]) return;\n    if (this.loading && sameOptionRows(this.measuredRows, this.options)) return;\n    this.measuredRows = this.loading ? null : this.options;\n    this.needsMeasure = true;\n    // The pre-measure baseline for the new inputs, so the first paint is the\n    // same one-column layout the other packages start from.\n    this.plan = planOptionsGrid(this.options.length, isOptionsGridMobileViewport(), null, null);\n  }\n\n  ngAfterViewChecked(): void {\n    if (!this.needsMeasure) return;\n    this.needsMeasure = false;\n    const isMobile = isOptionsGridMobileViewport();\n    const grid = this.gridComp?.gridRef?.nativeElement;\n    // Measuring clones every row and forces a layout — skip it whenever the\n    // plan would ignore the result (mobile, fewer than five options).\n    const shouldMeasure =\n      grid && !this.loading && needsOptionsGridMeasurement(this.options.length, isMobile);\n    const measured = shouldMeasure ? measureOptionsGrid(grid) : null;\n    const next = planOptionsGrid(\n      this.options.length,\n      isMobile,\n      measured?.rowWidths ?? null,\n      measured?.gridWidth ?? null,\n    );\n    const unchanged =\n      next.template === this.plan.template &&\n      next.maxHeight === this.plan.maxHeight &&\n      next.scrollHintIndices.join() === this.plan.scrollHintIndices.join();\n    if (unchanged) return;\n    // The view was already checked this cycle — apply the measured plan in a\n    // fresh microtask so OnPush picks it up without an\n    // ExpressionChangedAfterItHasBeenChecked error.\n    queueMicrotask(() => {\n      this.plan = next;\n      this.cdr.markForCheck();\n    });\n  }\n\n  isScrollHint(index: number): boolean {\n    return !this.loading && this.plan.scrollHintIndices.includes(index);\n  }\n\n  /**\n   * Start delay of row `index`'s entrance — each row rises in a beat after\n   * the one nearer the input. Skeleton rows fade in together (they're\n   * placeholders, not content arriving).\n   */\n  enterDelayMs(index: number): number {\n    if (this.loading) return 0;\n    // Across the columns the measured plan settled on — the two-column\n    // upgrade only decides that after the rows exist.\n    return optionEnterDelayMs(index, this.plan.cols, this.options.length, this.optionsPosition);\n  }\n\n  /**\n   * The group is part of the identity: a new suggestion's options are new\n   * rows and get the entrance animation even when one spells the same as a\n   * row already on screen.\n   */\n  trackByOptionText = (_: number, opt: SuggestionOption): string => `${this.groupKey}\\0${opt.text}`;\n}\n","<!-- max=\"1fr\": columns share out the full width, so a lone column spans the\n     whole options box instead of stopping at 250px. -->\n<aia-grid\n  min=\"250px\"\n  max=\"1fr\"\n  gap=\"0\"\n  [scroll]=\"true\"\n  [scrollResetKey]=\"groupKey\"\n  [template]=\"plan.template\"\n  [maxHeight]=\"plan.maxHeight\"\n  [group]=\"groupKey\"\n>\n  <aia-suggestion-item\n    *ngFor=\"let option of options; trackBy: trackByOptionText; let i = index\"\n    [option]=\"option\"\n    [isHighlighted]=\"i === activeIndex\"\n    [id]=\"listboxId + '-option-' + i\"\n    [loading]=\"loading\"\n    [showIcon]=\"showIcons\"\n    [showImage]=\"showImages\"\n    [showCount]=\"showCounts\"\n    [scrollHint]=\"isScrollHint(i)\"\n    [enterDelayMs]=\"enterDelayMs(i)\"\n    (select)=\"select.emit($event)\"\n    (highlight)=\"highlight.emit(i)\"\n    (unhighlight)=\"unhighlight.emit(i)\"\n  ></aia-suggestion-item>\n</aia-grid>\n"]}