@magicx-eng/ai-autocomplete-angular 0.1.0 → 0.2.0

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

@@ -38,17 +38,37 @@ export class AIAutocompleteController {
             optionsPosition: opts.optionsPosition ?? "below",
         });
         this.rawState$ = new BehaviorSubject(this.core.getState());
-        this.unsubscribeCore = this.core.subscribe((state) => {
+        // Push the store's *current* state, not the snapshot the listener was
+        // handed. The core notifies listeners synchronously, and some actions
+        // trigger reentrant `store.set` calls (e.g. typing a non-matching char
+        // during re-edit makes the core synchronously exit re-edit and kick off a
+        // fetch). Reentrancy makes the outer set's listener loop continue with a
+        // now-stale snapshot, so the listener can fire *out of order* — delivering
+        // an older state (still in re-edit) after a newer one (re-edit exited).
+        // Reading `getState()` at emission time collapses every notification onto
+        // the true latest state, so a stale `editingParam` can't resurrect and
+        // retrigger the editor's re-edit caret-park (which would yank the caret
+        // back to where re-editing started). distinctUntilChanged downstream drops
+        // the resulting duplicate emissions. React avoids this because it batches
+        // renders and its caret effects are dependency-gated; our subscription is
+        // synchronous, so we coalesce here instead.
+        this.unsubscribeCore = this.core.subscribe(() => {
             if (!this.isDestroyed)
-                this.rawState$.next(state);
+                this.rawState$.next(this.core.getState());
         });
         // === Per-field observables ===
+        // Array-valued fields use shallow equality. The vanilla store spreads on
+        // every write (`store.set({ completedParams: [...] })`), so reference
+        // equality would re-fire downstream subscribers on every state tick even
+        // when the array's contents are unchanged. The other fields are
+        // primitives or stable object references, so default identity equality
+        // works fine.
         this.text$ = deriveField(this.rawState$, (s) => s.text);
-        this.completedParams$ = deriveField(this.rawState$, (s) => s.completedParams);
-        this.suggestionPills$ = deriveField(this.rawState$, (s) => s.actionableSuggestions);
-        this.segments$ = deriveField(this.rawState$, (s) => s.segments);
+        this.completedParams$ = deriveField(this.rawState$, (s) => s.completedParams, arrEq);
+        this.suggestionPills$ = deriveField(this.rawState$, (s) => s.actionableSuggestions, arrEq);
+        this.segments$ = deriveField(this.rawState$, (s) => s.segments, arrEq);
         this.newParamId$ = deriveField(this.rawState$, (s) => s.newParamId);
-        this.suggestions$ = deriveField(this.rawState$, (s) => s.suggestions);
+        this.suggestions$ = deriveField(this.rawState$, (s) => s.suggestions, arrEq);
         this.activeIndex$ = deriveField(this.rawState$, (s) => s.activeDropdownIndex);
         this.isLoading$ = deriveField(this.rawState$, computeUiLoading);
         this.isReady$ = deriveField(this.rawState$, (s) => s.isReady);
@@ -89,68 +109,109 @@ export class AIAutocompleteController {
         return computeState(this.rawState$.value);
     }
     // === Action methods (pass-through to the core) ===
+    //
+    // Every action method begins with an `isDestroyed` guard so that callers
+    // who hold a stale reference after `destroy()` don't accidentally trigger
+    // work on a torn-down core. The vanilla core does not gate its own methods
+    // post-dispose — `reset()`, `handleTextChange()`, and friends would still
+    // schedule fetches or fire HTTP requests against an aborted controller,
+    // and the responses would have nowhere to surface (rawState$ is already
+    // complete). The guard makes the JSDoc-promised "no-op silently"
+    // semantics actually true.
     /** Clear all state, rotate `session_id`, and re-fetch. Call after submit. */
     reset() {
+        if (this.isDestroyed)
+            return;
         this.core.reset();
     }
     /** Pick a dropdown option (or replace the re-edited param if in re-edit mode). */
     selectOption(option) {
+        if (this.isDestroyed)
+            return;
         this.core.selectOption(option);
     }
     /** Promote the pill at `index` to active (front of the list). */
     setActivePill(index) {
+        if (this.isDestroyed)
+            return;
         this.core.setActivePill(index);
     }
     /** Drop the last completed param's "completed" status. Text stays as plain text. */
     removeLastParam() {
+        if (this.isDestroyed)
+            return;
         this.core.removeLastParam();
     }
     /** Clear the shimmer animation state for the most-recently-added param. */
     clearNewParamId() {
+        if (this.isDestroyed)
+            return;
         this.core.clearNewParamId();
     }
     /** Controlled-mode setter for editor text. */
     setValue(text) {
+        if (this.isDestroyed)
+            return;
         this.core.setValue(text);
     }
     /** Controlled-mode setter for completed params. */
     setCompletedParams(params) {
+        if (this.isDestroyed)
+            return;
         this.core.setCompletedParams(params);
     }
     /** Forward plain-text input from the consumer's `<textarea>` to the core. */
     handleTextChange(value) {
+        if (this.isDestroyed)
+            return;
         this.core.handleTextChange(value);
     }
     /** Forward keyboard events from the consumer's `<textarea>` to the core. */
     handleKeyDown(event) {
+        if (this.isDestroyed)
+            return;
         this.core.handleKeyDown(event);
     }
     /** Notify the core of focus state. */
     setFocused(focused) {
+        if (this.isDestroyed)
+            return;
         this.core.setFocused(focused);
     }
     /** Enter re-edit mode for the bold param with the given id. */
     startEditingParam(paramId) {
+        if (this.isDestroyed)
+            return;
         this.core.startEditingParam(paramId);
     }
     /** Exit re-edit mode without changing the bold param. */
     exitEditMode() {
+        if (this.isDestroyed)
+            return;
         this.core.exitEditMode();
     }
     /** Forward post-input caret position (extends the edit tail). */
     handleCaretAfterInput(offset) {
+        if (this.isDestroyed)
+            return;
         this.core.handleCaretAfterInput(offset);
     }
     /** Forward selection-only caret moves (may exit re-edit). */
     handleCaretMove(offset) {
+        if (this.isDestroyed)
+            return;
         this.core.handleCaretMove(offset);
     }
     /** Replace the bold param being re-edited. Returns true when applied. */
     replaceEditingRange(replacement) {
+        if (this.isDestroyed)
+            return false;
         return this.core.replaceEditingRange(replacement);
     }
     /** Set the highlighted option index (typically driven by hover). */
     setActiveDropdownIndex(index) {
+        if (this.isDestroyed)
+            return;
         this.core.setActiveDropdownIndex(index);
     }
     // === Lifecycle ===
@@ -162,6 +223,8 @@ export class AIAutocompleteController {
      * (e.g. `text$` instead of `onChange`).
      */
     update(opts) {
+        if (this.isDestroyed)
+            return;
         this.core.update(opts);
     }
     /**
@@ -179,6 +242,24 @@ export class AIAutocompleteController {
     }
 }
 // ===== Pure helpers — not part of the public surface =====
+/**
+ * Shallow array equality. The vanilla store reassigns array fields on every
+ * write (`store.set({ completedParams: [...prev, x] })`), so reference
+ * equality alone would re-emit downstream even when the contents are
+ * identical. Used for `completedParams$`, `suggestions$`, `suggestionPills$`,
+ * and `segments$`.
+ */
+function arrEq(a, b) {
+    if (a === b)
+        return true;
+    if (a.length !== b.length)
+        return false;
+    for (let i = 0; i < a.length; i++) {
+        if (a[i] !== b[i])
+            return false;
+    }
+    return true;
+}
 function computeUiLoading(s) {
     return s.isLoading && !s.editingParam && !s.inSelectionAnimation;
 }
@@ -223,4 +304,4 @@ function computeDropdown(s) {
         isLoading: computeUiLoading(s),
     };
 }
-//# 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 CompletedParamState,\n  AIAutocomplete as CoreAIAutocomplete,\n  type CoreState,\n  type Segment,\n  type Suggestion,\n  type SuggestionOption,\n} from \"@magicx-eng/ai-autocomplete-vanilla\";\nimport { BehaviorSubject, 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 * Per TDB §3.3, 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  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  /** 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  /** Currently highlighted dropdown option index. -1 = none. */\n  readonly activeIndex$: Observable<number>;\n  /**\n   * UI-visible loading flag — suppressed during the post-select streak\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  /** 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` — see TDB §16.3.\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    this.unsubscribeCore = this.core.subscribe((state) => {\n      if (!this.isDestroyed) this.rawState$.next(state);\n    });\n\n    // === Per-field observables ===\n    this.text$ = deriveField(this.rawState$, (s) => s.text);\n    this.completedParams$ = deriveField(this.rawState$, (s) => s.completedParams);\n    this.suggestionPills$ = deriveField(this.rawState$, (s) => s.actionableSuggestions);\n    this.segments$ = deriveField(this.rawState$, (s) => s.segments);\n    this.newParamId$ = deriveField(this.rawState$, (s) => s.newParamId);\n    this.suggestions$ = deriveField(this.rawState$, (s) => s.suggestions);\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.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.dropdown$ = deriveField(this.rawState$, computeDropdown);\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  // === Action methods (pass-through to the core) ===\n\n  /** Clear all state, rotate `session_id`, and re-fetch. Call after submit. */\n  reset(): void {\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    this.core.selectOption(option);\n  }\n\n  /** Promote the pill at `index` to active (front of the list). */\n  setActivePill(index: number): void {\n    this.core.setActivePill(index);\n  }\n\n  /** Drop the last completed param's \"completed\" status. Text stays as plain text. */\n  removeLastParam(): void {\n    this.core.removeLastParam();\n  }\n\n  /** Clear the shimmer animation state for the most-recently-added param. */\n  clearNewParamId(): void {\n    this.core.clearNewParamId();\n  }\n\n  /** Controlled-mode setter for editor text. */\n  setValue(text: string): void {\n    this.core.setValue(text);\n  }\n\n  /** Controlled-mode setter for completed params. */\n  setCompletedParams(params: CompletedParamState[]): void {\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    this.core.handleTextChange(value);\n  }\n\n  /** Forward keyboard events from the consumer's `<textarea>` to the core. */\n  handleKeyDown(event: KeyboardEvent): void {\n    this.core.handleKeyDown(event);\n  }\n\n  /** Notify the core of focus state. */\n  setFocused(focused: boolean): void {\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    this.core.startEditingParam(paramId);\n  }\n\n  /** Exit re-edit mode without changing the bold param. */\n  exitEditMode(): void {\n    this.core.exitEditMode();\n  }\n\n  /** Forward post-input caret position (extends the edit tail). */\n  handleCaretAfterInput(offset: number | null): void {\n    this.core.handleCaretAfterInput(offset);\n  }\n\n  /** Forward selection-only caret moves (may exit re-edit). */\n  handleCaretMove(offset: number | null): void {\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    return this.core.replaceEditingRange(replacement);\n  }\n\n  /** Set the highlighted option index (typically driven by hover). */\n  setActiveDropdownIndex(index: number): void {\n    this.core.setActiveDropdownIndex(index);\n  }\n\n  // === Lifecycle ===\n\n  /**\n   * Apply runtime changes to a subset of options. Event callbacks\n   * (`onSubmit`, `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    this.core.update(opts);\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\nfunction computeUiLoading(s: CoreState): boolean {\n  return s.isLoading && !s.editingParam && !s.inSelectionAnimation;\n}\n\nfunction computeState(s: CoreState): AIAutocompleteControllerState {\n  return {\n    text: s.text,\n    completedParams: s.completedParams,\n    suggestionPills: s.actionableSuggestions,\n    segments: s.segments,\n    newParamId: s.newParamId,\n    suggestions: s.suggestions,\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    editingAnchor: s.editingAnchor,\n    caretOffset: s.caretOffset,\n  };\n}\n\nfunction computeDropdown(s: CoreState): AIAutocompleteDropdownState {\n  const editingParam = s.editingParam;\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    : null;\n  const dropdownActivePill = dropdownPill ?? activeSuggestion;\n  const dropdownPills = dropdownPill ? [dropdownPill] : s.actionableSuggestions;\n  return {\n    suggestions: dropdownActivePill ? [{ ...dropdownActivePill, options: s.filteredOptions }] : [],\n    activeIndex: s.activeDropdownIndex,\n    isOpen: s.isDropdownOpen,\n    pills: dropdownPills,\n    isLoading: computeUiLoading(s),\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 CompletedParamState,\n  AIAutocomplete as CoreAIAutocomplete,\n  type CoreState,\n  type Segment,\n  type Suggestion,\n  type SuggestionOption,\n} from \"@magicx-eng/ai-autocomplete-vanilla\";\nimport { BehaviorSubject, 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 * Per TDB §3.3, 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  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  /** 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  /** Currently highlighted dropdown option index. -1 = none. */\n  readonly activeIndex$: Observable<number>;\n  /**\n   * UI-visible loading flag — suppressed during the post-select streak\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  /** 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` — see TDB §16.3.\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). Reentrancy makes the outer set's listener loop continue with a\n    // now-stale snapshot, so the listener can fire *out of order* — delivering\n    // an older state (still in re-edit) after a newer one (re-edit exited).\n    // Reading `getState()` at emission time collapses every notification onto\n    // the true latest state, so a stale `editingParam` can't resurrect and\n    // retrigger the editor's re-edit caret-park (which would yank the caret\n    // back to where re-editing started). distinctUntilChanged downstream drops\n    // the resulting duplicate emissions. React avoids this because it batches\n    // renders and its caret effects are dependency-gated; our subscription is\n    // synchronous, so we coalesce here instead.\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.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.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.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.dropdown$ = deriveField(this.rawState$, computeDropdown);\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  // === 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  /** 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  /** 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  // === Lifecycle ===\n\n  /**\n   * Apply runtime changes to a subset of options. Event callbacks\n   * (`onSubmit`, `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  }\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\nfunction computeUiLoading(s: CoreState): boolean {\n  return s.isLoading && !s.editingParam && !s.inSelectionAnimation;\n}\n\nfunction computeState(s: CoreState): AIAutocompleteControllerState {\n  return {\n    text: s.text,\n    completedParams: s.completedParams,\n    suggestionPills: s.actionableSuggestions,\n    segments: s.segments,\n    newParamId: s.newParamId,\n    suggestions: s.suggestions,\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    editingAnchor: s.editingAnchor,\n    caretOffset: s.caretOffset,\n  };\n}\n\nfunction computeDropdown(s: CoreState): AIAutocompleteDropdownState {\n  const editingParam = s.editingParam;\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    : null;\n  const dropdownActivePill = dropdownPill ?? activeSuggestion;\n  const dropdownPills = dropdownPill ? [dropdownPill] : s.actionableSuggestions;\n  return {\n    suggestions: dropdownActivePill ? [{ ...dropdownActivePill, options: s.filteredOptions }] : [],\n    activeIndex: s.activeDropdownIndex,\n    isOpen: s.isDropdownOpen,\n    pills: dropdownPills,\n    isLoading: computeUiLoading(s),\n  };\n}\n"]}

package/esm2020/lib/input/ai-autocomplete-input.directive.mjs

@@ -34,11 +34,23 @@ export class AIAutocompleteInputDirective {
         this.destroy$ = new Subject();
         this.onChangeFn = noop;
         this.onTouchedFn = noop;
+        // Timestamp of the last `input` event. A `keyup`/`select` that fires within
+        // this window is the tail of a keystroke, not a deliberate caret move, so we
+        // skip the caret-move handler there (mirrors the editor host's selectionchange
+        // guard). performance.now() is monotonic; 0 means "no input yet".
+        this.lastInputAt = 0;
+        // Tracks the most-recently-promoted param so we only reposition the caret
+        // once per option selection (mirrors the editor host's post-promote refocus).
+        this.lastSeenParamId = "";
     }
     ngOnInit() {
         if (!this.controller) {
             throw new Error('[aiaInput] requires a controller — use `[aiaInput]="myController"`.');
         }
+        if (this.pendingWriteValue !== undefined) {
+            this.controller.setValue(this.pendingWriteValue);
+            this.pendingWriteValue = undefined;
+        }
         const el = this.el.nativeElement;
         this.renderer.setAttribute(el, "aria-controls", this.controller.listboxId);
         // Sync editor text → DOM. Skips the write when values already match, so
@@ -74,6 +86,35 @@ export class AIAutocompleteInputDirective {
                 this.renderer.removeAttribute(el, "aria-activedescendant");
             }
         });
+        // After an option selection promotes a param, the core appends its text and
+        // stamps `caretOffset` at the end of the inserted text. The text$ subscriber
+        // above writes the new value but *restores the pre-write caret* (correct for
+        // typing echoes, wrong here), so we move the caret to the promoted position.
+        // Keyed on newParamId so it fires once per selection, not on every tick.
+        // Registered after text$ so the new value is in the DOM before we seek.
+        this.controller.newParamId$.pipe(takeUntil(this.destroy$)).subscribe((id) => {
+            const current = id ?? "";
+            if (current && current !== this.lastSeenParamId) {
+                this.lastSeenParamId = current;
+                const offset = this.controller.getState().caretOffset ?? el.value.length;
+                const clamped = Math.min(Math.max(offset, 0), el.value.length);
+                // Only grab focus if we don't already have it — don't yank focus back
+                // from wherever the user moved it after selecting (e.g. a host-app
+                // button). setSelectionRange still positions the caret regardless.
+                if (typeof document !== "undefined" && document.activeElement !== el) {
+                    el.focus();
+                }
+                try {
+                    el.setSelectionRange(clamped, clamped);
+                }
+                catch {
+                    // Some input types (e.g. "number") don't support setSelectionRange.
+                }
+            }
+            else if (!current) {
+                this.lastSeenParamId = "";
+            }
+        });
     }
     ngOnDestroy() {
         this.destroy$.next();
@@ -87,6 +128,11 @@ export class AIAutocompleteInputDirective {
      * we don't disrupt multi-keystroke input methods (Pinyin, Hangul, etc.).
      */
     onInput(event) {
+        // Stamp the input time before anything else. The autocapitalize path below
+        // calls setSelectionRange, which can synchronously fire a `select` event →
+        // onCaretMove; stamping first ensures that event falls inside the guard
+        // window and is treated as part of this keystroke, not a caret move.
+        this.lastInputAt = performance.now();
         const target = event.target;
         const raw = target.value;
         const isComposing = event.isComposing === true;
@@ -107,11 +153,36 @@ export class AIAutocompleteInputDirective {
             }
         }
         this.controller.handleTextChange(next);
+        // Sync the real caret into the core. The dropdown's auto-trigger gate only
+        // opens when the caret is at the end of the text; without this, the core's
+        // `caretOffset` stays pinned at whatever a prior promote/select set it to
+        // and goes stale as the user keeps typing, wedging the dropdown closed.
+        // selectionStart is null on some input types (number/email/color); treat
+        // that as "caret at end" rather than feeding null into the core.
+        this.controller.handleCaretAfterInput(target.selectionStart ?? target.value.length);
         this.onChangeFn(next);
     }
     onKeyDown(event) {
         this.controller.handleKeyDown(event);
     }
+    /**
+     * Caret moved by something other than typing — arrow keys, Home/End, or a
+     * mouse click/drag (keyup + mouseup). Forward the new offset so the core can
+     * re-evaluate the caret-at-end dropdown gate (and exit re-edit if the caret
+     * left the region). We deliberately do NOT listen for the `select` event:
+     * programmatic `setSelectionRange` calls (the text$ writeback, the post-select
+     * caret reposition) fire it in jsdom/some browsers, which would re-enter here
+     * and clobber `caretOffset`. `keyup`/`mouseup` only fire for real user input.
+     * Skipped right after an `input` event, where the caret is already handled by
+     * `handleCaretAfterInput` above.
+     */
+    onCaretMove() {
+        if (performance.now() - this.lastInputAt < 50)
+            return;
+        const el = this.el.nativeElement;
+        // selectionStart is null on some input types — treat as caret at end.
+        this.controller.handleCaretMove(el.selectionStart ?? el.value.length);
+    }
     onFocus() {
         this.controller.setFocused(true);
     }
@@ -123,11 +194,17 @@ export class AIAutocompleteInputDirective {
     writeValue(value) {
         const next = value ?? "";
         this.renderer.setProperty(this.el.nativeElement, "value", next);
-        // The controller may be undefined transiently if Angular calls
-        // writeValue() before ngOnInit (rare but possible during dynamic form
-        // construction). Guard so we don't throw in that window.
-        if (this.controller)
+        // If Angular calls writeValue() before ngOnInit (possible during dynamic
+        // form construction), queue the value and let ngOnInit flush it. We
+        // can't push it into the controller now because either the controller
+        // binding hasn't resolved yet, or text$'s initial subscription would
+        // overwrite it moments later.
+        if (this.controller) {
             this.controller.setValue(next);
+        }
+        else {
+            this.pendingWriteValue = next;
+        }
     }
     registerOnChange(fn) {
         this.onChangeFn = fn;
@@ -140,7 +217,7 @@ export class AIAutocompleteInputDirective {
     }
 }
 AIAutocompleteInputDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: AIAutocompleteInputDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
-AIAutocompleteInputDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.10", type: AIAutocompleteInputDirective, isStandalone: true, selector: "[aiaInput]", inputs: { controller: ["aiaInput", "controller"] }, host: { attributes: { "role": "combobox", "aria-autocomplete": "list" }, listeners: { "input": "onInput($event)", "keydown": "onKeyDown($event)", "focus": "onFocus()", "blur": "onBlur()" } }, providers: [
+AIAutocompleteInputDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.10", type: AIAutocompleteInputDirective, isStandalone: true, selector: "[aiaInput]", inputs: { controller: ["aiaInput", "controller"] }, host: { attributes: { "role": "combobox", "aria-autocomplete": "list" }, listeners: { "input": "onInput($event)", "keydown": "onKeyDown($event)", "keyup": "onCaretMove()", "mouseup": "onCaretMove()", "focus": "onFocus()", "blur": "onBlur()" } }, providers: [
         {
             provide: NG_VALUE_ACCESSOR,
             // eslint-disable-next-line @typescript-eslint/no-use-before-define
@@ -158,6 +235,8 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImpo
                         "aria-autocomplete": "list",
                         "(input)": "onInput($event)",
                         "(keydown)": "onKeyDown($event)",
+                        "(keyup)": "onCaretMove()",
+                        "(mouseup)": "onCaretMove()",
                         "(focus)": "onFocus()",
                         "(blur)": "onBlur()",
                     },
@@ -177,4 +256,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImpo
 function noop() {
     // Default no-op callback for CVA — overwritten by Angular's form bridge.
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ai-autocomplete-input.directive.js","sourceRoot":"","sources":["../../../../src/lib/input/ai-autocomplete-input.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Directive,\n  ElementRef,\n  forwardRef,\n  Input,\n  inject,\n  type OnDestroy,\n  type OnInit,\n  Renderer2,\n} from \"@angular/core\";\nimport { type ControlValueAccessor, NG_VALUE_ACCESSOR } from \"@angular/forms\";\nimport { Subject, takeUntil } from \"rxjs\";\nimport type { AIAutocompleteController } from \"../controller/ai-autocomplete.controller\";\n\n/**\n * Tier 2 input binder. Attach to a `<textarea>` or `<input>` and pass an\n * {@link AIAutocompleteController}:\n *\n * ```html\n * <textarea [aiaInput]=\"ac\"></textarea>\n * ```\n *\n * The directive wires the input's events (input/keydown/focus/blur) to the\n * controller, mirrors controller state into ARIA attributes\n * (`role=\"combobox\"`, `aria-expanded`, `aria-activedescendant`,\n * `aria-autocomplete`, `aria-controls`), and implements\n * {@link ControlValueAccessor} so the host element participates in Reactive\n * Forms out of the box:\n *\n * ```html\n * <textarea [aiaInput]=\"ac\" [formControl]=\"myControl\"></textarea>\n * ```\n *\n * Per the React hook's behavior, the first typed character is auto-capitalized\n * — typing \"h\" becomes \"H\" before being forwarded to the controller. The\n * cursor position is preserved across that rewrite.\n *\n * @public\n */\n@Directive({\n  selector: \"[aiaInput]\",\n  standalone: true,\n  host: {\n    role: \"combobox\",\n    \"aria-autocomplete\": \"list\",\n    \"(input)\": \"onInput($event)\",\n    \"(keydown)\": \"onKeyDown($event)\",\n    \"(focus)\": \"onFocus()\",\n    \"(blur)\": \"onBlur()\",\n  },\n  providers: [\n    {\n      provide: NG_VALUE_ACCESSOR,\n      // eslint-disable-next-line @typescript-eslint/no-use-before-define\n      useExisting: forwardRef(() => AIAutocompleteInputDirective),\n      multi: true,\n    },\n  ],\n})\nexport class AIAutocompleteInputDirective implements OnInit, OnDestroy, ControlValueAccessor {\n  /**\n   * The {@link AIAutocompleteController} that owns the autocomplete state.\n   * Required. The directive throws on init if this is missing.\n   */\n  @Input(\"aiaInput\") controller!: AIAutocompleteController;\n\n  private readonly el = inject<ElementRef<HTMLInputElement | HTMLTextAreaElement>>(ElementRef);\n  private readonly renderer = inject(Renderer2);\n  private readonly destroy$ = new Subject<void>();\n\n  private onChangeFn: (value: string) => void = noop;\n  private onTouchedFn: () => void = noop;\n\n  ngOnInit(): void {\n    if (!this.controller) {\n      throw new Error('[aiaInput] requires a controller — use `[aiaInput]=\"myController\"`.');\n    }\n\n    const el = this.el.nativeElement;\n    this.renderer.setAttribute(el, \"aria-controls\", this.controller.listboxId);\n\n    // Sync editor text → DOM. Skips the write when values already match, so\n    // user keystrokes don't fight with our writeback. Preserves the caret\n    // position when we do write (and the element still has focus).\n    this.controller.text$.pipe(takeUntil(this.destroy$)).subscribe((text) => {\n      if (el.value === text) return;\n      const wasFocused = typeof document !== \"undefined\" && document.activeElement === el;\n      const start = el.selectionStart;\n      const end = el.selectionEnd;\n      this.renderer.setProperty(el, \"value\", text);\n      if (wasFocused && start != null && end != null) {\n        const clampedStart = Math.min(start, text.length);\n        const clampedEnd = Math.min(end, text.length);\n        try {\n          el.setSelectionRange(clampedStart, clampedEnd);\n        } catch {\n          // `setSelectionRange` throws on some input types (e.g. \"number\");\n          // safe to ignore — those inputs don't have a meaningful selection.\n        }\n      }\n    });\n\n    this.controller.isDropdownOpen$.pipe(takeUntil(this.destroy$)).subscribe((isOpen) => {\n      this.renderer.setAttribute(el, \"aria-expanded\", String(isOpen));\n    });\n\n    this.controller.activeIndex$.pipe(takeUntil(this.destroy$)).subscribe((idx) => {\n      if (idx >= 0) {\n        this.renderer.setAttribute(\n          el,\n          \"aria-activedescendant\",\n          `${this.controller.listboxId}-option-${idx}`,\n        );\n      } else {\n        this.renderer.removeAttribute(el, \"aria-activedescendant\");\n      }\n    });\n  }\n\n  ngOnDestroy(): void {\n    this.destroy$.next();\n    this.destroy$.complete();\n  }\n\n  // === Event handlers (wired via host metadata above) ===\n\n  /**\n   * Auto-capitalizes the first character on the user's first keystroke so the\n   * server receives \"Create\" instead of \"create\". Matches React's\n   * `handleChange` in `useAIAutocomplete`. Skipped during IME composition so\n   * we don't disrupt multi-keystroke input methods (Pinyin, Hangul, etc.).\n   */\n  onInput(event: Event): void {\n    const target = event.target as HTMLInputElement | HTMLTextAreaElement;\n    const raw = target.value;\n    const isComposing = (event as InputEvent).isComposing === true;\n    const shouldCapitalize = raw.length > 0 && !isComposing && raw[0] !== raw[0].toUpperCase();\n\n    let next = raw;\n    if (shouldCapitalize) {\n      const start = target.selectionStart;\n      const end = target.selectionEnd;\n      next = raw[0].toUpperCase() + raw.slice(1);\n      this.renderer.setProperty(target, \"value\", next);\n      if (start != null && end != null) {\n        try {\n          target.setSelectionRange(start, end);\n        } catch {\n          // See note in ngOnInit's text$ subscriber.\n        }\n      }\n    }\n\n    this.controller.handleTextChange(next);\n    this.onChangeFn(next);\n  }\n\n  onKeyDown(event: KeyboardEvent): void {\n    this.controller.handleKeyDown(event);\n  }\n\n  onFocus(): void {\n    this.controller.setFocused(true);\n  }\n\n  onBlur(): void {\n    this.controller.setFocused(false);\n    this.onTouchedFn();\n  }\n\n  // === ControlValueAccessor ===\n\n  writeValue(value: string | null): void {\n    const next = value ?? \"\";\n    this.renderer.setProperty(this.el.nativeElement, \"value\", next);\n    // The controller may be undefined transiently if Angular calls\n    // writeValue() before ngOnInit (rare but possible during dynamic form\n    // construction). Guard so we don't throw in that window.\n    if (this.controller) this.controller.setValue(next);\n  }\n\n  registerOnChange(fn: (value: string) => void): void {\n    this.onChangeFn = fn;\n  }\n\n  registerOnTouched(fn: () => void): void {\n    this.onTouchedFn = fn;\n  }\n\n  setDisabledState(disabled: boolean): void {\n    this.renderer.setProperty(this.el.nativeElement, \"disabled\", disabled);\n  }\n}\n\nfunction noop(): void {\n  // Default no-op callback for CVA — overwritten by Angular's form bridge.\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ai-autocomplete-input.directive.js","sourceRoot":"","sources":["../../../../src/lib/input/ai-autocomplete-input.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Directive,\n  ElementRef,\n  forwardRef,\n  Input,\n  inject,\n  type OnDestroy,\n  type OnInit,\n  Renderer2,\n} from \"@angular/core\";\nimport { type ControlValueAccessor, NG_VALUE_ACCESSOR } from \"@angular/forms\";\nimport { Subject, takeUntil } from \"rxjs\";\nimport type { AIAutocompleteController } from \"../controller/ai-autocomplete.controller\";\n\n/**\n * Tier 2 input binder. Attach to a `<textarea>` or `<input>` and pass an\n * {@link AIAutocompleteController}:\n *\n * ```html\n * <textarea [aiaInput]=\"ac\"></textarea>\n * ```\n *\n * The directive wires the input's events (input/keydown/focus/blur) to the\n * controller, mirrors controller state into ARIA attributes\n * (`role=\"combobox\"`, `aria-expanded`, `aria-activedescendant`,\n * `aria-autocomplete`, `aria-controls`), and implements\n * {@link ControlValueAccessor} so the host element participates in Reactive\n * Forms out of the box:\n *\n * ```html\n * <textarea [aiaInput]=\"ac\" [formControl]=\"myControl\"></textarea>\n * ```\n *\n * Per the React hook's behavior, the first typed character is auto-capitalized\n * — typing \"h\" becomes \"H\" before being forwarded to the controller. The\n * cursor position is preserved across that rewrite.\n *\n * @public\n */\n@Directive({\n  selector: \"[aiaInput]\",\n  standalone: true,\n  host: {\n    role: \"combobox\",\n    \"aria-autocomplete\": \"list\",\n    \"(input)\": \"onInput($event)\",\n    \"(keydown)\": \"onKeyDown($event)\",\n    \"(keyup)\": \"onCaretMove()\",\n    \"(mouseup)\": \"onCaretMove()\",\n    \"(focus)\": \"onFocus()\",\n    \"(blur)\": \"onBlur()\",\n  },\n  providers: [\n    {\n      provide: NG_VALUE_ACCESSOR,\n      // eslint-disable-next-line @typescript-eslint/no-use-before-define\n      useExisting: forwardRef(() => AIAutocompleteInputDirective),\n      multi: true,\n    },\n  ],\n})\nexport class AIAutocompleteInputDirective implements OnInit, OnDestroy, ControlValueAccessor {\n  /**\n   * The {@link AIAutocompleteController} that owns the autocomplete state.\n   * Required. The directive throws on init if this is missing.\n   */\n  @Input(\"aiaInput\") controller!: AIAutocompleteController;\n\n  private readonly el = inject<ElementRef<HTMLInputElement | HTMLTextAreaElement>>(ElementRef);\n  private readonly renderer = inject(Renderer2);\n  private readonly destroy$ = new Subject<void>();\n\n  private onChangeFn: (value: string) => void = noop;\n  private onTouchedFn: () => void = noop;\n  // Timestamp of the last `input` event. A `keyup`/`select` that fires within\n  // this window is the tail of a keystroke, not a deliberate caret move, so we\n  // skip the caret-move handler there (mirrors the editor host's selectionchange\n  // guard). performance.now() is monotonic; 0 means \"no input yet\".\n  private lastInputAt = 0;\n  // Tracks the most-recently-promoted param so we only reposition the caret\n  // once per option selection (mirrors the editor host's post-promote refocus).\n  private lastSeenParamId = \"\";\n  // Holds a value written by Reactive Forms before ngOnInit ran. Reactive\n  // Forms can call writeValue() during dynamic form construction (e.g. when\n  // a control is patched at the moment the directive is created), and our\n  // controller binding may not be initialized yet. We stash the value here\n  // and flush it into the controller in ngOnInit *before* subscribing to\n  // text$, otherwise text$'s initial \"\" emission would clobber the form\n  // value the textarea already shows. `undefined` means \"no pending write\".\n  private pendingWriteValue: string | undefined;\n\n  ngOnInit(): void {\n    if (!this.controller) {\n      throw new Error('[aiaInput] requires a controller — use `[aiaInput]=\"myController\"`.');\n    }\n\n    if (this.pendingWriteValue !== undefined) {\n      this.controller.setValue(this.pendingWriteValue);\n      this.pendingWriteValue = undefined;\n    }\n\n    const el = this.el.nativeElement;\n    this.renderer.setAttribute(el, \"aria-controls\", this.controller.listboxId);\n\n    // Sync editor text → DOM. Skips the write when values already match, so\n    // user keystrokes don't fight with our writeback. Preserves the caret\n    // position when we do write (and the element still has focus).\n    this.controller.text$.pipe(takeUntil(this.destroy$)).subscribe((text) => {\n      if (el.value === text) return;\n      const wasFocused = typeof document !== \"undefined\" && document.activeElement === el;\n      const start = el.selectionStart;\n      const end = el.selectionEnd;\n      this.renderer.setProperty(el, \"value\", text);\n      if (wasFocused && start != null && end != null) {\n        const clampedStart = Math.min(start, text.length);\n        const clampedEnd = Math.min(end, text.length);\n        try {\n          el.setSelectionRange(clampedStart, clampedEnd);\n        } catch {\n          // `setSelectionRange` throws on some input types (e.g. \"number\");\n          // safe to ignore — those inputs don't have a meaningful selection.\n        }\n      }\n    });\n\n    this.controller.isDropdownOpen$.pipe(takeUntil(this.destroy$)).subscribe((isOpen) => {\n      this.renderer.setAttribute(el, \"aria-expanded\", String(isOpen));\n    });\n\n    this.controller.activeIndex$.pipe(takeUntil(this.destroy$)).subscribe((idx) => {\n      if (idx >= 0) {\n        this.renderer.setAttribute(\n          el,\n          \"aria-activedescendant\",\n          `${this.controller.listboxId}-option-${idx}`,\n        );\n      } else {\n        this.renderer.removeAttribute(el, \"aria-activedescendant\");\n      }\n    });\n\n    // After an option selection promotes a param, the core appends its text and\n    // stamps `caretOffset` at the end of the inserted text. The text$ subscriber\n    // above writes the new value but *restores the pre-write caret* (correct for\n    // typing echoes, wrong here), so we move the caret to the promoted position.\n    // Keyed on newParamId so it fires once per selection, not on every tick.\n    // Registered after text$ so the new value is in the DOM before we seek.\n    this.controller.newParamId$.pipe(takeUntil(this.destroy$)).subscribe((id) => {\n      const current = id ?? \"\";\n      if (current && current !== this.lastSeenParamId) {\n        this.lastSeenParamId = current;\n        const offset = this.controller.getState().caretOffset ?? el.value.length;\n        const clamped = Math.min(Math.max(offset, 0), el.value.length);\n        // Only grab focus if we don't already have it — don't yank focus back\n        // from wherever the user moved it after selecting (e.g. a host-app\n        // button). setSelectionRange still positions the caret regardless.\n        if (typeof document !== \"undefined\" && document.activeElement !== el) {\n          el.focus();\n        }\n        try {\n          el.setSelectionRange(clamped, clamped);\n        } catch {\n          // Some input types (e.g. \"number\") don't support setSelectionRange.\n        }\n      } else if (!current) {\n        this.lastSeenParamId = \"\";\n      }\n    });\n  }\n\n  ngOnDestroy(): void {\n    this.destroy$.next();\n    this.destroy$.complete();\n  }\n\n  // === Event handlers (wired via host metadata above) ===\n\n  /**\n   * Auto-capitalizes the first character on the user's first keystroke so the\n   * server receives \"Create\" instead of \"create\". Matches React's\n   * `handleChange` in `useAIAutocomplete`. Skipped during IME composition so\n   * we don't disrupt multi-keystroke input methods (Pinyin, Hangul, etc.).\n   */\n  onInput(event: Event): void {\n    // Stamp the input time before anything else. The autocapitalize path below\n    // calls setSelectionRange, which can synchronously fire a `select` event →\n    // onCaretMove; stamping first ensures that event falls inside the guard\n    // window and is treated as part of this keystroke, not a caret move.\n    this.lastInputAt = performance.now();\n    const target = event.target as HTMLInputElement | HTMLTextAreaElement;\n    const raw = target.value;\n    const isComposing = (event as InputEvent).isComposing === true;\n    const shouldCapitalize = raw.length > 0 && !isComposing && raw[0] !== raw[0].toUpperCase();\n\n    let next = raw;\n    if (shouldCapitalize) {\n      const start = target.selectionStart;\n      const end = target.selectionEnd;\n      next = raw[0].toUpperCase() + raw.slice(1);\n      this.renderer.setProperty(target, \"value\", next);\n      if (start != null && end != null) {\n        try {\n          target.setSelectionRange(start, end);\n        } catch {\n          // See note in ngOnInit's text$ subscriber.\n        }\n      }\n    }\n\n    this.controller.handleTextChange(next);\n    // Sync the real caret into the core. The dropdown's auto-trigger gate only\n    // opens when the caret is at the end of the text; without this, the core's\n    // `caretOffset` stays pinned at whatever a prior promote/select set it to\n    // and goes stale as the user keeps typing, wedging the dropdown closed.\n    // selectionStart is null on some input types (number/email/color); treat\n    // that as \"caret at end\" rather than feeding null into the core.\n    this.controller.handleCaretAfterInput(target.selectionStart ?? target.value.length);\n    this.onChangeFn(next);\n  }\n\n  onKeyDown(event: KeyboardEvent): void {\n    this.controller.handleKeyDown(event);\n  }\n\n  /**\n   * Caret moved by something other than typing — arrow keys, Home/End, or a\n   * mouse click/drag (keyup + mouseup). Forward the new offset so the core can\n   * re-evaluate the caret-at-end dropdown gate (and exit re-edit if the caret\n   * left the region). We deliberately do NOT listen for the `select` event:\n   * programmatic `setSelectionRange` calls (the text$ writeback, the post-select\n   * caret reposition) fire it in jsdom/some browsers, which would re-enter here\n   * and clobber `caretOffset`. `keyup`/`mouseup` only fire for real user input.\n   * Skipped right after an `input` event, where the caret is already handled by\n   * `handleCaretAfterInput` above.\n   */\n  onCaretMove(): void {\n    if (performance.now() - this.lastInputAt < 50) return;\n    const el = this.el.nativeElement;\n    // selectionStart is null on some input types — treat as caret at end.\n    this.controller.handleCaretMove(el.selectionStart ?? el.value.length);\n  }\n\n  onFocus(): void {\n    this.controller.setFocused(true);\n  }\n\n  onBlur(): void {\n    this.controller.setFocused(false);\n    this.onTouchedFn();\n  }\n\n  // === ControlValueAccessor ===\n\n  writeValue(value: string | null): void {\n    const next = value ?? \"\";\n    this.renderer.setProperty(this.el.nativeElement, \"value\", next);\n    // If Angular calls writeValue() before ngOnInit (possible during dynamic\n    // form construction), queue the value and let ngOnInit flush it. We\n    // can't push it into the controller now because either the controller\n    // binding hasn't resolved yet, or text$'s initial subscription would\n    // overwrite it moments later.\n    if (this.controller) {\n      this.controller.setValue(next);\n    } else {\n      this.pendingWriteValue = next;\n    }\n  }\n\n  registerOnChange(fn: (value: string) => void): void {\n    this.onChangeFn = fn;\n  }\n\n  registerOnTouched(fn: () => void): void {\n    this.onTouchedFn = fn;\n  }\n\n  setDisabledState(disabled: boolean): void {\n    this.renderer.setProperty(this.el.nativeElement, \"disabled\", disabled);\n  }\n}\n\nfunction noop(): void {\n  // Default no-op callback for CVA — overwritten by Angular's form bridge.\n}\n"]}