@magicx-eng/ai-autocomplete-angular 0.1.0

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

@@ -0,0 +1,226 @@
+import { AIAutocomplete as CoreAIAutocomplete, } from "@magicx-eng/ai-autocomplete-vanilla";
+import { BehaviorSubject, map, shareReplay } from "rxjs";
+import { deriveField } from "./observables";
+/**
+ * Tier 2 logic surface for `@magicx-eng/ai-autocomplete-angular` — the Angular
+ * equivalent of React's `useAIAutocomplete()` hook. Wraps a headless
+ * `@magicx-eng/ai-autocomplete-vanilla` core and exposes its state as RxJS
+ * observables plus thin action methods.
+ *
+ * Per TDB §3.3, the controller is consumer-managed — the consumer creates it
+ * with `new`, holds the reference, and **must call `destroy()`** in their
+ * own `ngOnDestroy`. The Tier 1 `<ai-autocomplete>` component does this
+ * automatically; Tier 2 consumers do not get auto-cleanup.
+ *
+ * @public
+ */
+export class AIAutocompleteController {
+    /**
+     * Throws if invoked outside a browser environment. For SSR / Angular
+     * Universal, gate construction with `isPlatformBrowser` — see TDB §16.3.
+     */
+    constructor(opts = {}) {
+        this.isDestroyed = false;
+        if (typeof document === "undefined") {
+            throw new Error("AIAutocompleteController requires a browser environment. " +
+                "For SSR / Angular Universal, gate construction with isPlatformBrowser.");
+        }
+        // Headless mode never renders to the host, so a throwaway div is fine —
+        // it's required by the core's signature for symmetry with full mode.
+        const host = document.createElement("div");
+        this.core = new CoreAIAutocomplete(host, {
+            ...opts,
+            renderMode: "headless",
+            source: opts.source ?? "headless-sdk",
+            // Headless mode never renders the dropdown DOM, but the keyboard
+            // controller still reads `optionsPosition` to decide which vertical
+            // arrow opens the dropdown from the input.
+            optionsPosition: opts.optionsPosition ?? "below",
+        });
+        this.rawState$ = new BehaviorSubject(this.core.getState());
+        this.unsubscribeCore = this.core.subscribe((state) => {
+            if (!this.isDestroyed)
+                this.rawState$.next(state);
+        });
+        // === Per-field observables ===
+        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.newParamId$ = deriveField(this.rawState$, (s) => s.newParamId);
+        this.suggestions$ = deriveField(this.rawState$, (s) => s.suggestions);
+        this.activeIndex$ = deriveField(this.rawState$, (s) => s.activeDropdownIndex);
+        this.isLoading$ = deriveField(this.rawState$, computeUiLoading);
+        this.isReady$ = deriveField(this.rawState$, (s) => s.isReady);
+        this.isFocused$ = deriveField(this.rawState$, (s) => s.isFocused);
+        this.isDropdownOpen$ = deriveField(this.rawState$, (s) => s.isDropdownOpen);
+        this.placeholderText$ = deriveField(this.rawState$, (s) => s.placeholderText);
+        this.error$ = deriveField(this.rawState$, (s) => s.error);
+        this.editingParam$ = deriveField(this.rawState$, (s) => s.editingParam);
+        this.editingAnchor$ = deriveField(this.rawState$, (s) => s.editingAnchor);
+        this.caretOffset$ = deriveField(this.rawState$, (s) => s.caretOffset);
+        // === Composite observables ===
+        // Project directly off `rawState$` with a single map() so each store
+        // tick produces exactly ONE coherent state$ emission. Using
+        // `combineLatest` over the per-field observables here would fire one
+        // emission per inner-source tick (up to N per store update), and the
+        // editor-host directive's post-promote refocus would run against an
+        // intermediate state where `newParamId` was set but `segments` /
+        // `caretOffset` still held their old values — leaving the caret stuck
+        // at the pre-click position.
+        this.state$ = this.rawState$.pipe(map(computeState), shareReplay({ bufferSize: 1, refCount: true }));
+        this.dropdown$ = deriveField(this.rawState$, computeDropdown);
+    }
+    // === Read-only accessors ===
+    /** Stable ARIA listbox ID for the dropdown. Pass to `<textarea aria-controls="...">`. */
+    get listboxId() {
+        return this.core.listboxId;
+    }
+    /** Whether `destroy()` has been called. After destruction all action methods no-op. */
+    get destroyed() {
+        return this.isDestroyed;
+    }
+    /**
+     * Synchronous snapshot of the controller's current public state. Mirrors
+     * the latest emission of `state$`. Useful in callbacks where you can't
+     * `subscribe` (e.g. inside an event handler).
+     */
+    getState() {
+        return computeState(this.rawState$.value);
+    }
+    // === Action methods (pass-through to the core) ===
+    /** Clear all state, rotate `session_id`, and re-fetch. Call after submit. */
+    reset() {
+        this.core.reset();
+    }
+    /** Pick a dropdown option (or replace the re-edited param if in re-edit mode). */
+    selectOption(option) {
+        this.core.selectOption(option);
+    }
+    /** Promote the pill at `index` to active (front of the list). */
+    setActivePill(index) {
+        this.core.setActivePill(index);
+    }
+    /** Drop the last completed param's "completed" status. Text stays as plain text. */
+    removeLastParam() {
+        this.core.removeLastParam();
+    }
+    /** Clear the shimmer animation state for the most-recently-added param. */
+    clearNewParamId() {
+        this.core.clearNewParamId();
+    }
+    /** Controlled-mode setter for editor text. */
+    setValue(text) {
+        this.core.setValue(text);
+    }
+    /** Controlled-mode setter for completed params. */
+    setCompletedParams(params) {
+        this.core.setCompletedParams(params);
+    }
+    /** Forward plain-text input from the consumer's `<textarea>` to the core. */
+    handleTextChange(value) {
+        this.core.handleTextChange(value);
+    }
+    /** Forward keyboard events from the consumer's `<textarea>` to the core. */
+    handleKeyDown(event) {
+        this.core.handleKeyDown(event);
+    }
+    /** Notify the core of focus state. */
+    setFocused(focused) {
+        this.core.setFocused(focused);
+    }
+    /** Enter re-edit mode for the bold param with the given id. */
+    startEditingParam(paramId) {
+        this.core.startEditingParam(paramId);
+    }
+    /** Exit re-edit mode without changing the bold param. */
+    exitEditMode() {
+        this.core.exitEditMode();
+    }
+    /** Forward post-input caret position (extends the edit tail). */
+    handleCaretAfterInput(offset) {
+        this.core.handleCaretAfterInput(offset);
+    }
+    /** Forward selection-only caret moves (may exit re-edit). */
+    handleCaretMove(offset) {
+        this.core.handleCaretMove(offset);
+    }
+    /** Replace the bold param being re-edited. Returns true when applied. */
+    replaceEditingRange(replacement) {
+        return this.core.replaceEditingRange(replacement);
+    }
+    /** Set the highlighted option index (typically driven by hover). */
+    setActiveDropdownIndex(index) {
+        this.core.setActiveDropdownIndex(index);
+    }
+    // === Lifecycle ===
+    /**
+     * Apply runtime changes to a subset of options. Event callbacks
+     * (`onSubmit`, `onError`, etc.) cannot be swapped this way — they are
+     * registered once at construction (matches the React hook's design). For
+     * dynamic event reactivity, subscribe to the corresponding observable
+     * (e.g. `text$` instead of `onChange`).
+     */
+    update(opts) {
+        this.core.update(opts);
+    }
+    /**
+     * Release all resources — unsubscribes from the core, destroys the core,
+     * and completes the internal state subject. Safe to call multiple times.
+     * After destruction, action methods no-op silently.
+     */
+    destroy() {
+        if (this.isDestroyed)
+            return;
+        this.isDestroyed = true;
+        this.unsubscribeCore();
+        this.core.destroy();
+        this.rawState$.complete();
+    }
+}
+// ===== Pure helpers — not part of the public surface =====
+function computeUiLoading(s) {
+    return s.isLoading && !s.editingParam && !s.inSelectionAnimation;
+}
+function computeState(s) {
+    return {
+        text: s.text,
+        completedParams: s.completedParams,
+        suggestionPills: s.actionableSuggestions,
+        segments: s.segments,
+        newParamId: s.newParamId,
+        suggestions: s.suggestions,
+        activeIndex: s.activeDropdownIndex,
+        isLoading: computeUiLoading(s),
+        isReady: s.isReady,
+        isFocused: s.isFocused,
+        isDropdownOpen: s.isDropdownOpen,
+        placeholderText: s.placeholderText,
+        error: s.error,
+        editingParam: s.editingParam,
+        editingAnchor: s.editingAnchor,
+        caretOffset: s.caretOffset,
+    };
+}
+function computeDropdown(s) {
+    const editingParam = s.editingParam;
+    const activeSuggestion = s.actionableSuggestions[0];
+    const dropdownPill = editingParam
+        ? {
+            type: editingParam.suggestionType,
+            text: editingParam.suggestionPlaceholder,
+            required: true,
+            options: editingParam.options,
+        }
+        : null;
+    const dropdownActivePill = dropdownPill ?? activeSuggestion;
+    const dropdownPills = dropdownPill ? [dropdownPill] : s.actionableSuggestions;
+    return {
+        suggestions: dropdownActivePill ? [{ ...dropdownActivePill, options: s.filteredOptions }] : [],
+        activeIndex: s.activeDropdownIndex,
+        isOpen: s.isDropdownOpen,
+        pills: dropdownPills,
+        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"]}

package/esm2020/lib/controller/index.mjs

@@ -0,0 +1,2 @@
+export { AIAutocompleteController } from "./ai-autocomplete.controller";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvbGliL2NvbnRyb2xsZXIvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLHdCQUF3QixFQUFFLE1BQU0sOEJBQThCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgeyBBSUF1dG9jb21wbGV0ZUNvbnRyb2xsZXIgfSBmcm9tIFwiLi9haS1hdXRvY29tcGxldGUuY29udHJvbGxlclwiO1xuIl19

package/esm2020/lib/controller/observables.mjs

@@ -0,0 +1,24 @@
+import { distinctUntilChanged, map, shareReplay } from "rxjs";
+/**
+ * Per-field observable derivation factory. Enforces the §19.4 invariant:
+ *
+ * - `distinctUntilChanged` — prevents re-emission storms when the upstream
+ *   state object ticks but the field a consumer cares about hasn't changed.
+ *   Without this, every keystroke would re-render every async-pipe binding
+ *   in the consumer's template even when nothing changed for that binding.
+ * - `shareReplay({ bufferSize: 1, refCount: true })` — guarantees that
+ *   multiple subscribers (multiple `async` pipes in a template, e.g.
+ *   `*ngIf="isLoading$ | async"` and `[disabled]="isLoading$ | async"`)
+ *   share a single upstream subscription. `refCount: true` is non-obvious
+ *   but essential: without it, the inner subscription survives after the
+ *   last subscriber unmounts, leaking the chain back to `state$`.
+ *
+ * Every public observable on {@link AIAutocompleteController} must go through
+ * this factory — no exceptions.
+ *
+ * @internal
+ */
+export function deriveField(source$, selector, equalityFn) {
+    return source$.pipe(map(selector), distinctUntilChanged(equalityFn), shareReplay({ bufferSize: 1, refCount: true }));
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,180 @@
+import { Directive, ElementRef, forwardRef, Input, inject, Renderer2, } from "@angular/core";
+import { NG_VALUE_ACCESSOR } from "@angular/forms";
+import { Subject, takeUntil } from "rxjs";
+import * as i0 from "@angular/core";
+/**
+ * Tier 2 input binder. Attach to a `<textarea>` or `<input>` and pass an
+ * {@link AIAutocompleteController}:
+ *
+ * ```html
+ * <textarea [aiaInput]="ac"></textarea>
+ * ```
+ *
+ * The directive wires the input's events (input/keydown/focus/blur) to the
+ * controller, mirrors controller state into ARIA attributes
+ * (`role="combobox"`, `aria-expanded`, `aria-activedescendant`,
+ * `aria-autocomplete`, `aria-controls`), and implements
+ * {@link ControlValueAccessor} so the host element participates in Reactive
+ * Forms out of the box:
+ *
+ * ```html
+ * <textarea [aiaInput]="ac" [formControl]="myControl"></textarea>
+ * ```
+ *
+ * Per the React hook's behavior, the first typed character is auto-capitalized
+ * — typing "h" becomes "H" before being forwarded to the controller. The
+ * cursor position is preserved across that rewrite.
+ *
+ * @public
+ */
+export class AIAutocompleteInputDirective {
+    constructor() {
+        this.el = inject(ElementRef);
+        this.renderer = inject(Renderer2);
+        this.destroy$ = new Subject();
+        this.onChangeFn = noop;
+        this.onTouchedFn = noop;
+    }
+    ngOnInit() {
+        if (!this.controller) {
+            throw new Error('[aiaInput] requires a controller — use `[aiaInput]="myController"`.');
+        }
+        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
+        // user keystrokes don't fight with our writeback. Preserves the caret
+        // position when we do write (and the element still has focus).
+        this.controller.text$.pipe(takeUntil(this.destroy$)).subscribe((text) => {
+            if (el.value === text)
+                return;
+            const wasFocused = typeof document !== "undefined" && document.activeElement === el;
+            const start = el.selectionStart;
+            const end = el.selectionEnd;
+            this.renderer.setProperty(el, "value", text);
+            if (wasFocused && start != null && end != null) {
+                const clampedStart = Math.min(start, text.length);
+                const clampedEnd = Math.min(end, text.length);
+                try {
+                    el.setSelectionRange(clampedStart, clampedEnd);
+                }
+                catch {
+                    // `setSelectionRange` throws on some input types (e.g. "number");
+                    // safe to ignore — those inputs don't have a meaningful selection.
+                }
+            }
+        });
+        this.controller.isDropdownOpen$.pipe(takeUntil(this.destroy$)).subscribe((isOpen) => {
+            this.renderer.setAttribute(el, "aria-expanded", String(isOpen));
+        });
+        this.controller.activeIndex$.pipe(takeUntil(this.destroy$)).subscribe((idx) => {
+            if (idx >= 0) {
+                this.renderer.setAttribute(el, "aria-activedescendant", `${this.controller.listboxId}-option-${idx}`);
+            }
+            else {
+                this.renderer.removeAttribute(el, "aria-activedescendant");
+            }
+        });
+    }
+    ngOnDestroy() {
+        this.destroy$.next();
+        this.destroy$.complete();
+    }
+    // === Event handlers (wired via host metadata above) ===
+    /**
+     * Auto-capitalizes the first character on the user's first keystroke so the
+     * server receives "Create" instead of "create". Matches React's
+     * `handleChange` in `useAIAutocomplete`. Skipped during IME composition so
+     * we don't disrupt multi-keystroke input methods (Pinyin, Hangul, etc.).
+     */
+    onInput(event) {
+        const target = event.target;
+        const raw = target.value;
+        const isComposing = event.isComposing === true;
+        const shouldCapitalize = raw.length > 0 && !isComposing && raw[0] !== raw[0].toUpperCase();
+        let next = raw;
+        if (shouldCapitalize) {
+            const start = target.selectionStart;
+            const end = target.selectionEnd;
+            next = raw[0].toUpperCase() + raw.slice(1);
+            this.renderer.setProperty(target, "value", next);
+            if (start != null && end != null) {
+                try {
+                    target.setSelectionRange(start, end);
+                }
+                catch {
+                    // See note in ngOnInit's text$ subscriber.
+                }
+            }
+        }
+        this.controller.handleTextChange(next);
+        this.onChangeFn(next);
+    }
+    onKeyDown(event) {
+        this.controller.handleKeyDown(event);
+    }
+    onFocus() {
+        this.controller.setFocused(true);
+    }
+    onBlur() {
+        this.controller.setFocused(false);
+        this.onTouchedFn();
+    }
+    // === ControlValueAccessor ===
+    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)
+            this.controller.setValue(next);
+    }
+    registerOnChange(fn) {
+        this.onChangeFn = fn;
+    }
+    registerOnTouched(fn) {
+        this.onTouchedFn = fn;
+    }
+    setDisabledState(disabled) {
+        this.renderer.setProperty(this.el.nativeElement, "disabled", disabled);
+    }
+}
+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: [
+        {
+            provide: NG_VALUE_ACCESSOR,
+            // eslint-disable-next-line @typescript-eslint/no-use-before-define
+            useExisting: forwardRef(() => AIAutocompleteInputDirective),
+            multi: true,
+        },
+    ], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: AIAutocompleteInputDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: "[aiaInput]",
+                    standalone: true,
+                    host: {
+                        role: "combobox",
+                        "aria-autocomplete": "list",
+                        "(input)": "onInput($event)",
+                        "(keydown)": "onKeyDown($event)",
+                        "(focus)": "onFocus()",
+                        "(blur)": "onBlur()",
+                    },
+                    providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            // eslint-disable-next-line @typescript-eslint/no-use-before-define
+                            useExisting: forwardRef(() => AIAutocompleteInputDirective),
+                            multi: true,
+                        },
+                    ],
+                }]
+        }], propDecorators: { controller: [{
+                type: Input,
+                args: ["aiaInput"]
+            }] } });
+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"]}

package/esm2020/lib/input/index.mjs

@@ -0,0 +1,2 @@
+export { AIAutocompleteInputDirective } from "./ai-autocomplete-input.directive";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvbGliL2lucHV0L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSw0QkFBNEIsRUFBRSxNQUFNLG1DQUFtQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHsgQUlBdXRvY29tcGxldGVJbnB1dERpcmVjdGl2ZSB9IGZyb20gXCIuL2FpLWF1dG9jb21wbGV0ZS1pbnB1dC5kaXJlY3RpdmVcIjtcbiJdfQ==