@adobe/spectrum-wc-core 0.0.0-snapshot.20260922095923

package/dist/controllers/page-scroll-lock-controller/src/page-scroll-lock.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"page-scroll-lock.js","names":[],"sources":["../../../../controllers/page-scroll-lock-controller/src/page-scroll-lock.ts"],"sourcesContent":["/**\n * Copyright 2026 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */\n\nimport type { ReactiveController, ReactiveElement } from 'lit';\n\n// ────────────────────────────────────────────\n// Module-scoped reference-counted lock\n// ────────────────────────────────────────────\n//\n// Stacked blocking surfaces (e.g. nested modal dialogs, a modal popover opened\n// over another) must coordinate a single page-scroll lock. The document's\n// original `overflow` is captured once on the 0 -> 1 transition and restored\n// once on the 1 -> 0 transition. Saving per instance would let a later locker\n// capture an already-locked value (`hidden`) and then restore it permanently\n// when it releases, leaving the page unscrollable.\n\nlet lockCount = 0;\nlet savedOverflow = '';\n\nfunction acquirePageScrollLock(): void {\n  if (lockCount === 0) {\n    const html = document.documentElement;\n    savedOverflow = html.style.overflow;\n    html.style.overflow = 'hidden';\n  }\n  lockCount += 1;\n}\n\nfunction releasePageScrollLock(): void {\n  if (lockCount === 0) {\n    return;\n  }\n  lockCount -= 1;\n  if (lockCount === 0) {\n    document.documentElement.style.overflow = savedOverflow;\n    savedOverflow = '';\n  }\n}\n\n/**\n * Locks page scroll behind a blocking surface (a modal popover, dialog, or tray)\n * by setting `overflow: hidden` on the document element. A component's shadow\n * stylesheet cannot reach `<html>`, so this is done in JS.\n *\n * The lock is reference-counted at module scope so concurrent locks from stacked\n * surfaces do not clobber one another's saved state. Each host holds at most one\n * count (the per-instance `lock()` / `unlock()` are idempotent), and the\n * controller releases the host's count automatically on disconnect.\n */\nexport class PageScrollLockController implements ReactiveController {\n  private _locked = false;\n\n  constructor(host: ReactiveElement) {\n    host.addController(this);\n  }\n\n  /** Lock page scroll on behalf of the host. Idempotent per host. */\n  public lock(): void {\n    if (this._locked) {\n      return;\n    }\n    this._locked = true;\n    acquirePageScrollLock();\n  }\n\n  /** Release the host's lock if it holds one. Idempotent per host. */\n  public unlock(): void {\n    if (!this._locked) {\n      return;\n    }\n    this._locked = false;\n    releasePageScrollLock();\n  }\n\n  public hostDisconnected(): void {\n    this.unlock();\n  }\n}\n"],"mappings":";AAyBA,IAAI,IAAY,GACZ,IAAgB;AAEpB,SAAS,IAA8B;AACrC,KAAI,MAAc,GAAG;EACnB,IAAM,IAAO,SAAS;AAEtB,EADA,IAAgB,EAAK,MAAM,UAC3B,EAAK,MAAM,WAAW;;AAExB,MAAa;;AAGf,SAAS,IAA8B;AACjC,OAAc,MAGlB,KACI,MAAc,MAChB,SAAS,gBAAgB,MAAM,WAAW,GAC1C,IAAgB;;AAcpB,IAAa,IAAb,MAAoE;CAGlE,YAAY,GAAuB;AACjC,iBAHgB,IAGhB,EAAK,cAAc,KAAK;;CAI1B,OAAoB;AACd,OAAK,YAGT,KAAK,UAAU,IACf,GAAuB;;CAIzB,SAAsB;AACf,OAAK,YAGV,KAAK,UAAU,IACf,GAAuB;;CAGzB,mBAAgC;AAC9B,OAAK,QAAQ"}

package/dist/controllers/pending-controller/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Copyright 2026 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+export { PendingController, type PendingControllerHost, type PendingControllerOptions, } from './src/pending-controller.js';

package/dist/controllers/pending-controller/index.js

@@ -0,0 +1,2 @@
+import { PendingController as e } from "./src/pending-controller.js";
+export { e as PendingController };

package/dist/controllers/pending-controller/src/pending-controller.d.ts

@@ -0,0 +1,95 @@
+import { ReactiveController, ReactiveElement } from 'lit';
+import { PendingSpinnerResult } from '../../../directives/pending-spinner/index.js';
+/** Minimum interface required from any element that hosts a {@link PendingController}. */
+export interface PendingControllerHost extends ReactiveElement {
+    /** Whether the host is in a pending (busy) state. */
+    pending: boolean;
+    /**
+     * Optional explicit accessible label used during the pending state. When
+     * omitted, the controller derives a busy label from
+     * {@link PendingControllerOptions.resolveAccessibleName}.
+     */
+    pendingLabel?: string;
+}
+/** Configuration options for {@link PendingController}. */
+export interface PendingControllerOptions {
+    /**
+     * Milliseconds to wait after `pending` becomes true before activating the
+     * pending visual, so the host does not flash to its busy appearance for
+     * operations that complete quickly. Defaults to `1000`.
+     */
+    delay?: number;
+    /**
+     * CSS selector, resolved within the host's `renderRoot`, for the element
+     * whose inline size should be frozen while pending (via
+     * `--swc-pending-inline-size`) so the host does not resize when its label or
+     * icon is hidden. Defaults to `'button'`. Pass `null` to skip the freeze.
+     */
+    targetSelector?: string | null;
+    /**
+     * Returns the host's non-busy accessible name, used to derive the default
+     * busy label (`"<name>, busy"`). Keeps the controller decoupled from how the
+     * host resolves its own name.
+     */
+    resolveAccessibleName?: () => string | null;
+}
+/**
+ * A Lit {@link ReactiveController} that manages the pending (busy) *state* of a
+ * host element: the delayed visual activation, freezing the host's inline size
+ * while busy, and deriving the pending accessible name. Rendering is handled
+ * separately by the `renderPendingSpinner` directive
+ * (`@adobe/spectrum-wc-core/directives/pending-spinner`); wiring (the
+ * `pending` / `pending-label` properties and click suppression) is handled by
+ * `PendingMixin` (`@adobe/spectrum-wc-core/mixins`).
+ *
+ * The accessible name and `aria-disabled` are applied by the host's own
+ * template, keyed off `host.pending` for an immediate (non-delayed) response;
+ * this controller exposes {@link getPendingAccessibleName} for the host to read.
+ *
+ * @example
+ * ```ts
+ * const pendingController = new PendingController(this, {
+ *   resolveAccessibleName: () => this.textContent?.trim() || null,
+ * });
+ * // in render(): class=${classMap({ active: pendingController.pendingActive })}
+ * ```
+ */
+export declare class PendingController implements ReactiveController {
+    private readonly _host;
+    private readonly _delay;
+    private readonly _targetSelector;
+    private readonly _resolveAccessibleName;
+    private _timer;
+    /** Tracks the last-seen `pending` value so transitions can be detected in `hostUpdate`. */
+    private _wasPending;
+    /**
+     * Whether the pending visual is currently active. Becomes `true` only after
+     * the configured delay so the host does not flash to its busy appearance for
+     * operations that complete quickly. Read this from the host's `render`.
+     */
+    get pendingActive(): boolean;
+    private _pendingActive;
+    constructor(host: PendingControllerHost, options?: PendingControllerOptions);
+    /**
+     * Derives the pending-state accessible label. Prefers an explicit
+     * `pendingLabel`, then the resolved non-busy name plus a ", busy" suffix,
+     * then a fixed "Busy" fallback.
+     */
+    getPendingAccessibleName(): string;
+    /**
+     * Renders the pending spinner for the controller's current state via the
+     * `renderPendingSpinner` directive. Exposed here so a host gets the indicator
+     * straight from the controller, without importing the directive separately.
+     * Returns `nothing` while the host is not pending.
+     */
+    renderPendingState(): PendingSpinnerResult;
+    hostConnected(): void;
+    hostUpdate(): void;
+    hostDisconnected(): void;
+    private _activateAfterDelay;
+    private _deactivate;
+    private _clearTimer;
+    private get _freezeTarget();
+    private _freezeInlineSize;
+    private _releaseInlineSize;
+}

package/dist/controllers/pending-controller/src/pending-controller.js

@@ -0,0 +1,55 @@
+import { renderPendingSpinner as e } from "../../../directives/pending-spinner/src/pending-spinner.js";
+import "../../../directives/pending-spinner/index.js";
+//#region controllers/pending-controller/src/pending-controller.ts
+var t = 1e3, n = "--swc-pending-inline-size", r = class {
+	get pendingActive() {
+		return this._pendingActive;
+	}
+	constructor(e, n = {}) {
+		var r, i;
+		this._timer = null, this._wasPending = !1, this._pendingActive = !1, this._host = e, this._delay = (r = n.delay) == null ? t : r, this._targetSelector = n.targetSelector === void 0 ? "button" : n.targetSelector, this._resolveAccessibleName = (i = n.resolveAccessibleName) == null ? (() => null) : i, e.addController(this);
+	}
+	getPendingAccessibleName() {
+		if (this._host.pendingLabel) return this._host.pendingLabel;
+		let e = this._resolveAccessibleName();
+		return e ? `${e}, busy` : "Busy";
+	}
+	renderPendingState() {
+		return e(this._host.pending, this._pendingActive);
+	}
+	hostConnected() {
+		this._host.pending && !this._wasPending && (this._wasPending = !0, this._activateAfterDelay());
+	}
+	hostUpdate() {
+		this._host.pending !== this._wasPending && (this._wasPending = this._host.pending, this._host.pending ? this._activateAfterDelay() : this._deactivate());
+	}
+	hostDisconnected() {
+		this._clearTimer(), this._wasPending = !1, this._pendingActive = !1;
+	}
+	_activateAfterDelay() {
+		this._timer = setTimeout(() => {
+			this._timer = null, this._host.pending && (this._freezeInlineSize(), this._pendingActive = !0, this._host.requestUpdate());
+		}, this._delay);
+	}
+	_deactivate() {
+		this._clearTimer(), this._releaseInlineSize(), this._pendingActive && (this._pendingActive = !1, this._host.requestUpdate());
+	}
+	_clearTimer() {
+		this._timer !== null && (clearTimeout(this._timer), this._timer = null);
+	}
+	get _freezeTarget() {
+		return this._targetSelector ? this._host.renderRoot.querySelector(this._targetSelector) : null;
+	}
+	_freezeInlineSize() {
+		let e = this._freezeTarget;
+		e && e.style.setProperty(n, `${e.offsetWidth}px`);
+	}
+	_releaseInlineSize() {
+		var e;
+		(e = this._freezeTarget) == null || e.style.removeProperty(n);
+	}
+};
+//#endregion
+export { r as PendingController };
+
+//# sourceMappingURL=pending-controller.js.map

package/dist/controllers/pending-controller/src/pending-controller.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pending-controller.js","names":[],"sources":["../../../../controllers/pending-controller/src/pending-controller.ts"],"sourcesContent":["/**\n * Copyright 2026 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */\n\nimport type { ReactiveController, ReactiveElement } from 'lit';\n\nimport {\n  type PendingSpinnerResult,\n  renderPendingSpinner,\n} from '../../../directives/pending-spinner/index.js';\n\n// ─────────────────────────\n//     TYPES\n// ─────────────────────────\n\n/** Minimum interface required from any element that hosts a {@link PendingController}. */\nexport interface PendingControllerHost extends ReactiveElement {\n  /** Whether the host is in a pending (busy) state. */\n  pending: boolean;\n\n  /**\n   * Optional explicit accessible label used during the pending state. When\n   * omitted, the controller derives a busy label from\n   * {@link PendingControllerOptions.resolveAccessibleName}.\n   */\n  pendingLabel?: string;\n}\n\n/** Configuration options for {@link PendingController}. */\nexport interface PendingControllerOptions {\n  /**\n   * Milliseconds to wait after `pending` becomes true before activating the\n   * pending visual, so the host does not flash to its busy appearance for\n   * operations that complete quickly. Defaults to `1000`.\n   */\n  delay?: number;\n\n  /**\n   * CSS selector, resolved within the host's `renderRoot`, for the element\n   * whose inline size should be frozen while pending (via\n   * `--swc-pending-inline-size`) so the host does not resize when its label or\n   * icon is hidden. Defaults to `'button'`. Pass `null` to skip the freeze.\n   */\n  targetSelector?: string | null;\n\n  /**\n   * Returns the host's non-busy accessible name, used to derive the default\n   * busy label (`\"<name>, busy\"`). Keeps the controller decoupled from how the\n   * host resolves its own name.\n   */\n  resolveAccessibleName?: () => string | null;\n}\n\nconst DEFAULT_DELAY = 1000;\n\n/**\n * Custom property the controller sets on the freeze target to lock its measured\n * inline size while pending. Consumers apply it via `inline-size: var(...)`.\n */\nconst INLINE_SIZE_PROPERTY = '--swc-pending-inline-size';\n\n// ─────────────────────────\n//     CONTROLLER\n// ─────────────────────────\n\n/**\n * A Lit {@link ReactiveController} that manages the pending (busy) *state* of a\n * host element: the delayed visual activation, freezing the host's inline size\n * while busy, and deriving the pending accessible name. Rendering is handled\n * separately by the `renderPendingSpinner` directive\n * (`@adobe/spectrum-wc-core/directives/pending-spinner`); wiring (the\n * `pending` / `pending-label` properties and click suppression) is handled by\n * `PendingMixin` (`@adobe/spectrum-wc-core/mixins`).\n *\n * The accessible name and `aria-disabled` are applied by the host's own\n * template, keyed off `host.pending` for an immediate (non-delayed) response;\n * this controller exposes {@link getPendingAccessibleName} for the host to read.\n *\n * @example\n * ```ts\n * const pendingController = new PendingController(this, {\n *   resolveAccessibleName: () => this.textContent?.trim() || null,\n * });\n * // in render(): class=${classMap({ active: pendingController.pendingActive })}\n * ```\n */\nexport class PendingController implements ReactiveController {\n  private readonly _host: PendingControllerHost;\n  private readonly _delay: number;\n  private readonly _targetSelector: string | null;\n  private readonly _resolveAccessibleName: () => string | null;\n\n  private _timer: ReturnType<typeof setTimeout> | null = null;\n\n  /** Tracks the last-seen `pending` value so transitions can be detected in `hostUpdate`. */\n  private _wasPending = false;\n\n  /**\n   * Whether the pending visual is currently active. Becomes `true` only after\n   * the configured delay so the host does not flash to its busy appearance for\n   * operations that complete quickly. Read this from the host's `render`.\n   */\n  public get pendingActive(): boolean {\n    return this._pendingActive;\n  }\n  private _pendingActive = false;\n\n  constructor(\n    host: PendingControllerHost,\n    options: PendingControllerOptions = {}\n  ) {\n    this._host = host;\n    this._delay = options.delay ?? DEFAULT_DELAY;\n    this._targetSelector =\n      options.targetSelector === undefined ? 'button' : options.targetSelector;\n    this._resolveAccessibleName = options.resolveAccessibleName ?? (() => null);\n    host.addController(this);\n  }\n\n  // ─────────────────────────\n  //     PUBLIC API\n  // ─────────────────────────\n\n  /**\n   * Derives the pending-state accessible label. Prefers an explicit\n   * `pendingLabel`, then the resolved non-busy name plus a \", busy\" suffix,\n   * then a fixed \"Busy\" fallback.\n   */\n  public getPendingAccessibleName(): string {\n    if (this._host.pendingLabel) {\n      return this._host.pendingLabel;\n    }\n    const resolvedName = this._resolveAccessibleName();\n    return resolvedName ? `${resolvedName}, busy` : 'Busy';\n  }\n\n  /**\n   * Renders the pending spinner for the controller's current state via the\n   * `renderPendingSpinner` directive. Exposed here so a host gets the indicator\n   * straight from the controller, without importing the directive separately.\n   * Returns `nothing` while the host is not pending.\n   */\n  public renderPendingState(): PendingSpinnerResult {\n    return renderPendingSpinner(this._host.pending, this._pendingActive);\n  }\n\n  // ─────────────────────────\n  //     LIFECYCLE\n  // ─────────────────────────\n\n  public hostConnected(): void {\n    // Lit does not schedule an update on reconnect, so `hostUpdate` would not\n    // restart the delay timer for an element that reconnects while still\n    // pending. Re-arm it here. Setting `_wasPending` first prevents a later\n    // `hostUpdate` from starting a second timer.\n    if (this._host.pending && !this._wasPending) {\n      this._wasPending = true;\n      this._activateAfterDelay();\n    }\n  }\n\n  public hostUpdate(): void {\n    if (this._host.pending === this._wasPending) {\n      return;\n    }\n    this._wasPending = this._host.pending;\n    if (this._host.pending) {\n      this._activateAfterDelay();\n    } else {\n      this._deactivate();\n    }\n  }\n\n  public hostDisconnected(): void {\n    this._clearTimer();\n    this._wasPending = false;\n    this._pendingActive = false;\n  }\n\n  // ─────────────────────────\n  //     IMPLEMENTATION\n  // ─────────────────────────\n\n  private _activateAfterDelay(): void {\n    this._timer = setTimeout(() => {\n      this._timer = null;\n      // Guard against `pending` flipping back to false after the timer fired\n      // but before this callback ran.\n      if (!this._host.pending) {\n        return;\n      }\n      this._freezeInlineSize();\n      this._pendingActive = true;\n      this._host.requestUpdate();\n    }, this._delay);\n  }\n\n  private _deactivate(): void {\n    this._clearTimer();\n    this._releaseInlineSize();\n    if (this._pendingActive) {\n      this._pendingActive = false;\n      this._host.requestUpdate();\n    }\n  }\n\n  private _clearTimer(): void {\n    if (this._timer !== null) {\n      clearTimeout(this._timer);\n      this._timer = null;\n    }\n  }\n\n  private get _freezeTarget(): HTMLElement | null {\n    if (!this._targetSelector) {\n      return null;\n    }\n    return this._host.renderRoot.querySelector<HTMLElement>(\n      this._targetSelector\n    );\n  }\n\n  private _freezeInlineSize(): void {\n    const target = this._freezeTarget;\n    if (target) {\n      target.style.setProperty(INLINE_SIZE_PROPERTY, `${target.offsetWidth}px`);\n    }\n  }\n\n  private _releaseInlineSize(): void {\n    this._freezeTarget?.style.removeProperty(INLINE_SIZE_PROPERTY);\n  }\n}\n"],"mappings":";;;AA6DA,IAAM,IAAgB,KAMhB,IAAuB,6BA2BhB,IAAb,MAA6D;CAgB3D,IAAW,gBAAyB;AAClC,SAAO,KAAK;;CAId,YACE,GACA,IAAoC,EAAE,EACtC;;AAMA,gBAxBqD,yBAGjC,0BAUG,IAMvB,KAAK,QAAQ,GACb,KAAK,UAAA,IAAS,EAAQ,UAAA,OAAS,IAAT,GACtB,KAAK,kBACH,EAAQ,mBAAmB,KAAA,IAAY,WAAW,EAAQ,gBAC5D,KAAK,0BAAA,IAAyB,EAAQ,0BAAA,cAAgC,QAAhC,GACtC,EAAK,cAAc,KAAK;;CAY1B,2BAA0C;AACxC,MAAI,KAAK,MAAM,aACb,QAAO,KAAK,MAAM;EAEpB,IAAM,IAAe,KAAK,wBAAwB;AAClD,SAAO,IAAe,GAAG,EAAa,UAAU;;CASlD,qBAAkD;AAChD,SAAO,EAAqB,KAAK,MAAM,SAAS,KAAK,eAAe;;CAOtE,gBAA6B;AAK3B,EAAI,KAAK,MAAM,WAAW,CAAC,KAAK,gBAC9B,KAAK,cAAc,IACnB,KAAK,qBAAqB;;CAI9B,aAA0B;AACpB,OAAK,MAAM,YAAY,KAAK,gBAGhC,KAAK,cAAc,KAAK,MAAM,SAC1B,KAAK,MAAM,UACb,KAAK,qBAAqB,GAE1B,KAAK,aAAa;;CAItB,mBAAgC;AAG9B,EAFA,KAAK,aAAa,EAClB,KAAK,cAAc,IACnB,KAAK,iBAAiB;;CAOxB,sBAAoC;AAClC,OAAK,SAAS,iBAAiB;AAC7B,QAAK,SAAS,MAGT,KAAK,MAAM,YAGhB,KAAK,mBAAmB,EACxB,KAAK,iBAAiB,IACtB,KAAK,MAAM,eAAe;KACzB,KAAK,OAAO;;CAGjB,cAA4B;AAG1B,EAFA,KAAK,aAAa,EAClB,KAAK,oBAAoB,EACrB,KAAK,mBACP,KAAK,iBAAiB,IACtB,KAAK,MAAM,eAAe;;CAI9B,cAA4B;AAC1B,EAAI,KAAK,WAAW,SAClB,aAAa,KAAK,OAAO,EACzB,KAAK,SAAS;;CAIlB,IAAY,gBAAoC;AAI9C,SAHK,KAAK,kBAGH,KAAK,MAAM,WAAW,cAC3B,KAAK,gBACN,GAJQ;;CAOX,oBAAkC;EAChC,IAAM,IAAS,KAAK;AACpB,EAAI,KACF,EAAO,MAAM,YAAY,GAAsB,GAAG,EAAO,YAAY,IAAI;;CAI7E,qBAAmC;;AACjC,GAAA,IAAA,KAAK,kBAAA,QAAA,EAAe,MAAM,eAAe,EAAqB"}

package/dist/controllers/placement-controller/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Copyright 2026 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+export { ALL_PLACEMENTS, fromFloatingPlacement, PlacementController, toFloatingPlacement, type Placement, type PlacementOptions, type VirtualTrigger, } from './src/placement-controller.js';

package/dist/controllers/placement-controller/index.js

@@ -0,0 +1,4 @@
+import { fromFloatingPlacement as e, toFloatingPlacement as t } from "./src/placement-conversion.js";
+import { ALL_PLACEMENTS as n } from "./src/types.js";
+import { PlacementController as r } from "./src/placement-controller.js";
+export { n as ALL_PLACEMENTS, r as PlacementController, e as fromFloatingPlacement, t as toFloatingPlacement };

package/dist/controllers/placement-controller/src/fallback-placements.d.ts

@@ -0,0 +1,9 @@
+import { Placement as FloatingPlacement } from '@floating-ui/dom';
+/**
+ * Look up the fallback placement order for Floating UI's `flip` middleware
+ * when the anchor is a `VirtualTrigger`.
+ *
+ * @param placement - Normalized Floating UI placement for the current side.
+ * @returns Ordered list of placements to try when the primary side does not fit.
+ */
+export declare function getFallbackPlacements(placement: FloatingPlacement): FloatingPlacement[];

package/dist/controllers/placement-controller/src/fallback-placements.js

@@ -0,0 +1,71 @@
+//#region controllers/placement-controller/src/fallback-placements.ts
+var e = {
+	left: [
+		"right",
+		"bottom",
+		"top"
+	],
+	"left-start": [
+		"right-start",
+		"bottom",
+		"top"
+	],
+	"left-end": [
+		"right-end",
+		"bottom",
+		"top"
+	],
+	right: [
+		"left",
+		"bottom",
+		"top"
+	],
+	"right-start": [
+		"left-start",
+		"bottom",
+		"top"
+	],
+	"right-end": [
+		"left-end",
+		"bottom",
+		"top"
+	],
+	top: [
+		"bottom",
+		"left",
+		"right"
+	],
+	"top-start": [
+		"bottom-start",
+		"left",
+		"right"
+	],
+	"top-end": [
+		"bottom-end",
+		"left",
+		"right"
+	],
+	bottom: [
+		"top",
+		"left",
+		"right"
+	],
+	"bottom-start": [
+		"top-start",
+		"left",
+		"right"
+	],
+	"bottom-end": [
+		"top-end",
+		"left",
+		"right"
+	]
+};
+function t(t) {
+	var n;
+	return (n = e[t]) == null ? [t] : n;
+}
+//#endregion
+export { t as getFallbackPlacements };
+
+//# sourceMappingURL=fallback-placements.js.map

package/dist/controllers/placement-controller/src/fallback-placements.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fallback-placements.js","names":[],"sources":["../../../../controllers/placement-controller/src/fallback-placements.ts"],"sourcesContent":["/**\n * Copyright 2026 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */\n\nimport type { Placement as FloatingPlacement } from '@floating-ui/dom';\n\nconst FALLBACKS: Record<FloatingPlacement, FloatingPlacement[]> = {\n  left: ['right', 'bottom', 'top'],\n  'left-start': ['right-start', 'bottom', 'top'],\n  'left-end': ['right-end', 'bottom', 'top'],\n  right: ['left', 'bottom', 'top'],\n  'right-start': ['left-start', 'bottom', 'top'],\n  'right-end': ['left-end', 'bottom', 'top'],\n  top: ['bottom', 'left', 'right'],\n  'top-start': ['bottom-start', 'left', 'right'],\n  'top-end': ['bottom-end', 'left', 'right'],\n  bottom: ['top', 'left', 'right'],\n  'bottom-start': ['top-start', 'left', 'right'],\n  'bottom-end': ['top-end', 'left', 'right'],\n};\n\n/**\n * Look up the fallback placement order for Floating UI's `flip` middleware\n * when the anchor is a `VirtualTrigger`.\n *\n * @param placement - Normalized Floating UI placement for the current side.\n * @returns Ordered list of placements to try when the primary side does not fit.\n */\nexport function getFallbackPlacements(\n  placement: FloatingPlacement\n): FloatingPlacement[] {\n  return FALLBACKS[placement] ?? [placement];\n}\n"],"mappings":";AAcA,IAAM,IAA4D;CAChE,MAAM;EAAC;EAAS;EAAU;EAAM;CAChC,cAAc;EAAC;EAAe;EAAU;EAAM;CAC9C,YAAY;EAAC;EAAa;EAAU;EAAM;CAC1C,OAAO;EAAC;EAAQ;EAAU;EAAM;CAChC,eAAe;EAAC;EAAc;EAAU;EAAM;CAC9C,aAAa;EAAC;EAAY;EAAU;EAAM;CAC1C,KAAK;EAAC;EAAU;EAAQ;EAAQ;CAChC,aAAa;EAAC;EAAgB;EAAQ;EAAQ;CAC9C,WAAW;EAAC;EAAc;EAAQ;EAAQ;CAC1C,QAAQ;EAAC;EAAO;EAAQ;EAAQ;CAChC,gBAAgB;EAAC;EAAa;EAAQ;EAAQ;CAC9C,cAAc;EAAC;EAAW;EAAQ;EAAQ;CAC3C;AASD,SAAgB,EACd,GACqB;;AACrB,SAAA,IAAO,EAAU,OAAA,OAAc,CAAC,EAAU,GAAzB"}

package/dist/controllers/placement-controller/src/placement-controller.d.ts

@@ -0,0 +1,152 @@
+import { ReactiveController, ReactiveControllerHost } from 'lit';
+import { Placement, PlacementOptions, VirtualTrigger } from './types.js';
+/**
+ * **PlacementController** — Lit reactive controller that positions a floating
+ * element relative to a trigger using [Floating UI](https://floating-ui.com/)
+ * (`computePosition` + `autoUpdate`).
+ *
+ * Hyphenated placements are accepted on the public API. Logical sides
+ * (`start`, `end`) resolve to physical sides against the trigger's computed
+ * writing direction (`start` is the left in LTR, the right in RTL), so the
+ * panel lands on the correct side. Logical alignment suffixes (`bottom-start`)
+ * are left for Floating UI's own RTL handling; the consumer's CSS still owns
+ * direction-aware styling such as tip orientation. A `dir` change on the
+ * document root or the trigger's nearest `[dir]` ancestor recomputes
+ * placement, so runtime LTR/RTL flips re-resolve correctly.
+ *
+ * ### Available-space custom properties
+ *
+ * The `size` middleware does **not** write `max-width` / `max-height` on the
+ * floating element — an inline max-size would override the consuming
+ * component's intended CSS max-size. Instead it exposes the space available to
+ * the trigger as two custom properties on the floating element, refreshed on
+ * every compute. The caller removes them after any exit transition completes
+ * (clearing them in `stop()` would snap the floating element's size
+ * mid-animation):
+ *
+ * - `--swc-placement-available-width` — usable inline space, in px.
+ * - `--swc-placement-available-height` — usable block space, in px (floored to
+ *   a minimum so a cramped trigger still yields a usable panel).
+ *
+ * Only components positioned by this controller receive these properties.
+ * Such a component opts into viewport-bounded sizing by combining them with
+ * its own intended size via `min()`, with a fallback for when the controller
+ * is not active:
+ *
+ * ```css
+ * .floating {
+ *   box-sizing: border-box;
+ *   max-inline-size: min(var(--intended-width), var(--swc-placement-available-width, 100vi));
+ *   max-block-size: min(var(--intended-height), var(--swc-placement-available-height, 90vb));
+ *   overflow: auto;
+ * }
+ * ```
+ *
+ * The fallbacks use logical viewport units (`vi` / `vb`); `90vb` leaves a small
+ * buffer so the trigger isn't scrolled out of view. `box-sizing: border-box` is
+ * required so the available-space values account for the element's own padding
+ * and border rather than overflowing past them. Pair `max-block-size` with
+ * `overflow: auto` so the panel scrolls when the block space is constrained
+ * (read `isConstrained` to detect that state).
+ *
+ * @example
+ * ```typescript
+ * this.placement.start(this.trigger, this.dialog, {
+ *   placement: 'bottom-start',
+ *   offset: 0,
+ *   onPlacementChange: (p) => {
+ *     this.actualPlacement = p;
+ *   },
+ * });
+ * ```
+ */
+export declare class PlacementController implements ReactiveController {
+    private cleanup?;
+    private session;
+    /**
+     * The computed placement after `flip` reorients (hyphenated). `null` when
+     * `stop` has been called.
+     *
+     * Set synchronously to the requested `PlacementOptions.placement`
+     * (or `DEFAULT_PLACEMENT`) when `start` is called, then refreshed on every
+     * successful `computePlacement` pass. `PlacementOptions.onPlacementChange`
+     * fires when this value changes (and once after the first compute), so
+     * consumers can mirror it in a single callback without also reading it
+     * synchronously after `start()`.
+     */
+    actualPlacement: Placement | null;
+    /**
+     * Whether the floating content would overflow the available space
+     * below/above the trigger on the last compute. `true` when the content is
+     * taller than the available height, so a consumer applying
+     * `max-block-size: min(…, var(--swc-placement-available-height))` will be
+     * clamping (and should enable scrolling). Informational only — the
+     * controller no longer writes `max-height` itself.
+     */
+    isConstrained: boolean;
+    /**
+     * Natural floating-element height from the first un-constrained compute,
+     * used as the baseline that determines whether subsequent computes are
+     * clamping content. Cleared on `stop()`.
+     */
+    private initialHeight?;
+    /**
+     * Last placement handed to `onPlacementChange`. `actualPlacement` is refreshed
+     * on every compute, but the callback fires only when the computed placement
+     * actually changes — `autoUpdate` ticks that recompute the same placement do
+     * not re-notify consumers. `undefined` until the first compute (and after
+     * `stop`), so the first compute of a session always notifies.
+     */
+    private lastEmittedPlacement?;
+    /**
+     * Registers this controller on `host` via `addController`.
+     *
+     * @param host - Reactive element that owns the floating surface lifecycle.
+     */
+    constructor(host: ReactiveControllerHost);
+    /**
+     * Begin positioning `floating` relative to `trigger`.
+     *
+     * Tears down any prior session, stores the new options, and subscribes to
+     * Floating UI `autoUpdate` so placement stays correct on scroll and resize.
+     *
+     * @param trigger - Anchor element or `VirtualTrigger`.
+     * @param floating - Element to position (`position: fixed` or top-layer).
+     * @param options - `PlacementOptions`; omitted properties use defaults.
+     */
+    start(trigger: HTMLElement | VirtualTrigger, floating: HTMLElement, options?: PlacementOptions): void;
+    /**
+     * Stop positioning: tear down `autoUpdate`, clear `actualPlacement` and
+     * `isConstrained`. Inline style cleanup — including `translate`, `top`,
+     * `left`, and `--swc-placement-available-*` — is left to the caller so
+     * exit transitions can complete before those properties are removed.
+     * Safe to call multiple times.
+     */
+    stop(): void;
+    /**
+     * Force one recomputation outside the `autoUpdate` callback.
+     *
+     * Use when floating content reflows internally or when a
+     * `VirtualTrigger` moves without a DOM mutation. No-op if
+     * `start` has not been called.
+     */
+    recompute(): void;
+    /**
+     * Lit lifecycle hook — tears down positioning when the host disconnects.
+     *
+     * @internal
+     */
+    hostDisconnected(): void;
+    /**
+     * Run Floating UI `computePosition`, apply the result to the floating element,
+     * and update `actualPlacement` when `flip` reorients.
+     *
+     * Waits for web fonts and a WebKit animation frame before measuring. Skips
+     * when the floating element has zero dimensions. Aborts if `stop` or a
+     * new `start` call replaces the active session while awaiting async work.
+     */
+    private computePlacement;
+}
+export type { Placement, PlacementOptions, VirtualTrigger } from './types.js';
+export { ALL_PLACEMENTS } from './types.js';
+export { fromFloatingPlacement, toFloatingPlacement, } from './placement-conversion.js';

package/dist/controllers/placement-controller/src/placement-controller.js

@@ -0,0 +1,129 @@
+import { getFallbackPlacements as e } from "./fallback-placements.js";
+import { fromFloatingPlacement as t, toFloatingPlacement as n } from "./placement-conversion.js";
+import "./types.js";
+import { arrow as r, autoUpdate as i, computePosition as a, flip as o, offset as s, shift as c, size as l } from "@floating-ui/dom";
+//#region controllers/placement-controller/src/placement-controller.ts
+var u = 100, d = "bottom", f = 0, p = 0, m = 8, h = !0, g = 8;
+function _(e) {
+	let t = window.devicePixelRatio || 1;
+	return Math.round(e * t) / t;
+}
+function v() {
+	if (typeof navigator > "u") return !1;
+	let e = navigator.userAgent;
+	return /AppleWebKit/.test(e) && !/Chrome/.test(e);
+}
+var y = class {
+	constructor(e) {
+		this.session = null, this.actualPlacement = null, this.isConstrained = !1, e.addController(this);
+	}
+	start(e, t, n = {}) {
+		var r;
+		this.stop();
+		let a = {
+			trigger: e,
+			floating: t,
+			options: n,
+			isWebKit: v()
+		};
+		this.session = a, this.actualPlacement = (r = n.placement) == null ? d : r;
+		let o = i(e, t, () => {
+			this.computePlacement();
+		}), s, c = window.visualViewport;
+		if (a.isWebKit && c) {
+			let e = 0, t = !1, n = () => {
+				t || e || (e = requestAnimationFrame(() => {
+					e = 0, !t && this.computePlacement();
+				}));
+			};
+			c.addEventListener("resize", n, { passive: !0 }), c.addEventListener("scroll", n, { passive: !0 }), s = () => {
+				t = !0, e && (cancelAnimationFrame(e), e = 0), c.removeEventListener("resize", n), c.removeEventListener("scroll", n);
+			};
+		}
+		let l = e instanceof HTMLElement ? e : t, u = new MutationObserver(() => {
+			this.computePlacement();
+		}), f = (e) => {
+			e && u.observe(e, {
+				attributes: !0,
+				attributeFilter: ["dir"]
+			});
+		};
+		f(l.ownerDocument.documentElement), f(l.closest("[dir]")), this.cleanup = () => {
+			u.disconnect(), s == null || s(), o();
+		};
+	}
+	stop() {
+		var e;
+		(e = this.cleanup) == null || e.call(this), this.cleanup = void 0, this.session = null, this.actualPlacement = null, this.isConstrained = !1, this.initialHeight = void 0, this.lastEmittedPlacement = void 0;
+	}
+	recompute() {
+		this.computePlacement();
+	}
+	hostDisconnected() {
+		this.stop();
+	}
+	async computePlacement() {
+		var i, v, y, b, x, S;
+		let C = this.session;
+		if (!C) return;
+		let { trigger: w, floating: T, options: E } = C;
+		if (document.fonts && await document.fonts.ready, this.session !== C || C.isWebKit && (await new Promise((e) => requestAnimationFrame(() => e())), this.session !== C)) return;
+		let D = T.getBoundingClientRect();
+		if (D.width === 0 && D.height === 0) return;
+		let O = (i = E.placement) == null ? d : i, k = w instanceof HTMLElement ? w : T, A = n(O, getComputedStyle(k).direction === "rtl" ? "rtl" : "ltr"), j = (v = E.containerPadding) == null ? m : v, M = (y = E.shouldFlip) == null ? h : y, N = (b = E.offset) == null ? f : b, P = (x = E.crossOffset) == null ? p : x, F = M && (w instanceof HTMLElement ? o({
+			padding: j,
+			fallbackStrategy: "bestFit"
+		}) : o({
+			padding: j,
+			fallbackPlacements: e(A),
+			fallbackStrategy: "bestFit"
+		})), I = E.tipElement, L = (S = E.tipPadding) == null ? g : S, { x: R, y: z, placement: B, middlewareData: V } = await a(w, T, {
+			placement: A,
+			middleware: [
+				s({
+					mainAxis: N,
+					crossAxis: P
+				}),
+				c({ padding: j }),
+				F,
+				l({
+					padding: j,
+					apply: ({ availableHeight: e, availableWidth: t, rects: n }) => {
+						var r;
+						if (this.session !== C) return;
+						let i = Math.max(u, Math.floor(e)), a = n.floating.height;
+						this.initialHeight = this.isConstrained ? (r = this.initialHeight) == null ? a : r : a, this.isConstrained = a < this.initialHeight || i <= a, T.style.setProperty("--swc-placement-available-width", `${Math.floor(t)}px`), T.style.setProperty("--swc-placement-available-height", `${i}px`);
+					}
+				}),
+				I ? r({
+					element: I,
+					padding: L
+				}) : null
+			],
+			strategy: "absolute"
+		});
+		if (this.session !== C) return;
+		let H = R, U = z, W = window.visualViewport;
+		if (W && C.isWebKit && (H -= W.offsetLeft, U -= W.offsetTop), Object.assign(T.style, {
+			top: "0px",
+			left: "0px",
+			translate: `${_(H)}px ${_(U)}px`
+		}), I && V.arrow) {
+			let { x: e, y: t } = V.arrow;
+			Object.assign(I.style, {
+				top: B.startsWith("right") || B.startsWith("left") ? "0px" : "",
+				left: B.startsWith("bottom") || B.startsWith("top") ? "0px" : "",
+				translate: `${_(e == null ? 0 : e)}px ${_(t == null ? 0 : t)}px`
+			});
+		}
+		let G = t(B);
+		if (this.actualPlacement = G, G !== this.lastEmittedPlacement) {
+			var K;
+			this.lastEmittedPlacement = G, (K = E.onPlacementChange) == null || K.call(E, G);
+		}
+	}
+};
+//#endregion
+export { y as PlacementController };
+
+//# sourceMappingURL=placement-controller.js.map

package/dist/controllers/placement-controller/src/placement-controller.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"placement-controller.js","names":[],"sources":["../../../../controllers/placement-controller/src/placement-controller.ts"],"sourcesContent":["/**\n * Copyright 2026 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */\n\nimport type { ReactiveController, ReactiveControllerHost } from 'lit';\nimport {\n  arrow,\n  autoUpdate,\n  computePosition,\n  flip,\n  offset,\n  shift,\n  size,\n} from '@floating-ui/dom';\n\nimport { getFallbackPlacements } from './fallback-placements.js';\nimport {\n  fromFloatingPlacement,\n  toFloatingPlacement,\n} from './placement-conversion.js';\nimport type { Placement, PlacementOptions, VirtualTrigger } from './types.js';\n\n/** Minimum height the `size` middleware will allow the floating content to clamp to. */\nconst MIN_FLOATING_HEIGHT = 100;\n\nconst DEFAULT_PLACEMENT: Placement = 'bottom';\n// Neutral default — controller does not impose a trigger gap. Consuming\n// components set their own pattern-specific default.\nconst DEFAULT_OFFSET = 0;\nconst DEFAULT_CROSS_OFFSET = 0;\nconst DEFAULT_CONTAINER_PADDING = 8;\nconst DEFAULT_SHOULD_FLIP = true;\nconst DEFAULT_TIP_PADDING = 8;\n\n/**\n * Round a pixel value to the nearest device-pixel boundary so translated\n * coordinates stay sharp on high-DPR displays.\n *\n * @param num - Coordinate in CSS pixels.\n * @returns The value rounded to the nearest physical pixel.\n */\nfunction roundByDPR(num: number): number {\n  const dpr = window.devicePixelRatio || 1;\n  return Math.round(num * dpr) / dpr;\n}\n\n/**\n * Detect WebKit-based browsers (Safari, iOS) where `visualViewport` offset\n * correction is required after `computePosition`.\n *\n * @returns True when the runtime appears to be WebKit without Chrome.\n */\nfunction isWebKit(): boolean {\n  if (typeof navigator === 'undefined') {\n    return false;\n  }\n  const ua = navigator.userAgent;\n  return /AppleWebKit/.test(ua) && !/Chrome/.test(ua);\n}\n\ntype ActiveSession = {\n  trigger: HTMLElement | VirtualTrigger;\n  floating: HTMLElement;\n  options: PlacementOptions;\n\n  /**\n   * Cached `isWebKit()` result so `computePlacement` doesn't run a UA\n   * regex per `autoUpdate` tick.\n   */\n  isWebKit: boolean;\n};\n\n/**\n * **PlacementController** — Lit reactive controller that positions a floating\n * element relative to a trigger using [Floating UI](https://floating-ui.com/)\n * (`computePosition` + `autoUpdate`).\n *\n * Hyphenated placements are accepted on the public API. Logical sides\n * (`start`, `end`) resolve to physical sides against the trigger's computed\n * writing direction (`start` is the left in LTR, the right in RTL), so the\n * panel lands on the correct side. Logical alignment suffixes (`bottom-start`)\n * are left for Floating UI's own RTL handling; the consumer's CSS still owns\n * direction-aware styling such as tip orientation. A `dir` change on the\n * document root or the trigger's nearest `[dir]` ancestor recomputes\n * placement, so runtime LTR/RTL flips re-resolve correctly.\n *\n * ### Available-space custom properties\n *\n * The `size` middleware does **not** write `max-width` / `max-height` on the\n * floating element — an inline max-size would override the consuming\n * component's intended CSS max-size. Instead it exposes the space available to\n * the trigger as two custom properties on the floating element, refreshed on\n * every compute. The caller removes them after any exit transition completes\n * (clearing them in `stop()` would snap the floating element's size\n * mid-animation):\n *\n * - `--swc-placement-available-width` — usable inline space, in px.\n * - `--swc-placement-available-height` — usable block space, in px (floored to\n *   a minimum so a cramped trigger still yields a usable panel).\n *\n * Only components positioned by this controller receive these properties.\n * Such a component opts into viewport-bounded sizing by combining them with\n * its own intended size via `min()`, with a fallback for when the controller\n * is not active:\n *\n * ```css\n * .floating {\n *   box-sizing: border-box;\n *   max-inline-size: min(var(--intended-width), var(--swc-placement-available-width, 100vi));\n *   max-block-size: min(var(--intended-height), var(--swc-placement-available-height, 90vb));\n *   overflow: auto;\n * }\n * ```\n *\n * The fallbacks use logical viewport units (`vi` / `vb`); `90vb` leaves a small\n * buffer so the trigger isn't scrolled out of view. `box-sizing: border-box` is\n * required so the available-space values account for the element's own padding\n * and border rather than overflowing past them. Pair `max-block-size` with\n * `overflow: auto` so the panel scrolls when the block space is constrained\n * (read `isConstrained` to detect that state).\n *\n * @example\n * ```typescript\n * this.placement.start(this.trigger, this.dialog, {\n *   placement: 'bottom-start',\n *   offset: 0,\n *   onPlacementChange: (p) => {\n *     this.actualPlacement = p;\n *   },\n * });\n * ```\n */\nexport class PlacementController implements ReactiveController {\n  private cleanup?: () => void;\n  private session: ActiveSession | null = null;\n\n  /**\n   * The computed placement after `flip` reorients (hyphenated). `null` when\n   * `stop` has been called.\n   *\n   * Set synchronously to the requested `PlacementOptions.placement`\n   * (or `DEFAULT_PLACEMENT`) when `start` is called, then refreshed on every\n   * successful `computePlacement` pass. `PlacementOptions.onPlacementChange`\n   * fires when this value changes (and once after the first compute), so\n   * consumers can mirror it in a single callback without also reading it\n   * synchronously after `start()`.\n   */\n  public actualPlacement: Placement | null = null;\n\n  /**\n   * Whether the floating content would overflow the available space\n   * below/above the trigger on the last compute. `true` when the content is\n   * taller than the available height, so a consumer applying\n   * `max-block-size: min(…, var(--swc-placement-available-height))` will be\n   * clamping (and should enable scrolling). Informational only — the\n   * controller no longer writes `max-height` itself.\n   */\n  public isConstrained = false;\n\n  /**\n   * Natural floating-element height from the first un-constrained compute,\n   * used as the baseline that determines whether subsequent computes are\n   * clamping content. Cleared on `stop()`.\n   */\n  private initialHeight?: number;\n\n  /**\n   * Last placement handed to `onPlacementChange`. `actualPlacement` is refreshed\n   * on every compute, but the callback fires only when the computed placement\n   * actually changes — `autoUpdate` ticks that recompute the same placement do\n   * not re-notify consumers. `undefined` until the first compute (and after\n   * `stop`), so the first compute of a session always notifies.\n   */\n  private lastEmittedPlacement?: Placement;\n\n  /**\n   * Registers this controller on `host` via `addController`.\n   *\n   * @param host - Reactive element that owns the floating surface lifecycle.\n   */\n  constructor(host: ReactiveControllerHost) {\n    host.addController(this);\n  }\n\n  /**\n   * Begin positioning `floating` relative to `trigger`.\n   *\n   * Tears down any prior session, stores the new options, and subscribes to\n   * Floating UI `autoUpdate` so placement stays correct on scroll and resize.\n   *\n   * @param trigger - Anchor element or `VirtualTrigger`.\n   * @param floating - Element to position (`position: fixed` or top-layer).\n   * @param options - `PlacementOptions`; omitted properties use defaults.\n   */\n  public start(\n    trigger: HTMLElement | VirtualTrigger,\n    floating: HTMLElement,\n    options: PlacementOptions = {}\n  ) {\n    this.stop();\n    const session: ActiveSession = {\n      trigger,\n      floating,\n      options,\n      isWebKit: isWebKit(),\n    };\n    this.session = session;\n    this.actualPlacement = options.placement ?? DEFAULT_PLACEMENT;\n\n    // Single `autoUpdate` channel — receives `ancestorScroll`,\n    // `ancestorResize`, `elementResize`, and `layoutShift` by default. The\n    // controller owns geometry only and just repositions on every event;\n    // the caller decides whether ancestor scroll should close the surface.\n    const autoUpdateCleanup = autoUpdate(trigger, floating, () => {\n      this.computePlacement();\n    });\n\n    // iOS WebKit `visualViewport` recompute channel. Floating UI's\n    // `autoUpdate` doesn't observe `window.visualViewport`, so without this\n    // an open floating element can drift away from its trigger on WebKit\n    // (iOS Safari, WKWebView, desktop Safari while pinch-zoomed) when the\n    // URL bar shows/hides, the virtual keyboard opens, etc. — until the\n    // next event `autoUpdate` does observe. Listeners are passive and\n    // rAF-coalesced so a burst of resize/scroll events compresses to one\n    // compute per frame. The matching `visualViewport.offset*` correction\n    // lives in `computePlacement`.\n    let visualViewportCleanup: (() => void) | undefined;\n    const visualViewport = window.visualViewport;\n    if (session.isWebKit && visualViewport) {\n      let rafId = 0;\n      let cancelled = false;\n      const onViewportChange = () => {\n        if (cancelled || rafId) {\n          return;\n        }\n        rafId = requestAnimationFrame(() => {\n          rafId = 0;\n          if (cancelled) {\n            return;\n          }\n          this.computePlacement();\n        });\n      };\n      visualViewport.addEventListener('resize', onViewportChange, {\n        passive: true,\n      });\n      visualViewport.addEventListener('scroll', onViewportChange, {\n        passive: true,\n      });\n      visualViewportCleanup = () => {\n        cancelled = true;\n        if (rafId) {\n          cancelAnimationFrame(rafId);\n          rafId = 0;\n        }\n        visualViewport.removeEventListener('resize', onViewportChange);\n        visualViewport.removeEventListener('scroll', onViewportChange);\n      };\n    }\n\n    // Direction channel — `autoUpdate` watches layout, not the `dir` attribute,\n    // so a runtime LTR/RTL flip (or a `dir` applied after the first compute)\n    // wouldn't re-resolve logical `start` / `end` sides. Observe `dir` on the\n    // document root and on the trigger's nearest `[dir]` ancestor, and\n    // recompute when it changes.\n    const directionSource = trigger instanceof HTMLElement ? trigger : floating;\n    const directionObserver = new MutationObserver(() => {\n      this.computePlacement();\n    });\n    const observeDir = (node: Element | null | undefined) => {\n      if (node) {\n        directionObserver.observe(node, {\n          attributes: true,\n          attributeFilter: ['dir'],\n        });\n      }\n    };\n    observeDir(directionSource.ownerDocument.documentElement);\n    observeDir(directionSource.closest('[dir]'));\n\n    this.cleanup = () => {\n      directionObserver.disconnect();\n      visualViewportCleanup?.();\n      autoUpdateCleanup();\n    };\n  }\n\n  /**\n   * Stop positioning: tear down `autoUpdate`, clear `actualPlacement` and\n   * `isConstrained`. Inline style cleanup — including `translate`, `top`,\n   * `left`, and `--swc-placement-available-*` — is left to the caller so\n   * exit transitions can complete before those properties are removed.\n   * Safe to call multiple times.\n   */\n  public stop() {\n    this.cleanup?.();\n    this.cleanup = undefined;\n    this.session = null;\n    this.actualPlacement = null;\n    this.isConstrained = false;\n    this.initialHeight = undefined;\n    this.lastEmittedPlacement = undefined;\n  }\n\n  /**\n   * Force one recomputation outside the `autoUpdate` callback.\n   *\n   * Use when floating content reflows internally or when a\n   * `VirtualTrigger` moves without a DOM mutation. No-op if\n   * `start` has not been called.\n   */\n  public recompute() {\n    this.computePlacement();\n  }\n\n  /**\n   * Lit lifecycle hook — tears down positioning when the host disconnects.\n   *\n   * @internal\n   */\n  public hostDisconnected() {\n    this.stop();\n  }\n\n  /**\n   * Run Floating UI `computePosition`, apply the result to the floating element,\n   * and update `actualPlacement` when `flip` reorients.\n   *\n   * Waits for web fonts and a WebKit animation frame before measuring. Skips\n   * when the floating element has zero dimensions. Aborts if `stop` or a\n   * new `start` call replaces the active session while awaiting async work.\n   */\n  private async computePlacement(): Promise<void> {\n    const session = this.session;\n    if (!session) {\n      return;\n    }\n\n    const { trigger, floating, options } = session;\n\n    if (document.fonts) {\n      await document.fonts.ready;\n    }\n    if (this.session !== session) {\n      return;\n    }\n\n    if (session.isWebKit) {\n      await new Promise<void>((resolve) =>\n        requestAnimationFrame(() => resolve())\n      );\n      if (this.session !== session) {\n        return;\n      }\n    }\n\n    const floatingRect = floating.getBoundingClientRect();\n    if (floatingRect.width === 0 && floatingRect.height === 0) {\n      return;\n    }\n\n    const requestedPlacement = options.placement ?? DEFAULT_PLACEMENT;\n    // Resolve logical sides (`start` / `end`) against the trigger's writing\n    // direction so RTL positions the panel on the correct physical side. Read\n    // from the trigger (it lives in the consumer's possibly scoped-RTL subtree);\n    // fall back to the floating element for a `VirtualTrigger`.\n    const directionSource = trigger instanceof HTMLElement ? trigger : floating;\n    const direction =\n      getComputedStyle(directionSource).direction === 'rtl' ? 'rtl' : 'ltr';\n    const floatingPlacement = toFloatingPlacement(\n      requestedPlacement,\n      direction\n    );\n    const containerPadding =\n      options.containerPadding ?? DEFAULT_CONTAINER_PADDING;\n    const shouldFlip = options.shouldFlip ?? DEFAULT_SHOULD_FLIP;\n    const mainAxis = options.offset ?? DEFAULT_OFFSET;\n    const crossAxis = options.crossOffset ?? DEFAULT_CROSS_OFFSET;\n\n    const flipMiddleware =\n      shouldFlip &&\n      (!(trigger instanceof HTMLElement)\n        ? flip({\n            padding: containerPadding,\n            fallbackPlacements: getFallbackPlacements(floatingPlacement),\n            fallbackStrategy: 'bestFit',\n          })\n        : flip({\n            padding: containerPadding,\n            fallbackStrategy: 'bestFit',\n          }));\n\n    // Middleware order matches Gen1: offset → shift → flip → size → arrow.\n    // `shift` runs before `flip` so the panel slides along the current\n    // side before any decision to flip; `size` runs after the final\n    // placement is known so it measures the available space accurately;\n    // `arrow` (when a tip element is provided) runs last so it positions\n    // the tip relative to the trigger after every other middleware has\n    // settled.\n    const tipElement = options.tipElement;\n    const tipPadding = options.tipPadding ?? DEFAULT_TIP_PADDING;\n    const middleware = [\n      offset({ mainAxis, crossAxis }),\n      shift({ padding: containerPadding }),\n      flipMiddleware,\n      size({\n        padding: containerPadding,\n        apply: ({ availableHeight, availableWidth, rects }) => {\n          // Ignore a superseded compute: a new `start()` (or `stop()`) may\n          // have replaced the session while this `computePosition` was in\n          // flight, and writing baseline state here would bleed into it.\n          if (this.session !== session) {\n            return;\n          }\n          const maxHeight = Math.max(\n            MIN_FLOATING_HEIGHT,\n            Math.floor(availableHeight)\n          );\n          const actualHeight = rects.floating.height;\n          // Track the natural (un-constrained) height on the first compute\n          // so subsequent computes can detect whether content is currently\n          // being clamped.\n          this.initialHeight = !this.isConstrained\n            ? actualHeight\n            : (this.initialHeight ?? actualHeight);\n          this.isConstrained =\n            actualHeight < this.initialHeight || maxHeight <= actualHeight;\n          // Expose the available space as custom properties rather than writing\n          // `max-width` / `max-height` directly: an inline max-size would\n          // override a component's intended CSS max-size, so instead each\n          // component opts in by combining these with its own value, e.g.\n          // `max-inline-size: min(<intended>, var(--swc-placement-available-width))`.\n          floating.style.setProperty(\n            '--swc-placement-available-width',\n            `${Math.floor(availableWidth)}px`\n          );\n          floating.style.setProperty(\n            '--swc-placement-available-height',\n            `${maxHeight}px`\n          );\n        },\n      }),\n      tipElement ? arrow({ element: tipElement, padding: tipPadding }) : null,\n    ];\n\n    const { x, y, placement, middlewareData } = await computePosition(\n      trigger,\n      floating,\n      {\n        placement: floatingPlacement,\n        middleware,\n        strategy: 'absolute', // Required for correct top-layer element placement\n      }\n    );\n    if (this.session !== session) {\n      return;\n    }\n\n    let translateX = x;\n    let translateY = y;\n    const visualViewport = window.visualViewport;\n    if (visualViewport && session.isWebKit) {\n      translateX -= visualViewport.offsetLeft;\n      translateY -= visualViewport.offsetTop;\n    }\n\n    Object.assign(floating.style, {\n      top: '0px',\n      left: '0px',\n      translate: `${roundByDPR(translateX)}px ${roundByDPR(translateY)}px`,\n    });\n\n    // Position the tip element (Gen1 pattern). Floating UI exposes\n    // either `arrow.x` (top/bottom placements — arrow on a horizontal\n    // edge) or `arrow.y` (left/right placements — arrow on a vertical\n    // edge). Reset whichever inline offset would conflict with the\n    // edge we're on, then write the computed translate.\n    if (tipElement && middlewareData.arrow) {\n      const { x: arrowX, y: arrowY } = middlewareData.arrow;\n      Object.assign(tipElement.style, {\n        top:\n          placement.startsWith('right') || placement.startsWith('left')\n            ? '0px'\n            : '',\n        left:\n          placement.startsWith('bottom') || placement.startsWith('top')\n            ? '0px'\n            : '',\n        translate: `${roundByDPR(arrowX ?? 0)}px ${roundByDPR(arrowY ?? 0)}px`,\n      });\n    }\n\n    const nextPlacement = fromFloatingPlacement(placement);\n    this.actualPlacement = nextPlacement;\n    // Notify on change only: `autoUpdate` recomputes on every scroll/resize\n    // tick, but a consumer wiring `onPlacementChange` to reactive state should\n    // not re-render when the placement is unchanged. The first compute always\n    // fires (`lastEmittedPlacement` starts `undefined`).\n    if (nextPlacement !== this.lastEmittedPlacement) {\n      this.lastEmittedPlacement = nextPlacement;\n      options.onPlacementChange?.(nextPlacement);\n    }\n  }\n}\n\nexport type { Placement, PlacementOptions, VirtualTrigger } from './types.js';\nexport { ALL_PLACEMENTS } from './types.js';\nexport {\n  fromFloatingPlacement,\n  toFloatingPlacement,\n} from './placement-conversion.js';\n"],"mappings":"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"}