@adobe/spectrum-wc-core 2.0.0-beta.2 → 2.0.0-beta.4

package/dist/controllers/slot-presence-controller/src/slot-presence-controller.js

@@ -0,0 +1,44 @@
+//#region controllers/slot-presence-controller/src/slot-presence-controller.ts
+var e = class {
+	constructor(e, t) {
+		this.presenceMap = /* @__PURE__ */ new Map(), this.host = e, this.selectors = Array.isArray(t) ? t : [t], this.host.addController(this), this.observer = new MutationObserver(() => {
+			this.checkPresence();
+		}), this.checkPresence();
+	}
+	get isPresent() {
+		if (this.selectors.length === 1) {
+			var e;
+			return (e = this.presenceMap.get(this.selectors[0])) == null ? !1 : e;
+		}
+		throw Error("Multiple selectors provided to SlotPresenceController — use getPresence(selector) instead.");
+	}
+	getPresence(e) {
+		if (this.presenceMap.has(e)) {
+			var t;
+			return (t = this.presenceMap.get(e)) == null ? !1 : t;
+		}
+		throw Error(`The provided selector \`${e}\` is not being observed.`);
+	}
+	checkPresence() {
+		let e = !1;
+		for (let n of this.selectors) {
+			var t;
+			let r = !!this.host.querySelector(`:scope > ${n}`);
+			((t = this.presenceMap.get(n)) == null ? !1 : t) !== r && (e = !0), this.presenceMap.set(n, r);
+		}
+		e && this.host.requestUpdate();
+	}
+	hostConnected() {
+		this.observer.observe(this.host, {
+			childList: !0,
+			subtree: !0
+		}), this.checkPresence();
+	}
+	hostDisconnected() {
+		this.observer.disconnect();
+	}
+};
+//#endregion
+export { e as SlotPresenceController };
+
+//# sourceMappingURL=slot-presence-controller.js.map

package/dist/controllers/slot-presence-controller/src/slot-presence-controller.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"slot-presence-controller.js","names":[],"sources":["../../../../controllers/slot-presence-controller/src/slot-presence-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\n/**\n * A reactive controller that observes whether slotted content matching\n * given CSS selectors is present in the host's light DOM.\n *\n * Replaces the `ObserveSlotPresence` mixin with a composition-based approach.\n *\n * @example\n * ```typescript\n * class MyComponent extends SpectrumElement {\n *   private slotPresence = new SlotPresenceController(this, '[slot=\"icon\"]');\n *\n *   get hasIcon(): boolean {\n *     return this.slotPresence.isPresent;\n *   }\n * }\n * ```\n *\n * @example\n * ```typescript\n * // Observing multiple selectors\n * class MyComponent extends SpectrumElement {\n *   private slotPresence = new SlotPresenceController(this, [\n *     '[slot=\"icon\"]',\n *     '[slot=\"description\"]',\n *   ]);\n *\n *   get hasIcon(): boolean {\n *     return this.slotPresence.getPresence('[slot=\"icon\"]');\n *   }\n *\n *   get hasDescription(): boolean {\n *     return this.slotPresence.getPresence('[slot=\"description\"]');\n *   }\n * }\n * ```\n */\nexport class SlotPresenceController implements ReactiveController {\n  private host: ReactiveElement;\n  private selectors: string[];\n  private presenceMap = new Map<string, boolean>();\n  private observer: MutationObserver;\n\n  constructor(host: ReactiveElement, selectors: string | string[]) {\n    this.host = host;\n    this.selectors = Array.isArray(selectors) ? selectors : [selectors];\n    this.host.addController(this);\n\n    this.observer = new MutationObserver(() => {\n      this.checkPresence();\n    });\n\n    // Check initial state synchronously\n    this.checkPresence();\n  }\n\n  /**\n   * Whether slotted content is present. Use this when observing a single\n   * selector. Throws if multiple selectors were provided — use\n   * `getPresence(selector)` instead.\n   */\n  get isPresent(): boolean {\n    if (this.selectors.length === 1) {\n      return this.presenceMap.get(this.selectors[0]) ?? false;\n    }\n    throw new Error(\n      'Multiple selectors provided to SlotPresenceController — use getPresence(selector) instead.'\n    );\n  }\n\n  /**\n   * Returns whether content matching the given selector is present.\n   */\n  getPresence(selector: string): boolean {\n    if (this.presenceMap.has(selector)) {\n      return this.presenceMap.get(selector) ?? false;\n    }\n    throw new Error(\n      `The provided selector \\`${selector}\\` is not being observed.`\n    );\n  }\n\n  private checkPresence(): void {\n    let changed = false;\n    for (const selector of this.selectors) {\n      const nextValue = !!this.host.querySelector(`:scope > ${selector}`);\n      const previousValue = this.presenceMap.get(selector) ?? false;\n      if (previousValue !== nextValue) {\n        changed = true;\n      }\n      this.presenceMap.set(selector, nextValue);\n    }\n    if (changed) {\n      // The `ObserveSlotPresence` mixin this controller replaces deferred the\n      // re-render with `this.updateComplete.then(() => this.requestUpdate())`.\n      // The controller requests the update synchronously instead. This is\n      // safe because `checkPresence` only runs from the constructor, the\n      // `MutationObserver` callback, and `hostConnected` — never from inside\n      // the host's own `update()`/`render()` — so there is no re-entrant\n      // update. Lit batches `requestUpdate()` calls into the next microtask,\n      // so multiple presence changes in one tick still coalesce into a single\n      // render. See the controller stories for the behavioral test.\n      this.host.requestUpdate();\n    }\n  }\n\n  hostConnected(): void {\n    this.observer.observe(this.host, {\n      childList: true,\n      subtree: true,\n    });\n    this.checkPresence();\n  }\n\n  hostDisconnected(): void {\n    this.observer.disconnect();\n  }\n}\n"],"mappings":";AAkDA,IAAa,IAAb,MAAkE;CAMhE,YAAY,GAAuB,GAA8B;AAU/D,qCAboB,IAAI,KAAsB,EAI9C,KAAK,OAAO,GACZ,KAAK,YAAY,MAAM,QAAQ,EAAU,GAAG,IAAY,CAAC,EAAU,EACnE,KAAK,KAAK,cAAc,KAAK,EAE7B,KAAK,WAAW,IAAI,uBAAuB;AACzC,QAAK,eAAe;IACpB,EAGF,KAAK,eAAe;;CAQtB,IAAI,YAAqB;AACvB,MAAI,KAAK,UAAU,WAAW,GAAG;;AAC/B,WAAA,IAAO,KAAK,YAAY,IAAI,KAAK,UAAU,GAAG,KAAA,OAAI,KAAJ;;AAEhD,QAAU,MACR,6FACD;;CAMH,YAAY,GAA2B;AACrC,MAAI,KAAK,YAAY,IAAI,EAAS,EAAE;;AAClC,WAAA,IAAO,KAAK,YAAY,IAAI,EAAS,KAAA,OAAI,KAAJ;;AAEvC,QAAU,MACR,2BAA2B,EAAS,2BACrC;;CAGH,gBAA8B;EAC5B,IAAI,IAAU;AACd,OAAK,IAAM,KAAY,KAAK,WAAW;;GACrC,IAAM,IAAY,CAAC,CAAC,KAAK,KAAK,cAAc,YAAY,IAAW;AAKnE,KAHA,IADsB,KAAK,YAAY,IAAI,EAAS,KAAA,OAAI,KAAJ,OAC9B,MACpB,IAAU,KAEZ,KAAK,YAAY,IAAI,GAAU,EAAU;;AAE3C,EAAI,KAUF,KAAK,KAAK,eAAe;;CAI7B,gBAAsB;AAKpB,EAJA,KAAK,SAAS,QAAQ,KAAK,MAAM;GAC/B,WAAW;GACX,SAAS;GACV,CAAC,EACF,KAAK,eAAe;;CAGtB,mBAAyB;AACvB,OAAK,SAAS,YAAY"}

package/dist/controllers/slot-text-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 { SlotTextController, type SlotTextConfig, } from './src/slot-text-controller.js';

package/dist/controllers/slot-text-controller/index.js

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

package/dist/controllers/slot-text-controller/src/slot-text-controller.d.ts

@@ -0,0 +1,92 @@
+import { ReactiveController, ReactiveElement } from 'lit';
+export interface SlotTextConfig {
+    /**
+     * The slot name to observe. Use `''` (empty string) for the default slot.
+     *
+     * @default '' (default slot)
+     */
+    slotName?: string;
+    /**
+     * CSS selectors for elements to exclude when checking for content.
+     * Matched elements are ignored — only non-excluded elements and
+     * non-empty text nodes count as "content."
+     */
+    excludeSelectors?: string[];
+}
+/**
+ * A reactive controller that observes whether a slot contains meaningful
+ * text or element content.
+ *
+ * Replaces the `ObserveSlotText` mixin with a composition-based approach.
+ *
+ * Monitors for `characterData` mutations (text changes) and re-evaluates
+ * on slot change events. The host is requested to update whenever the
+ * content state changes.
+ *
+ * @example
+ * ```typescript
+ * class MyButton extends SpectrumElement {
+ *   private slotText = new SlotTextController(this);
+ *
+ *   get hasLabel(): boolean {
+ *     return this.slotText.hasContent;
+ *   }
+ *
+ *   override render() {
+ *     return html`<slot @slotchange=${this.slotText.handleSlotChange}></slot>`;
+ *   }
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Named slot with exclusions
+ * class MyComponent extends SpectrumElement {
+ *   private slotText = new SlotTextController(this, {
+ *     slotName: 'description',
+ *     excludeSelectors: ['.visually-hidden'],
+ *   });
+ * }
+ * ```
+ */
+export declare class SlotTextController implements ReactiveController {
+    private host;
+    private slotName;
+    private excludeSelectors;
+    private observer;
+    private _hasContent;
+    constructor(host: ReactiveElement, config?: SlotTextConfig);
+    /**
+     * Whether the observed slot has meaningful content (text nodes or
+     * non-excluded elements).
+     */
+    get hasContent(): boolean;
+    /**
+     * Bind this to the slot's `@slotchange` event in the template.
+     *
+     * @example
+     * ```html
+     * <slot @slotchange=${this.slotText.handleSlotChange}></slot>
+     * ```
+     */
+    handleSlotChange: (event: Event) => void;
+    private evaluateNodes;
+    /**
+     * Checks initial content from light DOM children before the first render,
+     * before slots are assigned.
+     *
+     * This runs from `hostConnected`, which Lit invokes during the host's
+     * `connectedCallback` — before the first `update()`. It sets `_hasContent`
+     * directly and intentionally does not call `requestUpdate()`: the first
+     * render has not happened yet, so it will read the correct value when it
+     * runs. This differs from the `ObserveSlotText` mixin, where `slotHasContent`
+     * was a reactive `@property` assigned in `update()`. After the first render,
+     * `handleSlotChange` (bound via `@slotchange`) and the `characterData`
+     * observer take over and do call `requestUpdate()` on change. The
+     * controller stories cover initial content being reflected on first paint.
+     */
+    private checkInitialContent;
+    private checkContent;
+    hostConnected(): void;
+    hostDisconnected(): void;
+}

package/dist/controllers/slot-text-controller/src/slot-text-controller.js

@@ -0,0 +1,53 @@
+//#region controllers/slot-text-controller/src/slot-text-controller.ts
+var e = class {
+	constructor(e, t = {}) {
+		var n, r;
+		this._hasContent = !1, this.handleSlotChange = (e) => {
+			let t = e.target.assignedNodes({ flatten: !0 });
+			this.evaluateNodes(t);
+		}, this.host = e, this.slotName = (n = t.slotName) == null ? "" : n, this.excludeSelectors = (r = t.excludeSelectors) == null ? [] : r, this.host.addController(this), this.observer = new MutationObserver((e) => {
+			for (let t of e) if (t.type === "characterData") {
+				this.checkContent();
+				return;
+			}
+		});
+	}
+	get hasContent() {
+		return this._hasContent;
+	}
+	evaluateNodes(e) {
+		let t = [...e].some((e) => {
+			let t = e;
+			return t.tagName ? !this.excludeSelectors.some((e) => t.matches(e)) : this.slotName ? !1 : e.nodeType === Node.TEXT_NODE && e.textContent ? e.textContent.trim().length > 0 : !1;
+		});
+		t !== this._hasContent && (this._hasContent = t, this.host.requestUpdate());
+	}
+	checkInitialContent() {
+		let { childNodes: e } = this.host;
+		this._hasContent = [...e].filter((e) => {
+			let t = e;
+			return t.tagName ? this.excludeSelectors.some((e) => t.matches(e)) ? !1 : this.slotName ? t.getAttribute("slot") === this.slotName : !t.hasAttribute("slot") : this.slotName ? !1 : e.nodeType === Node.TEXT_NODE && e.textContent ? e.textContent.trim().length > 0 : !1;
+		}).length > 0;
+	}
+	checkContent() {
+		var e;
+		let t = (e = this.host.shadowRoot) == null ? void 0 : e.querySelector(this.slotName ? `slot[name="${this.slotName}"]` : "slot:not([name])");
+		if (t) {
+			let e = t.assignedNodes({ flatten: !0 });
+			this.evaluateNodes(e);
+		}
+	}
+	hostConnected() {
+		this.observer.observe(this.host, {
+			characterData: !0,
+			subtree: !0
+		}), this.checkInitialContent();
+	}
+	hostDisconnected() {
+		this.observer.disconnect();
+	}
+};
+//#endregion
+export { e as SlotTextController };
+
+//# sourceMappingURL=slot-text-controller.js.map

package/dist/controllers/slot-text-controller/src/slot-text-controller.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"slot-text-controller.js","names":[],"sources":["../../../../controllers/slot-text-controller/src/slot-text-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\nexport interface SlotTextConfig {\n  /**\n   * The slot name to observe. Use `''` (empty string) for the default slot.\n   *\n   * @default '' (default slot)\n   */\n  slotName?: string;\n\n  /**\n   * CSS selectors for elements to exclude when checking for content.\n   * Matched elements are ignored — only non-excluded elements and\n   * non-empty text nodes count as \"content.\"\n   */\n  excludeSelectors?: string[];\n}\n\n/**\n * A reactive controller that observes whether a slot contains meaningful\n * text or element content.\n *\n * Replaces the `ObserveSlotText` mixin with a composition-based approach.\n *\n * Monitors for `characterData` mutations (text changes) and re-evaluates\n * on slot change events. The host is requested to update whenever the\n * content state changes.\n *\n * @example\n * ```typescript\n * class MyButton extends SpectrumElement {\n *   private slotText = new SlotTextController(this);\n *\n *   get hasLabel(): boolean {\n *     return this.slotText.hasContent;\n *   }\n *\n *   override render() {\n *     return html`<slot @slotchange=${this.slotText.handleSlotChange}></slot>`;\n *   }\n * }\n * ```\n *\n * @example\n * ```typescript\n * // Named slot with exclusions\n * class MyComponent extends SpectrumElement {\n *   private slotText = new SlotTextController(this, {\n *     slotName: 'description',\n *     excludeSelectors: ['.visually-hidden'],\n *   });\n * }\n * ```\n */\nexport class SlotTextController implements ReactiveController {\n  private host: ReactiveElement;\n  private slotName: string;\n  private excludeSelectors: string[];\n  private observer: MutationObserver;\n  private _hasContent = false;\n\n  constructor(host: ReactiveElement, config: SlotTextConfig = {}) {\n    this.host = host;\n    this.slotName = config.slotName ?? '';\n    this.excludeSelectors = config.excludeSelectors ?? [];\n    this.host.addController(this);\n\n    this.observer = new MutationObserver((mutations) => {\n      for (const mutation of mutations) {\n        if (mutation.type === 'characterData') {\n          this.checkContent();\n          return;\n        }\n      }\n    });\n  }\n\n  /**\n   * Whether the observed slot has meaningful content (text nodes or\n   * non-excluded elements).\n   */\n  get hasContent(): boolean {\n    return this._hasContent;\n  }\n\n  /**\n   * Bind this to the slot's `@slotchange` event in the template.\n   *\n   * @example\n   * ```html\n   * <slot @slotchange=${this.slotText.handleSlotChange}></slot>\n   * ```\n   */\n  handleSlotChange = (event: Event): void => {\n    const slot = event.target as HTMLSlotElement;\n    const nodes = slot.assignedNodes({ flatten: true });\n    this.evaluateNodes(nodes);\n  };\n\n  private evaluateNodes(nodes: Iterable<Node>): void {\n    const hasContent = [...nodes].some((node) => {\n      const el = node as HTMLElement;\n      if (el.tagName) {\n        return !this.excludeSelectors.some((sel) => el.matches(sel));\n      }\n      // A bare text node can never carry a `slot` attribute, so it is only\n      // ever assigned to the default slot. When observing a named slot it must\n      // not count as content.\n      if (this.slotName) {\n        return false;\n      }\n      // Only real text nodes count. Comment nodes (e.g. Lit's child-part\n      // markers left behind by a `${cond ? nothing : label}` binding) also\n      // lack a `tagName`, and their `textContent` is the marker data, which\n      // would otherwise be misread as label text.\n      return node.nodeType === Node.TEXT_NODE && node.textContent\n        ? node.textContent.trim().length > 0\n        : false;\n    });\n\n    if (hasContent !== this._hasContent) {\n      this._hasContent = hasContent;\n      this.host.requestUpdate();\n    }\n  }\n\n  /**\n   * Checks initial content from light DOM children before the first render,\n   * before slots are assigned.\n   *\n   * This runs from `hostConnected`, which Lit invokes during the host's\n   * `connectedCallback` — before the first `update()`. It sets `_hasContent`\n   * directly and intentionally does not call `requestUpdate()`: the first\n   * render has not happened yet, so it will read the correct value when it\n   * runs. This differs from the `ObserveSlotText` mixin, where `slotHasContent`\n   * was a reactive `@property` assigned in `update()`. After the first render,\n   * `handleSlotChange` (bound via `@slotchange`) and the `characterData`\n   * observer take over and do call `requestUpdate()` on change. The\n   * controller stories cover initial content being reflected on first paint.\n   */\n  private checkInitialContent(): void {\n    const { childNodes } = this.host;\n    const relevant = [...childNodes].filter((node) => {\n      const el = node as HTMLElement;\n      if (el.tagName) {\n        const excluded = this.excludeSelectors.some((sel) => el.matches(sel));\n        if (excluded) {\n          return false;\n        }\n        // Match slot assignment: named slot checks slot attribute,\n        // default slot checks for no slot attribute\n        return this.slotName\n          ? el.getAttribute('slot') === this.slotName\n          : !el.hasAttribute('slot');\n      }\n      // A bare text node has no `slot` attribute, so it is only assigned to\n      // the default slot; it never counts as content for a named slot.\n      if (this.slotName) {\n        return false;\n      }\n      // Only real text nodes count. Comment nodes (e.g. Lit's child-part\n      // markers left behind by a `${cond ? nothing : label}` binding) also\n      // lack a `tagName`, and their `textContent` is the marker data, which\n      // would otherwise be misread as label text.\n      return node.nodeType === Node.TEXT_NODE && node.textContent\n        ? node.textContent.trim().length > 0\n        : false;\n    });\n    this._hasContent = relevant.length > 0;\n  }\n\n  private checkContent(): void {\n    // Re-query assigned nodes from the slot element in the shadow root\n    const slot = this.host.shadowRoot?.querySelector(\n      this.slotName ? `slot[name=\"${this.slotName}\"]` : 'slot:not([name])'\n    ) as HTMLSlotElement | null;\n    if (slot) {\n      const nodes = slot.assignedNodes({ flatten: true });\n      this.evaluateNodes(nodes);\n    }\n  }\n\n  hostConnected(): void {\n    this.observer.observe(this.host, {\n      characterData: true,\n      subtree: true,\n    });\n    this.checkInitialContent();\n  }\n\n  hostDisconnected(): void {\n    this.observer.disconnect();\n  }\n}\n"],"mappings":";AAkEA,IAAa,IAAb,MAA8D;CAO5D,YAAY,GAAuB,IAAyB,EAAE,EAAE;;AAM9D,qBARoB,6BAkCF,MAAuB;GAEzC,IAAM,IADO,EAAM,OACA,cAAc,EAAE,SAAS,IAAM,CAAC;AACnD,QAAK,cAAc,EAAM;KAlCzB,KAAK,OAAO,GACZ,KAAK,YAAA,IAAW,EAAO,aAAA,OAAY,KAAZ,GACvB,KAAK,oBAAA,IAAmB,EAAO,qBAAA,OAAoB,EAAE,GAAtB,GAC/B,KAAK,KAAK,cAAc,KAAK,EAE7B,KAAK,WAAW,IAAI,kBAAkB,MAAc;AAClD,QAAK,IAAM,KAAY,EACrB,KAAI,EAAS,SAAS,iBAAiB;AACrC,SAAK,cAAc;AACnB;;IAGJ;;CAOJ,IAAI,aAAsB;AACxB,SAAO,KAAK;;CAiBd,cAAsB,GAA6B;EACjD,IAAM,IAAa,CAAC,GAAG,EAAM,CAAC,MAAM,MAAS;GAC3C,IAAM,IAAK;AAcX,UAbI,EAAG,UACE,CAAC,KAAK,iBAAiB,MAAM,MAAQ,EAAG,QAAQ,EAAI,CAAC,GAK1D,KAAK,WACA,KAMF,EAAK,aAAa,KAAK,aAAa,EAAK,cAC5C,EAAK,YAAY,MAAM,CAAC,SAAS,IACjC;IACJ;AAEF,EAAI,MAAe,KAAK,gBACtB,KAAK,cAAc,GACnB,KAAK,KAAK,eAAe;;CAkB7B,sBAAoC;EAClC,IAAM,EAAE,kBAAe,KAAK;AA2B5B,OAAK,cA1BY,CAAC,GAAG,EAAW,CAAC,QAAQ,MAAS;GAChD,IAAM,IAAK;AAqBX,UApBI,EAAG,UACY,KAAK,iBAAiB,MAAM,MAAQ,EAAG,QAAQ,EAAI,CAAC,GAE5D,KAIF,KAAK,WACR,EAAG,aAAa,OAAO,KAAK,KAAK,WACjC,CAAC,EAAG,aAAa,OAAO,GAI1B,KAAK,WACA,KAMF,EAAK,aAAa,KAAK,aAAa,EAAK,cAC5C,EAAK,YAAY,MAAM,CAAC,SAAS,IACjC;IACJ,CAC0B,SAAS;;CAGvC,eAA6B;;EAE3B,IAAM,KAAA,IAAO,KAAK,KAAK,eAAA,OAAA,KAAA,IAAA,EAAY,cACjC,KAAK,WAAW,cAAc,KAAK,SAAS,MAAM,mBACnD;AACD,MAAI,GAAM;GACR,IAAM,IAAQ,EAAK,cAAc,EAAE,SAAS,IAAM,CAAC;AACnD,QAAK,cAAc,EAAM;;;CAI7B,gBAAsB;AAKpB,EAJA,KAAK,SAAS,QAAQ,KAAK,MAAM;GAC/B,eAAe;GACf,SAAS;GACV,CAAC,EACF,KAAK,qBAAqB;;CAG5B,mBAAyB;AACvB,OAAK,SAAS,YAAY"}

package/dist/controllers/trigger-press-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 { TriggerPressController, type TriggerPressControllerOptions, } from './src/trigger-press-controller.js';

package/dist/controllers/trigger-press-controller/index.js

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

package/dist/controllers/trigger-press-controller/src/trigger-press-controller.d.ts

@@ -0,0 +1,149 @@
+import { ReactiveController, ReactiveControllerHost } from 'lit';
+/**
+ * Options for {@link TriggerPressController.attach}.
+ */
+export interface TriggerPressControllerOptions {
+    /**
+     * Called on a trigger click that is not consumed as a same-gesture reopen
+     * guard (see {@link TriggerPressController} for when a click is
+     * consumed instead). Typically flips the host's own `open` property.
+     */
+    onToggle: () => void;
+}
+/**
+ * **TriggerPressController** — click-to-toggle wiring for a trigger that
+ * opens a native light-dismissible surface (`popover="auto"`, a non-modal
+ * `<dialog>`, or anything else the platform can close on its own), without
+ * the surface reopening on the same click that was meant to close it.
+ *
+ * ### The bug this prevents
+ *
+ * A naive click-to-toggle handler (`trigger.onclick = () => (open = !open)`)
+ * looks correct, but breaks the moment the surface can close itself: pressing
+ * the trigger again while the surface is open is, from the surface's own
+ * perspective, a press *outside* it. The platform's light-dismiss closes the
+ * surface **before** the trailing `click` event fires on the trigger. By the
+ * time that `click` handler runs, `open` already reads `false` (synced down
+ * by the dismissal), so `!open` flips it back to `true` — the surface
+ * silently reopens on the very click that should have closed it.
+ *
+ * ### How it's fixed
+ *
+ * A capturing `pointerdown`/`touchstart` listener on the trigger opens a
+ * short "gesture window" before the platform gets a chance to light-dismiss.
+ * The consumer calls {@link TriggerPressController.noteNativeDismiss}
+ * from its own native-close handler (for example a `popover` element's
+ * `beforetoggle` reaction) whenever it observes a close that was **not**
+ * driven by its own `open` setter. If that close lands inside the gesture
+ * window, the controller remembers it, and the trailing `click` — read by
+ * this controller's own listener — is consumed instead of calling
+ * {@link TriggerPressControllerOptions.onToggle}. A close observed
+ * outside the gesture window (Escape, an outside click elsewhere, a
+ * programmatic close) is not affected.
+ *
+ * This is a JS-only fix because a custom element's shadow-internal surface
+ * cannot be associated with an external trigger via the native
+ * `popovertarget` attribute (that attribute cannot reach across shadow
+ * boundaries), so the platform has no way to know the trigger and the
+ * surface belong together.
+ *
+ * ### Usage
+ *
+ * Construct once per host, then call {@link TriggerPressController.attach}
+ * every time the resolved trigger element changes (attaching the same
+ * element again is a no-op for the listeners, but still updates the
+ * {@link TriggerPressControllerOptions.onToggle} callback). Call
+ * {@link TriggerPressController.noteNativeDismiss} from the surface's own
+ * native-close reaction, guarded by whatever the host already uses to tell a
+ * genuine native dismissal apart from its own programmatic close (typically:
+ * the close reaction fires while the host's `open` property is still `true`).
+ *
+ * @example
+ * ```typescript
+ * class MyToggle extends LitElement {
+ *   @property({ type: Boolean, reflect: true }) open = false;
+ *
+ *   private readonly pressGuard = new TriggerPressController(this);
+ *
+ *   private wireTrigger(trigger: HTMLElement | null): void {
+ *     this.pressGuard.attach(trigger, {
+ *       onToggle: () => (this.open = !this.open),
+ *     });
+ *   }
+ *
+ *   // Bound to the surface's `beforetoggle` in render().
+ *   private onBeforeToggle = (event: ToggleEvent): void => {
+ *     if (event.newState === 'open') {
+ *       return;
+ *     }
+ *     if (this.open) {
+ *       // Not already closed via our own setter, so this is a genuine
+ *       // native dismissal (Escape, outside click, ...).
+ *       this.pressGuard.noteNativeDismiss();
+ *     }
+ *     this.open = false;
+ *   };
+ * }
+ * ```
+ */
+export declare class TriggerPressController implements ReactiveController {
+    /** The element currently carrying the press/click listeners. */
+    private trigger;
+    private options;
+    /**
+     * True between a trigger press start (`pointerdown`/`touchstart`) and its
+     * `click`, so a native dismissal observed inside that window is attributed
+     * to the press.
+     */
+    private pointerActive;
+    /** Cancels the pending press-end listeners armed in {@link onPressStart}. */
+    private pressEndAbort;
+    /**
+     * Set by {@link noteNativeDismiss} when a native dismissal is observed
+     * while {@link pointerActive}, so the trailing `click` of that same
+     * gesture is read as the close rather than a reopen.
+     */
+    private dismissedByPress;
+    /**
+     * Registers this controller on `host` via `addController`.
+     *
+     * @param host - Reactive element whose trigger this controller wires.
+     */
+    constructor(host: ReactiveControllerHost);
+    /**
+     * Wires (or rewires) the click-to-toggle and press-tracking listeners.
+     *
+     * A no-op for the listeners themselves when `trigger` is the same element
+     * already attached — safe to call on every re-resolution of the trigger
+     * (for example from a Lit `updated()` reacting to `for`/`triggerElement`
+     * changes) without needing to compare against the previous element
+     * yourself. `options` is always updated, even when `trigger` is unchanged.
+     *
+     * @param trigger - Element to wire, or `null` to only detach.
+     * @param options - Callback invoked on an un-consumed click.
+     */
+    attach(trigger: HTMLElement | null, options: TriggerPressControllerOptions): void;
+    /**
+     * Removes the currently-wired listeners (if any) and resets gesture state.
+     * Safe to call multiple times. Also called automatically by
+     * {@link hostDisconnected}.
+     */
+    detach(): void;
+    /**
+     * Call from the surface's own native-close reaction when the close was
+     * **not** driven by the host's own `open` setter (a genuine native
+     * dismissal: Escape, an outside click, or the platform closing it for any
+     * other reason). No-op unless a press on the attached trigger is currently
+     * in flight; that gesture window is the only time a dismissal needs to be
+     * correlated with the trailing click.
+     */
+    noteNativeDismiss(): void;
+    /**
+     * Lit `ReactiveController` hook: tears down listeners when the host
+     * disconnects.
+     */
+    hostDisconnected(): void;
+    private readonly onPressStart;
+    private readonly onPressEnd;
+    private readonly onClick;
+}

package/dist/controllers/trigger-press-controller/src/trigger-press-controller.js

@@ -0,0 +1,43 @@
+//#region controllers/trigger-press-controller/src/trigger-press-controller.ts
+var e = class {
+	constructor(e) {
+		this.trigger = null, this.options = null, this.pointerActive = !1, this.pressEndAbort = null, this.dismissedByPress = !1, this.onPressStart = () => {
+			var e;
+			this.pointerActive = !0, (e = this.pressEndAbort) == null || e.abort(), this.pressEndAbort = new AbortController();
+			let { signal: t } = this.pressEndAbort;
+			document.addEventListener("pointerup", this.onPressEnd, {
+				capture: !0,
+				once: !0,
+				signal: t
+			}), document.addEventListener("pointercancel", this.onPressEnd, {
+				capture: !0,
+				once: !0,
+				signal: t
+			});
+		}, this.onPressEnd = (e) => {
+			var t;
+			(t = this.pressEndAbort) == null || t.abort(), !(e.type === "pointerup" && this.trigger !== null && e.composedPath().includes(this.trigger)) && (this.pointerActive = !1, this.dismissedByPress = !1);
+		}, this.onClick = () => {
+			var e;
+			let t = this.dismissedByPress;
+			this.pointerActive = !1, this.dismissedByPress = !1, !t && ((e = this.options) == null || e.onToggle());
+		}, e.addController(this);
+	}
+	attach(e, t) {
+		this.options = t, e !== this.trigger && (this.detach(), this.trigger = e, e && (e.addEventListener("pointerdown", this.onPressStart, { capture: !0 }), e.addEventListener("touchstart", this.onPressStart, { capture: !0 }), e.addEventListener("click", this.onClick)));
+	}
+	detach() {
+		var e, t, n, r;
+		(e = this.trigger) == null || e.removeEventListener("pointerdown", this.onPressStart, { capture: !0 }), (t = this.trigger) == null || t.removeEventListener("touchstart", this.onPressStart, { capture: !0 }), (n = this.trigger) == null || n.removeEventListener("click", this.onClick), this.trigger = null, (r = this.pressEndAbort) == null || r.abort(), this.pressEndAbort = null, this.pointerActive = !1, this.dismissedByPress = !1;
+	}
+	noteNativeDismiss() {
+		this.pointerActive && (this.dismissedByPress = !0);
+	}
+	hostDisconnected() {
+		this.detach();
+	}
+};
+//#endregion
+export { e as TriggerPressController };
+
+//# sourceMappingURL=trigger-press-controller.js.map

package/dist/controllers/trigger-press-controller/src/trigger-press-controller.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"trigger-press-controller.js","names":[],"sources":["../../../../controllers/trigger-press-controller/src/trigger-press-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';\n\n/**\n * Options for {@link TriggerPressController.attach}.\n */\nexport interface TriggerPressControllerOptions {\n  /**\n   * Called on a trigger click that is not consumed as a same-gesture reopen\n   * guard (see {@link TriggerPressController} for when a click is\n   * consumed instead). Typically flips the host's own `open` property.\n   */\n  onToggle: () => void;\n}\n\n/**\n * **TriggerPressController** — click-to-toggle wiring for a trigger that\n * opens a native light-dismissible surface (`popover=\"auto\"`, a non-modal\n * `<dialog>`, or anything else the platform can close on its own), without\n * the surface reopening on the same click that was meant to close it.\n *\n * ### The bug this prevents\n *\n * A naive click-to-toggle handler (`trigger.onclick = () => (open = !open)`)\n * looks correct, but breaks the moment the surface can close itself: pressing\n * the trigger again while the surface is open is, from the surface's own\n * perspective, a press *outside* it. The platform's light-dismiss closes the\n * surface **before** the trailing `click` event fires on the trigger. By the\n * time that `click` handler runs, `open` already reads `false` (synced down\n * by the dismissal), so `!open` flips it back to `true` — the surface\n * silently reopens on the very click that should have closed it.\n *\n * ### How it's fixed\n *\n * A capturing `pointerdown`/`touchstart` listener on the trigger opens a\n * short \"gesture window\" before the platform gets a chance to light-dismiss.\n * The consumer calls {@link TriggerPressController.noteNativeDismiss}\n * from its own native-close handler (for example a `popover` element's\n * `beforetoggle` reaction) whenever it observes a close that was **not**\n * driven by its own `open` setter. If that close lands inside the gesture\n * window, the controller remembers it, and the trailing `click` — read by\n * this controller's own listener — is consumed instead of calling\n * {@link TriggerPressControllerOptions.onToggle}. A close observed\n * outside the gesture window (Escape, an outside click elsewhere, a\n * programmatic close) is not affected.\n *\n * This is a JS-only fix because a custom element's shadow-internal surface\n * cannot be associated with an external trigger via the native\n * `popovertarget` attribute (that attribute cannot reach across shadow\n * boundaries), so the platform has no way to know the trigger and the\n * surface belong together.\n *\n * ### Usage\n *\n * Construct once per host, then call {@link TriggerPressController.attach}\n * every time the resolved trigger element changes (attaching the same\n * element again is a no-op for the listeners, but still updates the\n * {@link TriggerPressControllerOptions.onToggle} callback). Call\n * {@link TriggerPressController.noteNativeDismiss} from the surface's own\n * native-close reaction, guarded by whatever the host already uses to tell a\n * genuine native dismissal apart from its own programmatic close (typically:\n * the close reaction fires while the host's `open` property is still `true`).\n *\n * @example\n * ```typescript\n * class MyToggle extends LitElement {\n *   @property({ type: Boolean, reflect: true }) open = false;\n *\n *   private readonly pressGuard = new TriggerPressController(this);\n *\n *   private wireTrigger(trigger: HTMLElement | null): void {\n *     this.pressGuard.attach(trigger, {\n *       onToggle: () => (this.open = !this.open),\n *     });\n *   }\n *\n *   // Bound to the surface's `beforetoggle` in render().\n *   private onBeforeToggle = (event: ToggleEvent): void => {\n *     if (event.newState === 'open') {\n *       return;\n *     }\n *     if (this.open) {\n *       // Not already closed via our own setter, so this is a genuine\n *       // native dismissal (Escape, outside click, ...).\n *       this.pressGuard.noteNativeDismiss();\n *     }\n *     this.open = false;\n *   };\n * }\n * ```\n */\nexport class TriggerPressController implements ReactiveController {\n  /** The element currently carrying the press/click listeners. */\n  private trigger: HTMLElement | null = null;\n\n  private options: TriggerPressControllerOptions | null = null;\n\n  /**\n   * True between a trigger press start (`pointerdown`/`touchstart`) and its\n   * `click`, so a native dismissal observed inside that window is attributed\n   * to the press.\n   */\n  private pointerActive = false;\n\n  /** Cancels the pending press-end listeners armed in {@link onPressStart}. */\n  private pressEndAbort: AbortController | null = null;\n\n  /**\n   * Set by {@link noteNativeDismiss} when a native dismissal is observed\n   * while {@link pointerActive}, so the trailing `click` of that same\n   * gesture is read as the close rather than a reopen.\n   */\n  private dismissedByPress = false;\n\n  /**\n   * Registers this controller on `host` via `addController`.\n   *\n   * @param host - Reactive element whose trigger this controller wires.\n   */\n  constructor(host: ReactiveControllerHost) {\n    host.addController(this);\n  }\n\n  /**\n   * Wires (or rewires) the click-to-toggle and press-tracking listeners.\n   *\n   * A no-op for the listeners themselves when `trigger` is the same element\n   * already attached — safe to call on every re-resolution of the trigger\n   * (for example from a Lit `updated()` reacting to `for`/`triggerElement`\n   * changes) without needing to compare against the previous element\n   * yourself. `options` is always updated, even when `trigger` is unchanged.\n   *\n   * @param trigger - Element to wire, or `null` to only detach.\n   * @param options - Callback invoked on an un-consumed click.\n   */\n  public attach(\n    trigger: HTMLElement | null,\n    options: TriggerPressControllerOptions\n  ): void {\n    this.options = options;\n    if (trigger === this.trigger) {\n      return;\n    }\n    this.detach();\n    this.trigger = trigger;\n    if (trigger) {\n      trigger.addEventListener('pointerdown', this.onPressStart, {\n        capture: true,\n      });\n      trigger.addEventListener('touchstart', this.onPressStart, {\n        capture: true,\n      });\n      trigger.addEventListener('click', this.onClick);\n    }\n  }\n\n  /**\n   * Removes the currently-wired listeners (if any) and resets gesture state.\n   * Safe to call multiple times. Also called automatically by\n   * {@link hostDisconnected}.\n   */\n  public detach(): void {\n    this.trigger?.removeEventListener('pointerdown', this.onPressStart, {\n      capture: true,\n    });\n    this.trigger?.removeEventListener('touchstart', this.onPressStart, {\n      capture: true,\n    });\n    this.trigger?.removeEventListener('click', this.onClick);\n    this.trigger = null;\n    this.pressEndAbort?.abort();\n    this.pressEndAbort = null;\n    this.pointerActive = false;\n    this.dismissedByPress = false;\n  }\n\n  /**\n   * Call from the surface's own native-close reaction when the close was\n   * **not** driven by the host's own `open` setter (a genuine native\n   * dismissal: Escape, an outside click, or the platform closing it for any\n   * other reason). No-op unless a press on the attached trigger is currently\n   * in flight; that gesture window is the only time a dismissal needs to be\n   * correlated with the trailing click.\n   */\n  public noteNativeDismiss(): void {\n    if (this.pointerActive) {\n      this.dismissedByPress = true;\n    }\n  }\n\n  /**\n   * Lit `ReactiveController` hook: tears down listeners when the host\n   * disconnects.\n   */\n  public hostDisconnected(): void {\n    this.detach();\n  }\n\n  // ─────────────────────────\n  //     IMPLEMENTATION\n  // ─────────────────────────\n\n  // Capture phase, before a native light-dismiss (which runs on the same\n  // press) gets a chance to close the surface first.\n  private readonly onPressStart = (): void => {\n    this.pointerActive = true;\n    // A touch gesture fires both `pointerdown` and `touchstart` on the same\n    // trigger, so this runs twice per press. Without aborting the previous\n    // controller first, the second `addEventListener` below is a no-op (the\n    // DOM dedupes on type/listener/capture, ignoring the new `signal`), so\n    // `pressEndAbort` would end up pointing at a controller with nothing\n    // attached to it while the real listeners stay tied to the first one.\n    this.pressEndAbort?.abort();\n    // Catches a press that ends without a click (drag off the trigger, or a\n    // cancelled gesture), which would otherwise leave the flag stuck true.\n    this.pressEndAbort = new AbortController();\n    const { signal } = this.pressEndAbort;\n    document.addEventListener('pointerup', this.onPressEnd, {\n      capture: true,\n      once: true,\n      signal,\n    });\n    document.addEventListener('pointercancel', this.onPressEnd, {\n      capture: true,\n      once: true,\n      signal,\n    });\n  };\n\n  private readonly onPressEnd = (event: PointerEvent): void => {\n    this.pressEndAbort?.abort();\n    // A same-target pointerup still gets its own click, which reads and\n    // clears `dismissedByPress` itself; clearing it here too would race that\n    // read. Any other press end (pointercancel, or a pointerup that lands off\n    // the trigger) means no click is coming for this gesture, so both flags\n    // are cleared here instead — otherwise a dismissal noted during a press\n    // that never resolves to a click would incorrectly consume the next,\n    // unrelated click on the trigger.\n    if (\n      event.type === 'pointerup' &&\n      this.trigger !== null &&\n      event.composedPath().includes(this.trigger)\n    ) {\n      return;\n    }\n    this.pointerActive = false;\n    this.dismissedByPress = false;\n  };\n\n  // If a native dismissal already consumed this gesture (recorded via\n  // `noteNativeDismiss`), consume this click so it does not toggle back\n  // open; otherwise call the consumer's own toggle.\n  private readonly onClick = (): void => {\n    const dismissedByThisGesture = this.dismissedByPress;\n    this.pointerActive = false;\n    this.dismissedByPress = false;\n    if (dismissedByThisGesture) {\n      return;\n    }\n    this.options?.onToggle();\n  };\n}\n"],"mappings":";AAsGA,IAAa,IAAb,MAAkE;CA4BhE,YAAY,GAA8B;AACxC,iBA3BoC,qBAEkB,2BAOhC,yBAGwB,8BAOrB,8BA4FiB;;AAW1C,GAVA,KAAK,gBAAgB,KAOrB,IAAA,KAAK,kBAAA,QAAA,EAAe,OAAO,EAG3B,KAAK,gBAAgB,IAAI,iBAAiB;GAC1C,IAAM,EAAE,cAAW,KAAK;AAMxB,GALA,SAAS,iBAAiB,aAAa,KAAK,YAAY;IACtD,SAAS;IACT,MAAM;IACN;IACD,CAAC,EACF,SAAS,iBAAiB,iBAAiB,KAAK,YAAY;IAC1D,SAAS;IACT,MAAM;IACN;IACD,CAAC;wBAG2B,MAA8B;;AAC3D,IAAA,IAAA,KAAK,kBAAA,QAAA,EAAe,OAAO,EASzB,IAAM,SAAS,eACf,KAAK,YAAY,QACjB,EAAM,cAAc,CAAC,SAAS,KAAK,QAAQ,MAI7C,KAAK,gBAAgB,IACrB,KAAK,mBAAmB;0BAMa;;GACrC,IAAM,IAAyB,KAAK;AACpC,QAAK,gBAAgB,IACrB,KAAK,mBAAmB,IACpB,QAGJ,IAAA,KAAK,YAAA,QAAA,EAAS,UAAU;KA3IxB,EAAK,cAAc,KAAK;;CAe1B,OACE,GACA,GACM;AACN,OAAK,UAAU,GACX,MAAY,KAAK,YAGrB,KAAK,QAAQ,EACb,KAAK,UAAU,GACX,MACF,EAAQ,iBAAiB,eAAe,KAAK,cAAc,EACzD,SAAS,IACV,CAAC,EACF,EAAQ,iBAAiB,cAAc,KAAK,cAAc,EACxD,SAAS,IACV,CAAC,EACF,EAAQ,iBAAiB,SAAS,KAAK,QAAQ;;CASnD,SAAsB;;AAYpB,GAXA,IAAA,KAAK,YAAA,QAAA,EAAS,oBAAoB,eAAe,KAAK,cAAc,EAClE,SAAS,IACV,CAAC,GACF,IAAA,KAAK,YAAA,QAAA,EAAS,oBAAoB,cAAc,KAAK,cAAc,EACjE,SAAS,IACV,CAAC,GACF,IAAA,KAAK,YAAA,QAAA,EAAS,oBAAoB,SAAS,KAAK,QAAQ,EACxD,KAAK,UAAU,OACf,IAAA,KAAK,kBAAA,QAAA,EAAe,OAAO,EAC3B,KAAK,gBAAgB,MACrB,KAAK,gBAAgB,IACrB,KAAK,mBAAmB;;CAW1B,oBAAiC;AAC/B,EAAI,KAAK,kBACP,KAAK,mBAAmB;;CAQ5B,mBAAgC;AAC9B,OAAK,QAAQ"}

package/dist/directives/index.d.ts

@@ -10,6 +10,6 @@
  * governing permissions and limitations under the License.
  */
 /**
- * Public exports for render-only Lit template directives shared across 2nd-gen packages.
+ * Public exports for render-only Lit template directives shared across gen2 packages.
  */
 export { renderPendingSpinner, type PendingSpinnerResult, } from './pending-spinner/index.js';

package/dist/element/define-element.js

@@ -1,6 +1,6 @@
 //#region element/define-element.ts
 function e(e, t) {
-	window.__swc && window.__swc.DEBUG && customElements.get(e) && window.__swc.warn(void 0, `Attempted to redefine <${e}>. This usually indicates that multiple versions of the same web component were loaded onto a single page.`, "https://opensource.adobe.com/spectrum-web-components/registry-conflicts"), customElements.define(e, t);
+	window.__swc && window.__swc.DEBUG && customElements.get(e) && window.__swc.warn(void 0, `Attempted to redefine <${e}>. This usually indicates that multiple versions of the same web component were loaded onto a single page.`, "https://spectrum-web-components.adobe.com/registry-conflicts"), customElements.define(e, t);
 }
 //#endregion
 export { e as defineElement };

package/dist/element/define-element.js.map

@@ -1 +1 @@
-{"version":3,"file":"define-element.js","names":[],"sources":["../../element/define-element.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\ninterface CustomElementConstructor {\n  new (...params: unknown[]): HTMLElement;\n}\n\nexport function defineElement(\n  name: string,\n  constructor: CustomElementConstructor\n): void {\n  if (window.__swc && window.__swc.DEBUG) {\n    if (customElements.get(name)) {\n      window.__swc.warn(\n        undefined,\n        `Attempted to redefine <${name}>. This usually indicates that multiple versions of the same web component were loaded onto a single page.`,\n        'https://opensource.adobe.com/spectrum-web-components/registry-conflicts'\n      );\n    }\n  }\n  customElements.define(name, constructor);\n}\n"],"mappings":";AAgBA,SAAgB,EACd,GACA,GACM;AAUN,CATI,OAAO,SAAS,OAAO,MAAM,SAC3B,eAAe,IAAI,EAAK,IAC1B,OAAO,MAAM,KACX,KAAA,GACA,0BAA0B,EAAK,6GAC/B,0EACD,EAGL,eAAe,OAAO,GAAM,EAAY"}
+{"version":3,"file":"define-element.js","names":[],"sources":["../../element/define-element.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\ninterface CustomElementConstructor {\n  new (...params: unknown[]): HTMLElement;\n}\n\nexport function defineElement(\n  name: string,\n  constructor: CustomElementConstructor\n): void {\n  if (window.__swc && window.__swc.DEBUG) {\n    if (customElements.get(name)) {\n      window.__swc.warn(\n        undefined,\n        `Attempted to redefine <${name}>. This usually indicates that multiple versions of the same web component were loaded onto a single page.`,\n        'https://spectrum-web-components.adobe.com/registry-conflicts'\n      );\n    }\n  }\n  customElements.define(name, constructor);\n}\n"],"mappings":";AAgBA,SAAgB,EACd,GACA,GACM;AAUN,CATI,OAAO,SAAS,OAAO,MAAM,SAC3B,eAAe,IAAI,EAAK,IAC1B,OAAO,MAAM,KACX,KAAA,GACA,0BAA0B,EAAK,6GAC/B,+DACD,EAGL,eAAe,OAAO,GAAM,EAAY"}

package/dist/element/index.d.ts

@@ -10,5 +10,5 @@
  * governing permissions and limitations under the License.
  */
 export { defineElement } from './define-element.js';
-export { SpectrumElement, SpectrumMixin, type SpectrumInterface, } from './spectrum-element.js';
+export { SpectrumElement } from './spectrum-element.js';
 export { coreVersion, version } from './version.js';

package/dist/element/index.js

@@ -1,4 +1,4 @@
 import { defineElement as e } from "./define-element.js";
 import { coreVersion as t, version as n } from "./version.js";
-import { SpectrumElement as r, SpectrumMixin as i } from "./spectrum-element.js";
-export { r as SpectrumElement, i as SpectrumMixin, t as coreVersion, e as defineElement, n as version };
+import { SpectrumElement as r } from "./spectrum-element.js";
+export { r as SpectrumElement, t as coreVersion, e as defineElement, n as version };

package/dist/element/spectrum-element.d.ts

@@ -1,15 +1,5 @@
-import { LitElement, ReactiveElement } from 'lit';
-type Constructor<T = Record<string, unknown>> = {
-    new (...args: any[]): T;
-    prototype: T;
-};
-export interface SpectrumInterface {
-    shadowRoot: ShadowRoot;
-    hasVisibleFocusInTree(): boolean;
-}
-export declare function SpectrumMixin<T extends Constructor<ReactiveElement>>(constructor: T): T & Constructor<SpectrumInterface>;
-declare const SpectrumElement_base: typeof LitElement & Constructor<SpectrumInterface>;
-export declare class SpectrumElement extends SpectrumElement_base {
+import { LitElement } from 'lit';
+export declare class SpectrumElement extends LitElement {
     /**
      * @internal
      */
@@ -18,9 +8,62 @@ export declare class SpectrumElement extends SpectrumElement_base {
      * @internal
      */
     static CORE_VERSION: string;
+}
+/**
+ * Builds the deduplication key for a dev-mode warning. The `message` is part of
+ * the key so two distinct problems that share a `type`/`level` (the common
+ * case) do not suppress each other; only a verbatim repeat of the same warning
+ * is deduplicated. Exported so the dedup key can be unit tested without relying
+ * on the `NODE_ENV`-gated `window.__swc` setup below.
+ */
+export declare function warningId(localName: string, type: WarningType, level: WarningLevel, message: string): BrandedSWCWarningID;
+/**
+ * A group of dev-mode warnings that share a `warningId`, collected within a
+ * single microtask so they can be emitted as one console line with a count.
+ */
+type BatchedWarning = {
+    message: string;
+    url: string;
+    localName: string;
+    type: WarningType;
+    level: WarningLevel;
+    listedIssues: string;
+    elements: HTMLElement[];
+    count: number;
     /**
-     * @internal
+     * Elements already counted in this batch, keyed by identity. A repeated
+     * `warn()` for an element already here does not bump `count` again.
      */
-    get dir(): CSSStyleDeclaration['direction'];
-}
+    countedElements?: Set<HTMLElement>;
+    /**
+     * Whether the dev-mode warning (the only warning with no element) has been
+     * counted, so repeats of it collapse to one.
+     */
+    countedDevModeWarning?: boolean;
+};
+/**
+ * Builds the `console.warn` arguments for a grouped dev warning: the message
+ * and a count line, then the element ref(s) to inspect. By default one
+ * representative element is shown; `verbose` shows every collected element
+ * (already capped at collection time). Exported so the grouped output can be
+ * unit tested without the `NODE_ENV`-gated `window.__swc` setup below.
+ *
+ * @internal
+ */
+export declare function buildGroupedWarningArgs(batch: BatchedWarning, verbose: boolean): unknown[];
+/**
+ * Records one warning occurrence into its batch, counting by element identity:
+ * `count` becomes the number of distinct elements with this warning, not the
+ * number of `warn()` calls. A host that warns once per child (same message,
+ * same element) still counts as one affected element. `count` is uncapped;
+ * `maxDisplayed` only limits how many element refs are kept for display.
+ *
+ * @param batch - Grouped-warning batch to record into.
+ * @param element - Element the warning is about, or `undefined` for the
+ *   dev-mode warning, which is not about a specific element.
+ * @param maxDisplayed - Cap on element refs kept for display; does not affect
+ *   `count`.
+ * @internal
+ */
+export declare function recordAffectedElement(batch: BatchedWarning, element: HTMLElement | undefined, maxDisplayed: number): void;
 export {};