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

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

@@ -0,0 +1,35 @@
+import { Placement as FloatingPlacement } from '@floating-ui/dom';
+import { Placement } from './types.js';
+/** Writing direction used to resolve logical sides to physical sides. */
+export type Direction = 'ltr' | 'rtl';
+/**
+ * Normalize a hyphenated `Placement` for Floating UI's `computePosition`.
+ *
+ * - Logical **sides** (`start`, `end`) resolve to `left` / `right` per the
+ *   `direction` argument (`start` is left in LTR, right in RTL). Floating UI
+ *   has no logical primary side, so this must be resolved here for the panel
+ *   to land on the correct side.
+ * - Logical **alignments** (`bottom-start`, `top-end`) pass through unchanged —
+ *   Floating UI's own RTL handling flips those, so they must not be flipped here.
+ * - Physical alignments (`bottom-left`, `left-top`, `start-top`, etc.) map to
+ *   the nearest Floating UI placement.
+ *
+ * @param placement - Customer-facing hyphenated placement.
+ * @param direction - Writing direction of the trigger; defaults to `'ltr'`.
+ * @returns Placement value understood by Floating UI.
+ */
+export declare function toFloatingPlacement(placement: Placement, direction?: Direction): FloatingPlacement;
+/**
+ * Surface a Floating UI placement as the public hyphenated `Placement`
+ * form for `actualPlacement` and `onPlacementChange`.
+ *
+ * Floating UI emits four placements that don't appear in the SWC `Placement`
+ * union (`left-start`, `left-end`, `right-start`, `right-end`) — those map
+ * back to their physical equivalents (`left-top`, `left-bottom`, `right-top`,
+ * `right-bottom`). The remaining eight Floating UI placements are already
+ * valid SWC `Placement` values.
+ *
+ * @param placement - Placement returned by Floating UI after `flip`.
+ * @returns Customer-facing hyphenated placement in the SWC `Placement` union.
+ */
+export declare function fromFloatingPlacement(placement: FloatingPlacement): Placement;

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

@@ -0,0 +1,54 @@
+//#region controllers/placement-controller/src/placement-conversion.ts
+var e = new Set(["start", "end"]), t = {
+	ltr: {
+		start: "left",
+		end: "right"
+	},
+	rtl: {
+		start: "right",
+		end: "left"
+	}
+}, n = {
+	start: "left",
+	end: "right"
+}, r = {
+	bottom: {
+		left: "bottom-start",
+		right: "bottom-end"
+	},
+	top: {
+		left: "top-start",
+		right: "top-end"
+	},
+	left: {
+		top: "left-start",
+		bottom: "left-end"
+	},
+	right: {
+		top: "right-start",
+		bottom: "right-end"
+	}
+}, i = {
+	"left-start": "left-top",
+	"left-end": "left-bottom",
+	"right-start": "right-top",
+	"right-end": "right-bottom"
+};
+function a(i, a = "ltr") {
+	var o;
+	let [s, c] = i.split("-");
+	if (e.has(s)) {
+		var l, u, d;
+		let e = (l = t[a][s]) == null ? s : l;
+		return c ? ((u = r[e]) == null ? void 0 : u[c]) || `${e}-${(d = n[c]) == null ? c : d}` : e;
+	}
+	return c ? c === "start" || c === "end" ? `${s}-${c}` : ((o = r[s]) == null ? void 0 : o[c]) || `${s}-${c}` : s;
+}
+function o(e) {
+	var t;
+	return (t = i[e]) == null ? e : t;
+}
+//#endregion
+export { o as fromFloatingPlacement, a as toFloatingPlacement };
+
+//# sourceMappingURL=placement-conversion.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"placement-conversion.js","names":[],"sources":["../../../../controllers/placement-controller/src/placement-conversion.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\nimport type { Placement } from './types.js';\n\n/** Writing direction used to resolve logical sides to physical sides. */\nexport type Direction = 'ltr' | 'rtl';\n\nconst LOGICAL_SIDES = new Set(['start', 'end']);\n\n/**\n * Logical inline **sides** resolve to physical sides per the writing direction:\n * `start` is the left in LTR and the right in RTL (and vice versa for `end`).\n * Floating UI has no logical primary side, so this resolution must happen here\n * — the physical side it receives is what determines which side it positions on.\n */\nconst LOGICAL_SIDE_TO_PHYSICAL: Record<Direction, Record<string, string>> = {\n  ltr: { start: 'left', end: 'right' },\n  rtl: { start: 'right', end: 'left' },\n};\n\n/**\n * Logical **alignment** fallback for a logical side paired with a logical\n * alignment. Cross-axis alignment for left/right sides is vertical, so it is\n * direction-independent; this is only a guard for inputs outside the standard\n * placement set.\n */\nconst LOGICAL_TO_PHYSICAL: Record<string, string> = {\n  start: 'left',\n  end: 'right',\n};\n\n/**\n * Physical cross-axis labels mapped to Floating UI's start/end alignment on\n * each primary side. Floating UI only supports `start` / `end` alignment\n * suffixes; SWC exposes physical (`top`/`bottom`/`left`/`right`) cross-axis\n * names that this table translates.\n */\nconst PHYSICAL_ALIGNMENT_TO_FLOATING: Record<\n  string,\n  Record<string, FloatingPlacement>\n> = {\n  bottom: { left: 'bottom-start', right: 'bottom-end' },\n  top: { left: 'top-start', right: 'top-end' },\n  left: { top: 'left-start', bottom: 'left-end' },\n  right: { top: 'right-start', bottom: 'right-end' },\n};\n\n/**\n * Reverse lookup for Floating UI placements that aren't valid SWC Placement\n * values. Used by `fromFloatingPlacement` to map the four Floating UI\n * outputs that have no direct SWC equivalent (`left-start`, `left-end`,\n * `right-start`, `right-end`) back into the SWC union. Other Floating UI\n * placements are already valid Placement values and pass through unchanged.\n */\nconst FLOATING_TO_SWC_PLACEMENT: Partial<Record<FloatingPlacement, Placement>> =\n  {\n    'left-start': 'left-top',\n    'left-end': 'left-bottom',\n    'right-start': 'right-top',\n    'right-end': 'right-bottom',\n  };\n\n/**\n * Normalize a hyphenated `Placement` for Floating UI's `computePosition`.\n *\n * - Logical **sides** (`start`, `end`) resolve to `left` / `right` per the\n *   `direction` argument (`start` is left in LTR, right in RTL). Floating UI\n *   has no logical primary side, so this must be resolved here for the panel\n *   to land on the correct side.\n * - Logical **alignments** (`bottom-start`, `top-end`) pass through unchanged —\n *   Floating UI's own RTL handling flips those, so they must not be flipped here.\n * - Physical alignments (`bottom-left`, `left-top`, `start-top`, etc.) map to\n *   the nearest Floating UI placement.\n *\n * @param placement - Customer-facing hyphenated placement.\n * @param direction - Writing direction of the trigger; defaults to `'ltr'`.\n * @returns Placement value understood by Floating UI.\n */\nexport function toFloatingPlacement(\n  placement: Placement,\n  direction: Direction = 'ltr'\n): FloatingPlacement {\n  const [primary, alignment] = placement.split('-') as [string, string?];\n\n  if (LOGICAL_SIDES.has(primary)) {\n    const physicalPrimary =\n      LOGICAL_SIDE_TO_PHYSICAL[direction][primary] ?? primary;\n    if (!alignment) {\n      return physicalPrimary as FloatingPlacement;\n    }\n    // For logical sides combined with a physical sub-alignment\n    // (e.g. `start-top`, `end-bottom`), use the physical-alignment table on\n    // the resolved physical side. Without this, the function returns\n    // strings like `left-top` that aren't valid Floating UI placements.\n    const mapped = PHYSICAL_ALIGNMENT_TO_FLOATING[physicalPrimary]?.[alignment];\n    if (mapped) {\n      return mapped;\n    }\n    const physicalAlignment = LOGICAL_TO_PHYSICAL[alignment] ?? alignment;\n    return `${physicalPrimary}-${physicalAlignment}` as FloatingPlacement;\n  }\n\n  if (!alignment) {\n    return primary as FloatingPlacement;\n  }\n\n  if (alignment === 'start' || alignment === 'end') {\n    return `${primary}-${alignment}` as FloatingPlacement;\n  }\n\n  const mapped = PHYSICAL_ALIGNMENT_TO_FLOATING[primary]?.[alignment];\n  if (mapped) {\n    return mapped;\n  }\n\n  return `${primary}-${alignment}` as FloatingPlacement;\n}\n\n/**\n * Surface a Floating UI placement as the public hyphenated `Placement`\n * form for `actualPlacement` and `onPlacementChange`.\n *\n * Floating UI emits four placements that don't appear in the SWC `Placement`\n * union (`left-start`, `left-end`, `right-start`, `right-end`) — those map\n * back to their physical equivalents (`left-top`, `left-bottom`, `right-top`,\n * `right-bottom`). The remaining eight Floating UI placements are already\n * valid SWC `Placement` values.\n *\n * @param placement - Placement returned by Floating UI after `flip`.\n * @returns Customer-facing hyphenated placement in the SWC `Placement` union.\n */\nexport function fromFloatingPlacement(placement: FloatingPlacement): Placement {\n  return FLOATING_TO_SWC_PLACEMENT[placement] ?? (placement as Placement);\n}\n"],"mappings":";AAmBA,IAAM,IAAgB,IAAI,IAAI,CAAC,SAAS,MAAM,CAAC,EAQzC,IAAsE;CAC1E,KAAK;EAAE,OAAO;EAAQ,KAAK;EAAS;CACpC,KAAK;EAAE,OAAO;EAAS,KAAK;EAAQ;CACrC,EAQK,IAA8C;CAClD,OAAO;CACP,KAAK;CACN,EAQK,IAGF;CACF,QAAQ;EAAE,MAAM;EAAgB,OAAO;EAAc;CACrD,KAAK;EAAE,MAAM;EAAa,OAAO;EAAW;CAC5C,MAAM;EAAE,KAAK;EAAc,QAAQ;EAAY;CAC/C,OAAO;EAAE,KAAK;EAAe,QAAQ;EAAa;CACnD,EASK,IACJ;CACE,cAAc;CACd,YAAY;CACZ,eAAe;CACf,aAAa;CACd;AAkBH,SAAgB,EACd,GACA,IAAuB,OACJ;;CACnB,IAAM,CAAC,GAAS,KAAa,EAAU,MAAM,IAAI;AAEjD,KAAI,EAAc,IAAI,EAAQ,EAAE;;EAC9B,IAAM,KAAA,IACJ,EAAyB,GAAW,OAAA,OAAY,IAAZ;AAatC,SAZK,MAOC,IAAS,EAA+B,OAAA,OAAA,KAAA,IAAA,EAAmB,OAK1D,GAAG,EAAgB,IAAA,IADA,EAAoB,OAAA,OAAc,IAAd,MAVrC;;AA2BX,QAbK,IAID,MAAc,WAAW,MAAc,QAClC,GAAG,EAAQ,GAAG,QAGjB,IAAS,EAA+B,OAAA,OAAA,KAAA,IAAA,EAAW,OAKlD,GAAG,EAAQ,GAAG,MAZZ;;AA4BX,SAAgB,EAAsB,GAAyC;;AAC7E,SAAA,IAAO,EAA0B,OAAA,OAAe,IAAf"}

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

@@ -0,0 +1,128 @@
+/**
+ * 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.
+ */
+/**
+ * The full set of hyphenated placement values accepted by the public API
+ * (`'bottom'`, `'bottom-start'`, `'start-top'`, etc.).
+ *
+ * Physical-alignment variants (`top-left`, `bottom-right`) are distinct from
+ * logical-alignment variants (`top-start`, `bottom-end`) — physical stays fixed
+ * regardless of direction; logical reverses in RTL via CSS.
+ */
+export declare const ALL_PLACEMENTS: readonly ["bottom", "bottom-left", "bottom-right", "bottom-start", "bottom-end", "top", "top-left", "top-right", "top-start", "top-end", "left", "left-top", "left-bottom", "start", "start-top", "start-bottom", "right", "right-top", "right-bottom", "end", "end-top", "end-bottom"];
+/**
+ * The placement of the element with respect to its anchor element
+ * (hyphenated form).
+ */
+export type Placement = (typeof ALL_PLACEMENTS)[number];
+/**
+ * A virtual trigger reference accepted by `PlacementController`. Mirrors
+ * the Floating UI virtual-element shape: anything that can report its bounding
+ * rect and (optionally) its context element is a valid anchor.
+ */
+export interface VirtualTrigger {
+    getBoundingClientRect(): DOMRect;
+    contextElement?: Element;
+}
+/**
+ * Options passed to `PlacementController.start`.
+ */
+export interface PlacementOptions {
+    /**
+     * Preferred side and alignment of the floating element relative to the
+     * **trigger** (hyphenated, for example `'bottom'`, `'bottom-start'`).
+     *
+     * This is the requested placement. When `shouldFlip` is enabled,
+     * Floating UI may compute a different side if the requested one does not fit.
+     * The result is surfaced on `PlacementController.actualPlacement` and
+     * via `onPlacementChange`.
+     *
+     * @default 'bottom'
+     */
+    placement?: Placement;
+    /**
+     * Gap along the **placement direction** between the trigger and the floating
+     * element, in pixels (Floating UI `offset` main axis).
+     *
+     * For `'bottom'`, this is the space below the trigger. This is **not**
+     * viewport padding — see `containerPadding` for inset from the overflow
+     * boundary.
+     *
+     * Defaults to `0` so the controller-host contract stays neutral; each
+     * consuming component sets its own pattern-specific default.
+     *
+     * @default 0
+     */
+    offset?: number;
+    /**
+     * Slide along the **trigger edge**, perpendicular to the placement
+     * direction, in pixels (Floating UI `offset` cross axis).
+     *
+     * Adjusts alignment such as `'bottom-start'` vs `'bottom-end'` without
+     * changing viewport inset. This is **not** `containerPadding`.
+     *
+     * @default 0
+     */
+    crossOffset?: number;
+    /**
+     * Minimum inset from the **overflow boundary**, in pixels, used for
+     * collision detection.
+     *
+     * Floating UI applies this as padding around the boundary it uses for
+     * collision detection. By default that is the floating element's clipping
+     * ancestors, capped by the visual viewport — so fixed or top-layer popovers
+     * usually behave like screen-edge inset, while surfaces inside a scrollable
+     * clipping parent use that container's edges instead.
+     *
+     * This is **not** the gap from the trigger — use `offset` and
+     * `crossOffset` for trigger-relative spacing.
+     *
+     * @default 8
+     */
+    containerPadding?: number;
+    /**
+     * Whether Floating UI may **flip** the floating element to the opposite side when the
+     * requested `placement` does not fit within the overflow boundary.
+     *
+     * When `false`, the floating element stays on the requested side even if it
+     * overflows — useful for tooltips that must not jump above the trigger.
+     *
+     * @default true
+     */
+    shouldFlip?: boolean;
+    /**
+     * Optional tip element ("arrow") that should point at the trigger from
+     * the floating element's edge. When provided, the controller installs
+     * Floating UI's `arrow` middleware and writes an inline `translate` on
+     * this element after every compute so it stays aligned with the trigger
+     * even when `shift` slides the floating panel sideways. CSS positions
+     * the tip relative to the floating element's edge (typically with a
+     * negative offset for the half-size of the arrow); the controller only
+     * moves it along that edge.
+     */
+    tipElement?: HTMLElement;
+    /**
+     * Minimum inset of the tip element from the floating element's
+     * corners, in pixels. Passed straight to the `arrow` middleware as
+     * its `padding`. Only meaningful when `tipElement` is provided.
+     *
+     * @default 8
+     */
+    tipPadding?: number;
+    /**
+     * Called with the computed hyphenated placement, on change only: once after
+     * the first compute, then again whenever an `autoUpdate` tick produces a
+     * different value. Computes that resolve to the same placement do not
+     * re-notify, so wiring this to reactive state will not re-render on every
+     * scroll or resize.
+     */
+    onPlacementChange?: (placement: Placement) => void;
+}

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

@@ -0,0 +1,29 @@
+//#region controllers/placement-controller/src/types.ts
+var e = [
+	"bottom",
+	"bottom-left",
+	"bottom-right",
+	"bottom-start",
+	"bottom-end",
+	"top",
+	"top-left",
+	"top-right",
+	"top-start",
+	"top-end",
+	"left",
+	"left-top",
+	"left-bottom",
+	"start",
+	"start-top",
+	"start-bottom",
+	"right",
+	"right-top",
+	"right-bottom",
+	"end",
+	"end-top",
+	"end-bottom"
+];
+//#endregion
+export { e as ALL_PLACEMENTS };
+
+//# sourceMappingURL=types.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","names":[],"sources":["../../../../controllers/placement-controller/src/types.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\n// ─────────────────────────\n//     PLACEMENT\n// ─────────────────────────\n\n/**\n * The full set of hyphenated placement values accepted by the public API\n * (`'bottom'`, `'bottom-start'`, `'start-top'`, etc.).\n *\n * Physical-alignment variants (`top-left`, `bottom-right`) are distinct from\n * logical-alignment variants (`top-start`, `bottom-end`) — physical stays fixed\n * regardless of direction; logical reverses in RTL via CSS.\n */\nexport const ALL_PLACEMENTS = [\n  'bottom',\n  'bottom-left',\n  'bottom-right',\n  'bottom-start',\n  'bottom-end',\n  'top',\n  'top-left',\n  'top-right',\n  'top-start',\n  'top-end',\n  'left',\n  'left-top',\n  'left-bottom',\n  'start',\n  'start-top',\n  'start-bottom',\n  'right',\n  'right-top',\n  'right-bottom',\n  'end',\n  'end-top',\n  'end-bottom',\n] as const;\n\n/**\n * The placement of the element with respect to its anchor element\n * (hyphenated form).\n */\nexport type Placement = (typeof ALL_PLACEMENTS)[number];\n\n// ─────────────────────────\n//     VIRTUAL TRIGGER\n// ─────────────────────────\n\n/**\n * A virtual trigger reference accepted by `PlacementController`. Mirrors\n * the Floating UI virtual-element shape: anything that can report its bounding\n * rect and (optionally) its context element is a valid anchor.\n */\nexport interface VirtualTrigger {\n  getBoundingClientRect(): DOMRect;\n  contextElement?: Element;\n}\n\n// ─────────────────────────\n//     OPTIONS\n// ─────────────────────────\n\n/**\n * Options passed to `PlacementController.start`.\n */\nexport interface PlacementOptions {\n  /**\n   * Preferred side and alignment of the floating element relative to the\n   * **trigger** (hyphenated, for example `'bottom'`, `'bottom-start'`).\n   *\n   * This is the requested placement. When `shouldFlip` is enabled,\n   * Floating UI may compute a different side if the requested one does not fit.\n   * The result is surfaced on `PlacementController.actualPlacement` and\n   * via `onPlacementChange`.\n   *\n   * @default 'bottom'\n   */\n  placement?: Placement;\n\n  /**\n   * Gap along the **placement direction** between the trigger and the floating\n   * element, in pixels (Floating UI `offset` main axis).\n   *\n   * For `'bottom'`, this is the space below the trigger. This is **not**\n   * viewport padding — see `containerPadding` for inset from the overflow\n   * boundary.\n   *\n   * Defaults to `0` so the controller-host contract stays neutral; each\n   * consuming component sets its own pattern-specific default.\n   *\n   * @default 0\n   */\n  offset?: number;\n\n  /**\n   * Slide along the **trigger edge**, perpendicular to the placement\n   * direction, in pixels (Floating UI `offset` cross axis).\n   *\n   * Adjusts alignment such as `'bottom-start'` vs `'bottom-end'` without\n   * changing viewport inset. This is **not** `containerPadding`.\n   *\n   * @default 0\n   */\n  crossOffset?: number;\n\n  /**\n   * Minimum inset from the **overflow boundary**, in pixels, used for\n   * collision detection.\n   *\n   * Floating UI applies this as padding around the boundary it uses for\n   * collision detection. By default that is the floating element's clipping\n   * ancestors, capped by the visual viewport — so fixed or top-layer popovers\n   * usually behave like screen-edge inset, while surfaces inside a scrollable\n   * clipping parent use that container's edges instead.\n   *\n   * This is **not** the gap from the trigger — use `offset` and\n   * `crossOffset` for trigger-relative spacing.\n   *\n   * @default 8\n   */\n  containerPadding?: number;\n\n  /**\n   * Whether Floating UI may **flip** the floating element to the opposite side when the\n   * requested `placement` does not fit within the overflow boundary.\n   *\n   * When `false`, the floating element stays on the requested side even if it\n   * overflows — useful for tooltips that must not jump above the trigger.\n   *\n   * @default true\n   */\n  shouldFlip?: boolean;\n\n  /**\n   * Optional tip element (\"arrow\") that should point at the trigger from\n   * the floating element's edge. When provided, the controller installs\n   * Floating UI's `arrow` middleware and writes an inline `translate` on\n   * this element after every compute so it stays aligned with the trigger\n   * even when `shift` slides the floating panel sideways. CSS positions\n   * the tip relative to the floating element's edge (typically with a\n   * negative offset for the half-size of the arrow); the controller only\n   * moves it along that edge.\n   */\n  tipElement?: HTMLElement;\n\n  /**\n   * Minimum inset of the tip element from the floating element's\n   * corners, in pixels. Passed straight to the `arrow` middleware as\n   * its `padding`. Only meaningful when `tipElement` is provided.\n   *\n   * @default 8\n   */\n  tipPadding?: number;\n\n  /**\n   * Called with the computed hyphenated placement, on change only: once after\n   * the first compute, then again whenever an `autoUpdate` tick produces a\n   * different value. Computes that resolve to the same placement do not\n   * re-notify, so wiring this to reactive state will not re-render on every\n   * scroll or resize.\n   */\n  onPlacementChange?: (placement: Placement) => void;\n}\n"],"mappings":";AAwBA,IAAa,IAAiB;CAC5B;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACD"}

package/dist/controllers/slot-attribute-propagation-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 { SlotAttributePropagationController, type SlotAttributePropagationControllerOptions, } from './src/slot-attribute-propagation-controller.js';

package/dist/controllers/slot-attribute-propagation-controller/index.js

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

package/dist/controllers/slot-attribute-propagation-controller/src/slot-attribute-propagation-controller.d.ts

@@ -0,0 +1,65 @@
+import { ReactiveController, ReactiveElement } from 'lit';
+export interface SlotAttributePropagationControllerOptions {
+    /** The attribute name to propagate to assigned elements. */
+    attribute: string;
+    /**
+     * Returns the current value to propagate. Return `null` to remove the
+     * attribute from assigned elements, for attributes that are only
+     * sometimes present on the host.
+     */
+    getValue: () => string | null;
+    /** Named slot to target. Omit for the default (unnamed) slot. */
+    slotName?: string;
+    /**
+     * CSS selector used to filter assigned elements before propagating.
+     * Omit to propagate to all assigned elements.
+     */
+    selector?: string;
+}
+/**
+ * A Lit {@link ReactiveController} that propagates an attribute from the host
+ * element to elements assigned to one of its slots.
+ *
+ * The controller automatically re-propagates in `hostUpdated()` whenever the
+ * value returned by `getValue` changes. Call `propagate()` from the host's
+ * `slotchange` handler to cover elements inserted after the first render.
+ *
+ * `getValue` may return `null` for attributes that are only sometimes present
+ * on the host; the controller removes the attribute from assigned elements
+ * rather than setting it to an empty string.
+ *
+ * @example
+ * ```ts
+ * class MyBase extends SpectrumElement {
+ *   @property({ type: String, reflect: true })
+ *   public size: MySize = 'm';
+ *
+ *   private readonly _sizePropagation = new SlotAttributePropagationController(this, {
+ *     attribute: 'size',
+ *     getValue: () => this.size,
+ *     slotName: 'actions',
+ *   });
+ *
+ *   protected handleActionsSlotChange(): void {
+ *     this._sizePropagation.propagate();
+ *   }
+ * }
+ * ```
+ */
+export declare class SlotAttributePropagationController implements ReactiveController {
+    private readonly _host;
+    private readonly _options;
+    private _previousValue?;
+    constructor(host: ReactiveElement, options: SlotAttributePropagationControllerOptions);
+    hostDisconnected(): void;
+    hostUpdated(): void;
+    /**
+     * Propagates the current value to all matching assigned elements
+     * immediately, updating the value tracked for the `hostUpdated()` no-op
+     * guard so it isn't repeated once the pending update runs. Call this from
+     * the host's `slotchange` event handler.
+     */
+    propagate(): void;
+    private _propagateToSlot;
+    private _resolveSlot;
+}

package/dist/controllers/slot-attribute-propagation-controller/src/slot-attribute-propagation-controller.js

@@ -0,0 +1,33 @@
+//#region controllers/slot-attribute-propagation-controller/src/slot-attribute-propagation-controller.ts
+var e = class {
+	constructor(e, t) {
+		this._host = e, this._options = t, e.addController(this);
+	}
+	hostDisconnected() {
+		this._previousValue = void 0;
+	}
+	hostUpdated() {
+		let e = this._options.getValue();
+		e !== this._previousValue && this._propagateToSlot(e);
+	}
+	propagate() {
+		this._propagateToSlot(this._options.getValue());
+	}
+	_propagateToSlot(e) {
+		let t = this._resolveSlot();
+		if (!t) return;
+		this._previousValue = e;
+		let n = t.assignedElements({ flatten: !0 }), r = this._options.selector ? n.filter((e) => e.matches(this._options.selector)) : n;
+		for (let t of r) e === null ? t.removeAttribute(this._options.attribute) : t.setAttribute(this._options.attribute, e);
+	}
+	_resolveSlot() {
+		let e = this._host.shadowRoot;
+		if (!e) return null;
+		let { slotName: t } = this._options;
+		return t ? e.querySelector(`slot[name="${t}"]`) : e.querySelector("slot:not([name])");
+	}
+};
+//#endregion
+export { e as SlotAttributePropagationController };
+
+//# sourceMappingURL=slot-attribute-propagation-controller.js.map

package/dist/controllers/slot-attribute-propagation-controller/src/slot-attribute-propagation-controller.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"slot-attribute-propagation-controller.js","names":[],"sources":["../../../../controllers/slot-attribute-propagation-controller/src/slot-attribute-propagation-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//     TYPES\n// ─────────────────────────\n\nexport interface SlotAttributePropagationControllerOptions {\n  /** The attribute name to propagate to assigned elements. */\n  attribute: string;\n\n  /**\n   * Returns the current value to propagate. Return `null` to remove the\n   * attribute from assigned elements, for attributes that are only\n   * sometimes present on the host.\n   */\n  getValue: () => string | null;\n  /** Named slot to target. Omit for the default (unnamed) slot. */\n  slotName?: string;\n\n  /**\n   * CSS selector used to filter assigned elements before propagating.\n   * Omit to propagate to all assigned elements.\n   */\n  selector?: string;\n}\n\n// ─────────────────────────────────────────────────────────────────\n//     CONTROLLER\n// ─────────────────────────────────────────────────────────────────\n\n/**\n * A Lit {@link ReactiveController} that propagates an attribute from the host\n * element to elements assigned to one of its slots.\n *\n * The controller automatically re-propagates in `hostUpdated()` whenever the\n * value returned by `getValue` changes. Call `propagate()` from the host's\n * `slotchange` handler to cover elements inserted after the first render.\n *\n * `getValue` may return `null` for attributes that are only sometimes present\n * on the host; the controller removes the attribute from assigned elements\n * rather than setting it to an empty string.\n *\n * @example\n * ```ts\n * class MyBase extends SpectrumElement {\n *   @property({ type: String, reflect: true })\n *   public size: MySize = 'm';\n *\n *   private readonly _sizePropagation = new SlotAttributePropagationController(this, {\n *     attribute: 'size',\n *     getValue: () => this.size,\n *     slotName: 'actions',\n *   });\n *\n *   protected handleActionsSlotChange(): void {\n *     this._sizePropagation.propagate();\n *   }\n * }\n * ```\n */\nexport class SlotAttributePropagationController implements ReactiveController {\n  private readonly _host: ReactiveElement;\n  private readonly _options: SlotAttributePropagationControllerOptions;\n  private _previousValue?: string | null;\n\n  constructor(\n    host: ReactiveElement,\n    options: SlotAttributePropagationControllerOptions\n  ) {\n    this._host = host;\n    this._options = options;\n    host.addController(this);\n  }\n\n  public hostDisconnected(): void {\n    this._previousValue = undefined;\n  }\n\n  public hostUpdated(): void {\n    const value = this._options.getValue();\n    if (value !== this._previousValue) {\n      this._propagateToSlot(value);\n    }\n  }\n\n  /**\n   * Propagates the current value to all matching assigned elements\n   * immediately, updating the value tracked for the `hostUpdated()` no-op\n   * guard so it isn't repeated once the pending update runs. Call this from\n   * the host's `slotchange` event handler.\n   */\n  public propagate(): void {\n    this._propagateToSlot(this._options.getValue());\n  }\n\n  private _propagateToSlot(value: string | null): void {\n    const slot = this._resolveSlot();\n    if (!slot) {\n      return;\n    }\n    // Tracked here (not just in hostUpdated()) so a propagate() call from a\n    // slotchange handler also updates the no-op guard; otherwise a\n    // subsequently-scheduled hostUpdated() with the same value would repeat\n    // the same setAttribute()/removeAttribute() sweep over every target. Set\n    // only once the slot resolves: if a call (from either hostUpdated() or\n    // propagate()) can't resolve the slot yet, the value must not be marked\n    // as applied, or a slot that resolves later with an unchanged value\n    // would be silently skipped forever.\n    this._previousValue = value;\n    const assigned = slot.assignedElements({ flatten: true });\n    const targets = this._options.selector\n      ? assigned.filter((el) => el.matches(this._options.selector!))\n      : assigned;\n    for (const el of targets) {\n      if (value === null) {\n        el.removeAttribute(this._options.attribute);\n      } else {\n        el.setAttribute(this._options.attribute, value);\n      }\n    }\n  }\n\n  private _resolveSlot(): HTMLSlotElement | null {\n    const root = this._host.shadowRoot;\n    if (!root) {\n      return null;\n    }\n    const { slotName } = this._options;\n    return slotName\n      ? root.querySelector<HTMLSlotElement>(`slot[name=\"${slotName}\"]`)\n      : root.querySelector<HTMLSlotElement>('slot:not([name])');\n  }\n}\n"],"mappings":";AAwEA,IAAa,IAAb,MAA8E;CAK5E,YACE,GACA,GACA;AAGA,EAFA,KAAK,QAAQ,GACb,KAAK,WAAW,GAChB,EAAK,cAAc,KAAK;;CAG1B,mBAAgC;AAC9B,OAAK,iBAAiB,KAAA;;CAGxB,cAA2B;EACzB,IAAM,IAAQ,KAAK,SAAS,UAAU;AACtC,EAAI,MAAU,KAAK,kBACjB,KAAK,iBAAiB,EAAM;;CAUhC,YAAyB;AACvB,OAAK,iBAAiB,KAAK,SAAS,UAAU,CAAC;;CAGjD,iBAAyB,GAA4B;EACnD,IAAM,IAAO,KAAK,cAAc;AAChC,MAAI,CAAC,EACH;AAUF,OAAK,iBAAiB;EACtB,IAAM,IAAW,EAAK,iBAAiB,EAAE,SAAS,IAAM,CAAC,EACnD,IAAU,KAAK,SAAS,WAC1B,EAAS,QAAQ,MAAO,EAAG,QAAQ,KAAK,SAAS,SAAU,CAAC,GAC5D;AACJ,OAAK,IAAM,KAAM,EACf,CAAI,MAAU,OACZ,EAAG,gBAAgB,KAAK,SAAS,UAAU,GAE3C,EAAG,aAAa,KAAK,SAAS,WAAW,EAAM;;CAKrD,eAA+C;EAC7C,IAAM,IAAO,KAAK,MAAM;AACxB,MAAI,CAAC,EACH,QAAO;EAET,IAAM,EAAE,gBAAa,KAAK;AAC1B,SAAO,IACH,EAAK,cAA+B,cAAc,EAAS,IAAI,GAC/D,EAAK,cAA+B,mBAAmB"}

package/dist/controllers/slot-presence-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 { SlotPresenceController } from './src/slot-presence-controller.js';

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

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

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

@@ -0,0 +1,57 @@
+import { ReactiveController, ReactiveElement } from 'lit';
+/**
+ * A reactive controller that observes whether slotted content matching
+ * given CSS selectors is present in the host's light DOM.
+ *
+ * Replaces the `ObserveSlotPresence` mixin with a composition-based approach.
+ *
+ * @example
+ * ```typescript
+ * class MyComponent extends SpectrumElement {
+ *   private slotPresence = new SlotPresenceController(this, '[slot="icon"]');
+ *
+ *   get hasIcon(): boolean {
+ *     return this.slotPresence.isPresent;
+ *   }
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Observing multiple selectors
+ * class MyComponent extends SpectrumElement {
+ *   private slotPresence = new SlotPresenceController(this, [
+ *     '[slot="icon"]',
+ *     '[slot="description"]',
+ *   ]);
+ *
+ *   get hasIcon(): boolean {
+ *     return this.slotPresence.getPresence('[slot="icon"]');
+ *   }
+ *
+ *   get hasDescription(): boolean {
+ *     return this.slotPresence.getPresence('[slot="description"]');
+ *   }
+ * }
+ * ```
+ */
+export declare class SlotPresenceController implements ReactiveController {
+    private host;
+    private selectors;
+    private presenceMap;
+    private observer;
+    constructor(host: ReactiveElement, selectors: string | string[]);
+    /**
+     * Whether slotted content is present. Use this when observing a single
+     * selector. Throws if multiple selectors were provided — use
+     * `getPresence(selector)` instead.
+     */
+    get isPresent(): boolean;
+    /**
+     * Returns whether content matching the given selector is present.
+     */
+    getPresence(selector: string): boolean;
+    private checkPresence;
+    hostConnected(): void;
+    hostDisconnected(): void;
+}

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 };