stimeo-ui 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 10b597acf4a7ae2ea8c06755f65219ebcd6cf8620dada3700e196d75991c5544
-  data.tar.gz: d0cabdded21420aa90c4eb4eb439588ab7a0bfeff3d4f9fe83b179197de9acb2
+  metadata.gz: dc8f7abf12a14555f6b1182d81844594d3bf86c772f115338d931e15eb35a43e
+  data.tar.gz: fee179d507f73e693b718e8563e3239d7a3fcad20d42d6db4624bdcbdf2a353c
 SHA512:
-  metadata.gz: 66afe27aa72dcbd893b2e2f76525bfddc6bd55788b15ee531cbad6357342ec0bf4d3c2ada2e3cd3dad7dfa37ff9306356b866c1a6e7bdde2445cb103ef944119
-  data.tar.gz: 616de9b15f081a503d907cb468a3c6ad77a74a6773e9677f3e1b9fb28baad505d5bfff6d588c66b48ed965a5acd275f5d8cc1209d69bac2aa7a89153e143be54
+  metadata.gz: e68c6fd65748f2e637ddd8bd77364f74f4336549fdd2bb47803d5bd0e300c7838c0037850154d040f32aadb7ccab53879dc754acf8bbe99430ddedeb3b102b8f
+  data.tar.gz: 833febb4eb631e61d0d700e56a13cfb38fa59465757a4d0c5f9430a8f87967ef9a8cc993e3272922b4794ec88b9ab38c8244a1c7614a904cc1d539bc40cd3e81

data/CHANGELOG.md

@@ -7,6 +7,167 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 While the version is `0.x`, the public API (the `stimeo--*` data attributes) may
 change between releases.
 
+## [0.3.0] - 2026-08-09
+
+Minor release focused on consistent keyboard and selection behavior, resilient
+runtime DOM changes, and substantially stronger Inspector diagnostics. No
+controller, target, value, action, event, or package export was removed. The
+Inspector manifest advances from schema v5 to v8, so tools that read the raw
+manifest must accept the new schema and fields.
+
+### Upgrade notes
+
+- Run `stimeo check` against existing views before deploying. New structural
+  checks can report errors for incomplete optional target groups, missing
+  companion controllers, undeclared role-bearing targets, and invalid
+  cardinality. New ARIA checks can also add warnings without failing the command.
+- In RTL containers, horizontal arrow keys now follow logical inline direction
+  across composite widgets. LTR behavior is unchanged.
+- Slider, range-slider, and color-picker pointer/arrow mirroring remains opt-in:
+  set their new `logicalTrack` value only when the consuming CSS mirrors the
+  track in RTL.
+- calendar's `stimeo--calendar:monthchange` no longer fires while the grid
+  settles on its initial month, so code that ran from that first event must now
+  run once at initialization. Listeners that re-apply per-date `aria-disabled`
+  marks are the common case.
+
+### Added
+
+- breadcrumb: a public `update` action for reconciling collapsible state after
+  application-driven DOM changes.
+- tree-view: a public `toggle` action for explicitly expanding or collapsing an
+  item from application markup.
+- scrollspy: a `focusSection` value for opting into focus movement when a link
+  activates a section.
+- slider, range-slider, color-picker: the `logicalTrack` value described above.
+- Inspector schema v6-v8: conditional target requirements and the new
+  `missing-companion`, `undeclared-target`, `cardinality-violation`,
+  `forbidden-aria`, and `missing-conditional-target` diagnostics. Rules can now
+  depend on controller values, element/document conditions, contained targets,
+  and ARIA requirement severity.
+
+### Changed
+
+- accordion, carousel, calendar, combobox, command-palette, context-menu,
+  data-grid, date-range-picker, listbox, menu, menubar, multi-select,
+  navigation-menu, OTP, radio-group, roving, tabs, tags-input, time-picker,
+  toggle-group, toolbar, tree-view, and related horizontal controls now resolve
+  Left/Right behavior from the effective text direction. Sortable geometry also
+  follows logical inline direction.
+- Arrow-key handlers yield modified browser shortcuts, and composite handlers
+  yield events already consumed by a nested widget. IME composition continues to
+  take precedence over component shortcuts.
+- Selection widgets normalize controller-owned `aria-selected` state, preserve a
+  single active/selected item where the pattern requires one, and reconcile that
+  state when options are inserted, removed, or replaced at runtime.
+- menu and overflow-menu delegate item interaction from their containers, so
+  dynamically added items work without per-item actions. Existing action markup
+  remains compatible.
+- `aria-disabled="true"` items remain discoverable by composite keyboard
+  navigation while activation, expansion, and consumer actions are suppressed.
+- Outside pointer listeners for dismissible composites — click and context-menu
+  alike — run in the capture phase so nested application code cannot leave an
+  open layer stuck by stopping bubbling.
+- Inspector accessible-name diagnostics now follow ARIA's Required, Recommended,
+  and conditional levels instead of treating every role alike.
+
+### Fixed
+
+- combobox, command-palette, listbox, and multi-select no longer retain stale
+  active IDs, selection, chips, or hidden fields after Turbo morphs and runtime
+  target replacement. A disconnect/reconnect in the same task can no longer let
+  an old reconciliation microtask consume the fresh generation's pass.
+- breadcrumb fails open when its optional disclosure targets are incomplete and
+  restores items that leave the collapsible set instead of leaving them hidden.
+- menu, menubar, navigation-menu, overflow-menu, pagination, and tree-view now
+  recover focus consistently across empty lists, disabled fieldsets, hidden
+  ancestors, item banking, and runtime item removal.
+- toolbar restores its single tab stop when an enclosing `<fieldset>` is
+  re-enabled, so unlocking a form brings the group back into the Tab sequence.
+- multi-select keeps chip focus when the selection was made in an order other
+  than the option order. The chips are reconciled against the selected value set
+  rather than position by position, and their labels are paired by value.
+- overflow-menu measures items adopted from server-rendered overflow in the bar
+  rather than inside the closed menu, so an already-overflowed bar no longer
+  returns every item to the bar on first paint.
+- combobox commits a clicked option after its input target is removed instead of
+  throwing, matching the tolerance the popup already had for that state.
+- color-picker falls back to the per-channel range when a slider omits
+  `aria-valuemin` / `aria-valuemax`, instead of pinning the channel at zero.
+- calendar maintains exactly one roving tab stop while selection and available
+  days change.
+- calendar reports `monthchange` from the month it paints, so a malformed
+  `month` value can no longer put a raw non-`YYYY-MM` string in `detail.month`.
+  The report is driven by the repaint rather than by the `month` value, so a
+  fallback month moved by `selected` or by selecting a neighbouring month's cell
+  is announced as it happens instead of arriving on a later repaint. Re-applying
+  the same month, as a Turbo cache restore does, stays silent.
+- scrollspy re-evaluates links and sections after every supported entry path;
+  intersection-based controllers align fallback thresholds, hidden-layout
+  handling, and reduced-motion behavior.
+- `stimeo catalog --json` and large `stimeo check --json` reports are no longer
+  truncated when stdout is piped; the CLI now lets buffered output flush before
+  exiting, and the build audit exercises the real piped catalog.
+
+## [0.2.1] - 2026-07-26
+
+Patch release from a review of the disclosure and layout components, plus a
+packaging fix. No breaking changes, but `stimeo check` now reports two markup
+requirements that existing pages may need to satisfy.
+
+### Added
+
+- sidebar: `beforeCache` action for Turbo page caching — wire
+  `data-action="turbo:before-cache@document->stimeo--sidebar#beforeCache"` to close
+  an open overlay and release its modal side effects before the snapshot is taken.
+- sidebar, stepper: the `breakpoint` and `index` values now take effect when
+  changed at runtime. An invalid `breakpoint` falls back to 768px.
+- Inspector: `stimeo check` verifies that the tabs `role="tablist"` element has an
+  accessible name.
+
+### Changed
+
+- tabs: the tablist container is now a required `list` target. Add
+  `data-stimeo--tabs-target="list"` to it, or `stimeo check` reports an error.
+  Runtime behavior is unchanged.
+- Inspector: `stimeo check` reports an error when `stimeo--sidebar` markup has no
+  `panel` target.
+
+### Fixed
+
+- package exports: 26 controllers — including sidebar, drawer, collapsible,
+  read-more, alert-dialog, carousel and tree-view — had no build output behind the
+  `./controllers/*` subpath their `package.json` `exports` declares, so
+  `import … from "stimeo-ui/controllers/<name>_controller"` failed to resolve in
+  0.2.0. Every controller in the catalog now ships one.
+- transition, flash, toast, sidebar, drawer, collapsible: animations now wait for
+  every declared transition property and its `transition-delay`, not just the
+  first duration. Multi-property and delayed animations are no longer cut short, a
+  cancelled transition settles immediately, and pseudo-element transitions no
+  longer end the wait early — so `hidden`, events, focus restore and scroll unlock
+  land at the right moment.
+- sidebar, drawer, collapsible: an interrupted close animation no longer leaves the
+  panel stuck open with the focus trap, background `inert` or scroll lock in place.
+- sidebar, drawer, collapsible, read-more, sticky-observer, overflow-indicator:
+  targets swapped in or added after connect (Turbo morph, lazily loaded Frames,
+  Streams) are now reconciled with the current state instead of keeping the value
+  they were rendered with.
+- overflow-indicator, scroll-area: horizontal position is read logically, so the
+  overflow attributes, the `scrollByPage` action, `data-scroll` and
+  `--stimeo-scroll-progress` behave correctly inside `dir="rtl"` containers.
+- overflow-indicator: reaching an edge while a page button has focus no longer
+  drops focus to the page body — the button stays focused and inert via
+  `aria-disabled`, becoming natively `disabled` only once blurred.
+- read-more: the toggle is no longer hidden while it holds keyboard focus when the
+  text starts to fit; overflow is re-checked on blur, on content changes, and when
+  media inside it finishes loading.
+- sticky-observer: `data-stuck="true"` is set only once the sentinel has actually
+  scrolled past the top edge — one that is merely out of view, or inside a hidden
+  container, no longer marks the element as stuck. Negative `offset` values are now
+  accepted.
+- intersection: an element with no layout box (hidden ancestor, collapsed
+  `<details>`) is no longer reported as scrolled past.
+
 ## [0.2.0] - 2026-07-22
 
 First release off the beta channel: `npm install stimeo-ui` now resolves
@@ -175,6 +336,8 @@ Initial public alpha: 101 behavior-only, accessible Stimulus controllers driven
 by `data-*` attributes, shipping no CSS. Published to npm (with provenance) and
 RubyGems.
 
+[0.3.0]: https://github.com/taiyaky/stimeo-ui/releases/tag/v0.3.0
+[0.2.1]: https://github.com/taiyaky/stimeo-ui/releases/tag/v0.2.1
 [0.2.0]: https://github.com/taiyaky/stimeo-ui/releases/tag/v0.2.0
 [0.1.0-beta.3]: https://github.com/taiyaky/stimeo-ui/releases/tag/v0.1.0-beta.3
 [0.1.0-beta.2]: https://github.com/taiyaky/stimeo-ui/releases/tag/v0.1.0-beta.2

data/dist/controllers/accordion_controller.js

@@ -1,5 +1,13 @@
 import { Controller } from '@hotwired/stimulus';
 
+// src/controllers/accordion_controller.ts
+
+// src/utils/arrow_step.ts
+function isReservedArrowChord(event, allow = []) {
+  if (!event.key.startsWith("Arrow")) return false;
+  return event.altKey && !allow.includes("alt") || event.ctrlKey && !allow.includes("ctrl") || event.metaKey && !allow.includes("meta") || event.shiftKey && !allow.includes("shift");
+}
+
 // src/controllers/accordion_controller.ts
 var AccordionController = class extends Controller {
   static targets = ["trigger", "panel"];
@@ -39,6 +47,8 @@ var AccordionController = class extends Controller {
    * `.focus()` lands on nothing and navigation appears to stall.
    */
   onKeydown(event) {
+    if (event.defaultPrevented) return;
+    if (isReservedArrowChord(event)) return;
     const current = event.currentTarget;
     if (this.triggerTargets.indexOf(current) === -1) return;
     const navigable = this.triggerTargets.filter((trigger) => trigger.closest("[hidden]") === null);

data/dist/controllers/alert_dialog_controller.js

@@ -0,0 +1,318 @@
+import { Controller } from '@hotwired/stimulus';
+
+// src/controllers/alert_dialog_controller.ts
+
+// src/utils/escape_layer.ts
+var EscapeLayer = class _EscapeLayer {
+  static #registries = /* @__PURE__ */ new WeakMap();
+  #ownerDocument = null;
+  /** Dismissal callback while active; `null` when inactive. */
+  #onDismiss = null;
+  /** Live predicate deciding whether the layer claims a press; `null` = always. */
+  #claims = null;
+  /**
+   * Activates this layer at the top of its document's Escape stack, installing
+   * the document's shared resolver listener if this is its first layer.
+   * Re-activating an already-active layer moves it to the top.
+   */
+  activate(ownerDocument = document, options) {
+    this.deactivate();
+    let registry = _EscapeLayer.#registries.get(ownerDocument);
+    if (!registry) {
+      registry = _EscapeLayer.#createRegistry();
+      _EscapeLayer.#registries.set(ownerDocument, registry);
+      ownerDocument.addEventListener("keydown", registry.onKeydown);
+    }
+    registry.stack.push(this);
+    this.#ownerDocument = ownerDocument;
+    this.#onDismiss = options.onDismiss;
+    this.#claims = options.claims ?? null;
+  }
+  /**
+   * Removes this layer from its document's Escape stack, uninstalling the
+   * shared listener when the stack empties. Safe to call when inactive.
+   */
+  deactivate() {
+    const ownerDocument = this.#ownerDocument;
+    if (!ownerDocument) return;
+    const registry = _EscapeLayer.#registries.get(ownerDocument);
+    if (registry) {
+      const index = registry.stack.lastIndexOf(this);
+      if (index >= 0) registry.stack.splice(index, 1);
+      if (registry.stack.length === 0) {
+        ownerDocument.removeEventListener("keydown", registry.onKeydown);
+        _EscapeLayer.#registries.delete(ownerDocument);
+      }
+    }
+    this.#ownerDocument = null;
+    this.#onDismiss = null;
+    this.#claims = null;
+  }
+  /**
+   * Whether this active layer would own a press right now: it is the topmost
+   * layer whose {@link EscapeLayerOptions.claims} passes. Exposed for tests
+   * and diagnostics — production dismissal goes through the shared listener.
+   */
+  get ownsEscape() {
+    const ownerDocument = this.#ownerDocument;
+    if (!ownerDocument) return false;
+    const registry = _EscapeLayer.#registries.get(ownerDocument);
+    if (!registry) return false;
+    return _EscapeLayer.#resolveOwner(registry.stack) === this;
+  }
+  /** Builds a document's registry with its shared resolver listener. */
+  static #createRegistry() {
+    const registry = {
+      stack: [],
+      onKeydown: (event) => {
+        if (event.key !== "Escape" || event.defaultPrevented || event.isComposing) return;
+        const owner = _EscapeLayer.#resolveOwner(registry.stack);
+        if (!owner) return;
+        event.preventDefault();
+        owner.#onDismiss?.();
+      }
+    };
+    return registry;
+  }
+  /** The topmost stack layer whose claims predicate passes, or `null`. */
+  static #resolveOwner(stack) {
+    for (let index = stack.length - 1; index >= 0; index--) {
+      const layer = stack[index];
+      if (!layer) continue;
+      if (layer.#claims && !layer.#claims()) continue;
+      return layer;
+    }
+    return null;
+  }
+};
+
+// src/utils/focus_trap.ts
+var FOCUSABLE = 'a[href], button:not([disabled]), textarea:not([disabled]), input:not([disabled]), select:not([disabled]), [tabindex]:not([tabindex="-1"])';
+var FocusTrap = class {
+  /** The element focused before activation, restored on deactivation. */
+  #previouslyFocused = null;
+  /** The body's inline `overflow` before locking, restored on deactivation. */
+  #previousBodyOverflow = "";
+  /** Whether scroll was locked this activation (so it is only restored if applied). */
+  #scrollLocked = false;
+  /** Background siblings made `inert` while active, restored on deactivation. */
+  #inertedSiblings = [];
+  /** Whether the modal side effects are currently applied. */
+  #activeState = false;
+  /** Registers the trap on the shared Escape stack while active (see {@link EscapeLayer}). */
+  #escapeLayer = new EscapeLayer();
+  /** Returns the trapped element; called on every operation for the live target. */
+  #getContainer;
+  /** Closing/focus hooks; see {@link FocusTrapOptions}. */
+  #options;
+  /**
+   * @param getContainer - Returns the trapped element. Called on every operation
+   *   so the live target is always used.
+   * @param options - Closing/focus hooks; see {@link FocusTrapOptions}.
+   */
+  constructor(getContainer, options = {}) {
+    this.#getContainer = getContainer;
+    this.#options = options;
+  }
+  /** Whether the trap is currently active. */
+  get active() {
+    return this.#activeState;
+  }
+  /**
+   * Applies the trap: records the current focus, optionally locks background scroll
+   * and makes background siblings `inert`, listens for `Tab`/`Escape`, and (unless
+   * `autoFocus` is off) moves focus inside. No-ops if already active.
+   */
+  activate() {
+    if (this.#activeState) return;
+    this.#activeState = true;
+    const active = document.activeElement;
+    this.#previouslyFocused = active instanceof HTMLElement && active !== document.body ? active : null;
+    if (this.#flag(this.#options.lockScroll, true)) {
+      this.#previousBodyOverflow = document.body.style.overflow;
+      document.body.style.overflow = "hidden";
+      this.#scrollLocked = true;
+    }
+    if (this.#flag(this.#options.isolate, true)) this.#isolateBackground();
+    document.addEventListener("keydown", this.#onKeydown);
+    document.addEventListener("turbo:before-cache", this.#onBeforeCache);
+    const onEscape = this.#options.onEscape;
+    if (onEscape) this.#escapeLayer.activate(document, { onDismiss: () => onEscape() });
+    if (this.#flag(this.#options.autoFocus, true)) this.#focusInitial();
+  }
+  /**
+   * Reverts every side effect applied by {@link activate}. No-ops if inactive, so
+   * a controller can call it defensively from both `close()` and `disconnect()`.
+   *
+   * @param restoreFocus - Move focus back to the opener (default `true`). Pass
+   *   `false` on teardown (`disconnect`), where yanking focus is undesirable.
+   */
+  deactivate({ restoreFocus = true } = {}) {
+    if (!this.#activeState) return;
+    this.#activeState = false;
+    this.#escapeLayer.deactivate();
+    document.removeEventListener("keydown", this.#onKeydown);
+    document.removeEventListener("turbo:before-cache", this.#onBeforeCache);
+    if (this.#scrollLocked) {
+      document.body.style.overflow = this.#previousBodyOverflow;
+      this.#scrollLocked = false;
+    }
+    this.#releaseBackground();
+    if (restoreFocus) {
+      const target = this.#previouslyFocused ?? this.#options.fallbackFocus?.() ?? null;
+      target?.focus();
+    }
+  }
+  /** Resolves a boolean-or-getter option, defaulting when it was not provided. */
+  #flag(option, fallback) {
+    if (option === void 0) return fallback;
+    return typeof option === "function" ? option() : option;
+  }
+  /**
+   * Reverts the side effects just before Turbo caches the page snapshot, so an
+   * overlay left open does not bake the scroll lock into `body[style]` — a
+   * restored page would feed that locked value back into {@link activate} as the
+   * baseline, and closing would then never unlock the page. Markup state stays
+   * untouched (restore-open designs reopen against a clean baseline), and focus
+   * is left alone mid-navigation. The listener lives only while active.
+   */
+  #onBeforeCache = () => {
+    this.deactivate({ restoreFocus: false });
+  };
+  /**
+   * Handles `Tab` (focus trap) while active. `Escape` dismissal is owned by the
+   * shared {@link EscapeLayer} resolver, so Tab trapping stays independent of
+   * which layer currently owns Escape.
+   */
+  #onKeydown = (event) => {
+    if (event.key === "Tab") this.#trapTab(event);
+  };
+  /** Keeps `Tab` focus cycling within the container's focusable elements. */
+  #trapTab(event) {
+    const focusable = this.#focusableElements();
+    if (focusable.length === 0) {
+      event.preventDefault();
+      return;
+    }
+    const first = focusable[0];
+    const last = focusable[focusable.length - 1];
+    const active = document.activeElement;
+    if (!(active instanceof Node) || !this.#getContainer().contains(active)) {
+      event.preventDefault();
+      first?.focus();
+      return;
+    }
+    if (event.shiftKey && active === first) {
+      event.preventDefault();
+      last?.focus();
+    } else if (!event.shiftKey && active === last) {
+      event.preventDefault();
+      first?.focus();
+    }
+  }
+  /**
+   * Marks every element outside the container's subtree as `inert` so background
+   * content cannot be focused or reached by assistive technology, honoring the
+   * `aria-modal="true"` contract. An element that was *already* `inert` is left
+   * untracked so `#releaseBackground` does not wrongly clear it.
+   */
+  #isolateBackground() {
+    const container = this.#getContainer();
+    this.#inertedSiblings = [];
+    for (const sibling of Array.from(document.body.children)) {
+      if (!(sibling instanceof HTMLElement)) continue;
+      if (sibling.contains(container) || sibling.inert) continue;
+      sibling.inert = true;
+      this.#inertedSiblings.push(sibling);
+    }
+  }
+  /** Reverts the `inert` flags applied by `#isolateBackground`. */
+  #releaseBackground() {
+    for (const sibling of this.#inertedSiblings) {
+      sibling.inert = false;
+    }
+    this.#inertedSiblings = [];
+  }
+  /** Moves focus to the initial target, the first focusable, or the container. */
+  #focusInitial() {
+    const preferred = this.#options.initialFocus?.();
+    if (preferred) {
+      preferred.focus();
+      return;
+    }
+    const focusable = this.#focusableElements();
+    if (focusable[0]) {
+      focusable[0].focus();
+      return;
+    }
+    const container = this.#getContainer();
+    container.tabIndex = -1;
+    container.focus();
+  }
+  /** Collects the container's currently focusable descendants in DOM order. */
+  #focusableElements() {
+    return Array.from(this.#getContainer().querySelectorAll(FOCUSABLE)).filter(
+      (el) => !el.hidden
+    );
+  }
+};
+
+// src/controllers/alert_dialog_controller.ts
+var AlertDialogController = class extends Controller {
+  static targets = ["trigger", "dialog", "initialFocus"];
+  static actions = ["cancel", "confirm", "open"];
+  static events = ["cancel", "confirm"];
+  /**
+   * Owns the modal side effects. Escape is routed through {@link cancel} so it
+   * emits the same event as the cancel button (tagged `"escape"`); focus falls
+   * back to the trigger when nothing was focused before opening.
+   */
+  #trap = new FocusTrap(() => this.dialogTarget, {
+    onEscape: () => this.#requestCancel("escape"),
+    initialFocus: () => this.hasInitialFocusTarget ? this.initialFocusTarget : null,
+    fallbackFocus: () => this.hasTriggerTarget ? this.triggerTarget : null
+  });
+  /** Starts closed (idempotently reflects the closed state on the markup). */
+  connect() {
+    if (this.hasDialogTarget) this.dialogTarget.hidden = true;
+  }
+  /** Reverts the modal side effects if torn down while open (Turbo navigation). */
+  disconnect() {
+    this.#trap.deactivate({ restoreFocus: false });
+  }
+  /** Opens the dialog, traps focus, and locks background scroll. */
+  open() {
+    if (!this.hasDialogTarget || this.#isOpen) return;
+    this.dialogTarget.hidden = false;
+    this.#trap.activate();
+  }
+  /** Confirms: closes and dispatches `confirm`. Bound via `data-action`. */
+  confirm() {
+    if (!this.#isOpen) return;
+    this.dispatch("confirm");
+    this.#closeDialog();
+  }
+  /** Cancels (user action): closes and dispatches `cancel` with `reason: "user"`. */
+  cancel() {
+    this.#requestCancel("user");
+  }
+  /** Shared cancel path used by both the cancel action and the Escape key. */
+  #requestCancel(reason) {
+    if (!this.#isOpen) return;
+    this.dispatch("cancel", { detail: { reason } });
+    this.#closeDialog();
+  }
+  /** Hides the dialog and reverts the modal side effects (restoring focus). */
+  #closeDialog() {
+    this.dialogTarget.hidden = true;
+    this.#trap.deactivate();
+  }
+  /** Whether the dialog is currently visible. */
+  get #isOpen() {
+    return this.hasDialogTarget && !this.dialogTarget.hidden;
+  }
+};
+
+export { AlertDialogController };
+//# sourceMappingURL=alert_dialog_controller.js.map
+//# sourceMappingURL=alert_dialog_controller.js.map