@material/web 2.4.2-nightly.a589695.0 → 2.4.2-nightly.b4af72e.0

package/labs/gb/components/ripple/ripple.d.ts

@@ -0,0 +1,77 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { type ClassInfo } from 'lit/directives/class-map.js';
+/** Ripple classes. */
+export declare const RIPPLE_CLASSES: {
+    ripple: string;
+    rippleTarget: string;
+    rippleHost: string;
+    hover: string;
+    active: string;
+    disabled: string;
+};
+/** The state provided to the `rippleClasses()` function. */
+export interface RippleClassesState {
+    /** Emulates `:hover`. */
+    hover?: boolean;
+    /** Emulates `:active`. */
+    active?: boolean;
+    /** Emulates `:disabled`. */
+    disabled?: boolean;
+}
+/**
+ * Returns the ripple classes to apply to an element based on the given state.
+ *
+ * @param state The state of the ripple.
+ * @return An object of class names and truthy values if they apply.
+ */
+export declare function rippleClasses({ hover, active, disabled, }?: RippleClassesState): ClassInfo;
+/**
+ * Sets up ripple functionality for the given element.
+ *
+ * @param ripple The element on which to set up ripple functionality.
+ * @param opts Setup options, supports a cleanup `signal`.
+ */
+export declare function setupRipple(ripple: HTMLElement, opts?: {
+    signal?: AbortSignal;
+}): void;
+/**
+ * A Lit directive that adds updates the position of a ripple to match pointer
+ * interactions. Use with the `.ripple` class.
+ *
+ * @example
+ * ```ts
+ * class Component extends LitElement {
+ *   static styles = [rippleStyles, css`...`];
+ *
+ *   render() {
+ *     return html`<button class="ripple" ${ripple()}>Ripple effect</button>`;
+ *   }
+ * }
+ * ```
+ *
+ * Use the `.ripple-target` class if the interactive element is a parent or
+ * child of the ripple element.
+ *
+ * The `ripple()` directive should be applied to the parent element, which may
+ * be the `.ripple-target` instead of the `.ripple`.
+ *
+ * @example
+ * ```ts
+ * html`
+ *   <div class="card ripple" ${ripple()}>
+ *     Child interactive element
+ *     <button class="ripple-target card-btn"></button>
+ *   </div>
+ *
+ *   <button class="ripple-target" ${ripple()}>
+ *     Parent interactive element
+ *     <span class="ripple"></span>
+ *   </button>
+ * `;
+ * ```
+ */
+export declare const ripple: () => import("lit-html/directive.js").DirectiveResult;

package/labs/gb/components/ripple/ripple.js

@@ -0,0 +1,148 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { createElementDirective } from '../shared/directives.js';
+import { PSEUDO_CLASSES, isDisabled } from '../shared/pseudo-classes.js';
+/** Ripple classes. */
+export const RIPPLE_CLASSES = {
+    ripple: 'ripple',
+    rippleTarget: 'ripple-target',
+    rippleHost: 'ripple-host',
+    hover: PSEUDO_CLASSES.hover,
+    active: PSEUDO_CLASSES.active,
+    disabled: PSEUDO_CLASSES.disabled,
+};
+/**
+ * Returns the ripple classes to apply to an element based on the given state.
+ *
+ * @param state The state of the ripple.
+ * @return An object of class names and truthy values if they apply.
+ */
+export function rippleClasses({ hover = false, active = false, disabled = false, } = {}) {
+    return {
+        [RIPPLE_CLASSES.ripple]: true,
+        [RIPPLE_CLASSES.hover]: hover,
+        [RIPPLE_CLASSES.active]: active,
+        [RIPPLE_CLASSES.disabled]: disabled,
+    };
+}
+const MINIMUM_PRESS_MS = 225;
+let ripplePropertiesRegistered = false;
+/**
+ * Sets up ripple functionality for the given element.
+ *
+ * @param ripple The element on which to set up ripple functionality.
+ * @param opts Setup options, supports a cleanup `signal`.
+ */
+export function setupRipple(ripple, opts) {
+    if (!ripplePropertiesRegistered) {
+        const properties = [
+            ['--ripple-scale', '0%'],
+            ['--ripple-hover-opacity', '0%'],
+            ['--ripple-press-opacity', '0%'],
+            ['--ripple-x', '50%'],
+            ['--ripple-y', '50%'],
+        ];
+        try {
+            for (const [property, value] of properties) {
+                CSS.registerProperty({
+                    name: property,
+                    syntax: '<percentage>',
+                    inherits: false,
+                    initialValue: value,
+                });
+            }
+        }
+        catch {
+            // Ignore errors if the properties are already registered.
+        }
+        finally {
+            ripplePropertiesRegistered = true;
+        }
+    }
+    let minimumPressTimeoutId;
+    const activateRipple = () => {
+        // If the ripple is already active, restart the current press animation.
+        if (ripple.classList.contains(RIPPLE_CLASSES.active)) {
+            const pressAnimation = ripple
+                .getAnimations()
+                .find((animation) => animation.animationName ===
+                'ripple-press');
+            pressAnimation?.cancel();
+            pressAnimation?.play();
+        }
+        // Emulate the `:active` class for a minimum press duration to show the
+        // ripple effect on short clicks.
+        ripple.classList.add(RIPPLE_CLASSES.active);
+        clearTimeout(minimumPressTimeoutId);
+        minimumPressTimeoutId = setTimeout(() => {
+            ripple.classList.remove(RIPPLE_CLASSES.active);
+        }, MINIMUM_PRESS_MS);
+    };
+    // Return true if the ripple is disabled, or if the ripple class has been
+    // removed. This allows components to disable and re-enable ripple behavior.
+    const isRippleDisabled = () => isDisabled(ripple) || !ripple.matches(`.${RIPPLE_CLASSES.ripple}`);
+    ripple.addEventListener('pointerdown', (event) => {
+        if (isRippleDisabled())
+            return;
+        // Set ripple position to the pointer position.
+        const rect = ripple.getBoundingClientRect();
+        const x = (event.clientX - rect.x) / rect.width;
+        const y = (event.clientY - rect.y) / rect.height;
+        ripple.style.setProperty('--ripple-x', `${x * 100}%`);
+        ripple.style.setProperty('--ripple-y', `${y * 100}%`);
+        activateRipple();
+    }, opts);
+    ripple.addEventListener('keydown', (event) => {
+        // Reset ripple pointer position when a key is pressed.
+        ripple.style.removeProperty('--ripple-x');
+        ripple.style.removeProperty('--ripple-y');
+    }, opts);
+    ripple.addEventListener('click', (event) => {
+        // A UIEvent.detail click count of 0 indicates the click was not triggered
+        // by a pointer. Show the ripple press effect for these clicks as well.
+        if (event.detail === 0 && !isRippleDisabled()) {
+            activateRipple();
+        }
+    }, opts);
+}
+/**
+ * A Lit directive that adds updates the position of a ripple to match pointer
+ * interactions. Use with the `.ripple` class.
+ *
+ * @example
+ * ```ts
+ * class Component extends LitElement {
+ *   static styles = [rippleStyles, css`...`];
+ *
+ *   render() {
+ *     return html`<button class="ripple" ${ripple()}>Ripple effect</button>`;
+ *   }
+ * }
+ * ```
+ *
+ * Use the `.ripple-target` class if the interactive element is a parent or
+ * child of the ripple element.
+ *
+ * The `ripple()` directive should be applied to the parent element, which may
+ * be the `.ripple-target` instead of the `.ripple`.
+ *
+ * @example
+ * ```ts
+ * html`
+ *   <div class="card ripple" ${ripple()}>
+ *     Child interactive element
+ *     <button class="ripple-target card-btn"></button>
+ *   </div>
+ *
+ *   <button class="ripple-target" ${ripple()}>
+ *     Parent interactive element
+ *     <span class="ripple"></span>
+ *   </button>
+ * `;
+ * ```
+ */
+export const ripple = createElementDirective(setupRipple);
+//# sourceMappingURL=ripple.js.map

package/labs/gb/components/ripple/ripple.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ripple.js","sourceRoot":"","sources":["ripple.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright 2026 Google LLC\n * SPDX-License-Identifier: Apache-2.0\n */\n\nimport {type ClassInfo} from 'lit/directives/class-map.js';\nimport {createElementDirective} from '../shared/directives.js';\nimport {PSEUDO_CLASSES, isDisabled} from '../shared/pseudo-classes.js';\n\n/** Ripple classes. */\nexport const RIPPLE_CLASSES = {\n  ripple: 'ripple',\n  rippleTarget: 'ripple-target',\n  rippleHost: 'ripple-host',\n  hover: PSEUDO_CLASSES.hover,\n  active: PSEUDO_CLASSES.active,\n  disabled: PSEUDO_CLASSES.disabled,\n};\n\n/** The state provided to the `rippleClasses()` function. */\nexport interface RippleClassesState {\n  /** Emulates `:hover`. */\n  hover?: boolean;\n  /** Emulates `:active`. */\n  active?: boolean;\n  /** Emulates `:disabled`. */\n  disabled?: boolean;\n}\n\n/**\n * Returns the ripple classes to apply to an element based on the given state.\n *\n * @param state The state of the ripple.\n * @return An object of class names and truthy values if they apply.\n */\nexport function rippleClasses({\n  hover = false,\n  active = false,\n  disabled = false,\n}: RippleClassesState = {}): ClassInfo {\n  return {\n    [RIPPLE_CLASSES.ripple]: true,\n    [RIPPLE_CLASSES.hover]: hover,\n    [RIPPLE_CLASSES.active]: active,\n    [RIPPLE_CLASSES.disabled]: disabled,\n  };\n}\n\nconst MINIMUM_PRESS_MS = 225;\nlet ripplePropertiesRegistered = false;\n\n/**\n * Sets up ripple functionality for the given element.\n *\n * @param ripple The element on which to set up ripple functionality.\n * @param opts Setup options, supports a cleanup `signal`.\n */\nexport function setupRipple(\n  ripple: HTMLElement,\n  opts?: {signal?: AbortSignal},\n): void {\n  if (!ripplePropertiesRegistered) {\n    const properties = [\n      ['--ripple-scale', '0%'],\n      ['--ripple-hover-opacity', '0%'],\n      ['--ripple-press-opacity', '0%'],\n      ['--ripple-x', '50%'],\n      ['--ripple-y', '50%'],\n    ];\n\n    try {\n      for (const [property, value] of properties) {\n        CSS.registerProperty({\n          name: property,\n          syntax: '<percentage>',\n          inherits: false,\n          initialValue: value,\n        });\n      }\n    } catch {\n      // Ignore errors if the properties are already registered.\n    } finally {\n      ripplePropertiesRegistered = true;\n    }\n  }\n\n  let minimumPressTimeoutId: number | undefined;\n  const activateRipple = () => {\n    // If the ripple is already active, restart the current press animation.\n    if (ripple.classList.contains(RIPPLE_CLASSES.active)) {\n      const pressAnimation = ripple\n        .getAnimations()\n        .find(\n          (animation) =>\n            (animation as Partial<CSSAnimation>).animationName ===\n            'ripple-press',\n        );\n      pressAnimation?.cancel();\n      pressAnimation?.play();\n    }\n\n    // Emulate the `:active` class for a minimum press duration to show the\n    // ripple effect on short clicks.\n    ripple.classList.add(RIPPLE_CLASSES.active);\n    clearTimeout(minimumPressTimeoutId);\n    minimumPressTimeoutId = setTimeout(() => {\n      ripple.classList.remove(RIPPLE_CLASSES.active);\n    }, MINIMUM_PRESS_MS);\n  };\n\n  // Return true if the ripple is disabled, or if the ripple class has been\n  // removed. This allows components to disable and re-enable ripple behavior.\n  const isRippleDisabled = () =>\n    isDisabled(ripple) || !ripple.matches(`.${RIPPLE_CLASSES.ripple}`);\n\n  ripple.addEventListener(\n    'pointerdown',\n    (event: PointerEvent): void => {\n      if (isRippleDisabled()) return;\n      // Set ripple position to the pointer position.\n      const rect = ripple.getBoundingClientRect();\n      const x = (event.clientX - rect.x) / rect.width;\n      const y = (event.clientY - rect.y) / rect.height;\n      ripple.style.setProperty('--ripple-x', `${x * 100}%`);\n      ripple.style.setProperty('--ripple-y', `${y * 100}%`);\n      activateRipple();\n    },\n    opts,\n  );\n\n  ripple.addEventListener(\n    'keydown',\n    (event: KeyboardEvent): void => {\n      // Reset ripple pointer position when a key is pressed.\n      ripple.style.removeProperty('--ripple-x');\n      ripple.style.removeProperty('--ripple-y');\n    },\n    opts,\n  );\n\n  ripple.addEventListener(\n    'click',\n    (event) => {\n      // A UIEvent.detail click count of 0 indicates the click was not triggered\n      // by a pointer. Show the ripple press effect for these clicks as well.\n      if (event.detail === 0 && !isRippleDisabled()) {\n        activateRipple();\n      }\n    },\n    opts,\n  );\n}\n\n/**\n * A Lit directive that adds updates the position of a ripple to match pointer\n * interactions. Use with the `.ripple` class.\n *\n * @example\n * ```ts\n * class Component extends LitElement {\n *   static styles = [rippleStyles, css`...`];\n *\n *   render() {\n *     return html`<button class=\"ripple\" ${ripple()}>Ripple effect</button>`;\n *   }\n * }\n * ```\n *\n * Use the `.ripple-target` class if the interactive element is a parent or\n * child of the ripple element.\n *\n * The `ripple()` directive should be applied to the parent element, which may\n * be the `.ripple-target` instead of the `.ripple`.\n *\n * @example\n * ```ts\n * html`\n *   <div class=\"card ripple\" ${ripple()}>\n *     Child interactive element\n *     <button class=\"ripple-target card-btn\"></button>\n *   </div>\n *\n *   <button class=\"ripple-target\" ${ripple()}>\n *     Parent interactive element\n *     <span class=\"ripple\"></span>\n *   </button>\n * `;\n * ```\n */\nexport const ripple = createElementDirective(setupRipple);\n"]}

package/labs/gb/components/ripple/ripple.scss

@@ -0,0 +1,103 @@
+/*!
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+@layer md.sys;
+@layer md.comp.ripple {
+  @property --ripple-scale {
+    syntax: '<percentage>';
+    inherits: false;
+    initial-value: 0%;
+  }
+  @property --ripple-hover-opacity {
+    syntax: '<percentage>';
+    inherits: false;
+    initial-value: 0%;
+  }
+  @property --ripple-press-opacity {
+    syntax: '<percentage>';
+    inherits: false;
+    initial-value: 0%;
+  }
+  @property --ripple-x {
+    syntax: '<percentage>';
+    inherits: false;
+    initial-value: 50%;
+  }
+  @property --ripple-y {
+    syntax: '<percentage>';
+    inherits: false;
+    initial-value: 50%;
+  }
+
+  .ripple {
+    --ripple-color: currentColor;
+    --ripple-press-transition: --ripple-press-opacity 375ms linear;
+    --ripple-transition: --ripple-hover-opacity 15ms linear,
+      var(--ripple-press-transition);
+    --ripple-animation: ripple-release 375ms linear;
+    --ripple: radial-gradient(
+        hsl(from var(--ripple-color) h s l / var(--ripple-hover-opacity))
+      ),
+      radial-gradient(
+        circle at var(--ripple-x) var(--ripple-y),
+        hsl(from var(--ripple-color) h s l / var(--ripple-press-opacity))
+          var(--ripple-scale),
+        transparent calc(var(--ripple-scale) * 1.35)
+      );
+
+    background-image: var(--ripple);
+    transition: var(--ripple-transition);
+    animation: var(--ripple-animation), var(--focus-ring-animation, none);
+
+    // Ripples support the following DOM use cases:
+    // 1. `.ripple` and interactive element are the same.
+    // 2. `.ripple` is a parent of a child interactive `.ripple-target`.
+    // 3. `.ripple` is a child of a parent interactive `.ripple-target`.
+    // 4. `.ripple.ripple-host` is a within an interactive shadow DOM host.
+    //
+    // Pseudo class emulation is only needed for the `.ripple` element, not for
+    // the target or host elements.
+
+    &:is(:hover, .hover),
+    &:has(.ripple-target:hover),
+    .ripple-target:hover &,
+    :host(:hover) &.ripple-host {
+      --ripple-hover-opacity: 8%;
+    }
+
+    &:is(:active, .active),
+    &:has(.ripple-target:active),
+    .ripple-target:active &,
+    :host(:active) &.ripple-host {
+      --ripple-press-opacity: 10%;
+      --ripple-press-transition: --ripple-press-opacity 100ms linear;
+      --ripple-animation: ripple-press forwards 450ms cubic-bezier(0.2, 0, 0, 1);
+    }
+
+    &:is(:disabled, .disabled) {
+      --ripple: none;
+    }
+  }
+
+  @keyframes ripple-press {
+    from {
+      --ripple-scale: 20%;
+    }
+    to {
+      --ripple-scale: 100%;
+      --ripple-x: 50%;
+      --ripple-y: 50%;
+    }
+  }
+
+  @keyframes ripple-release {
+    from {
+      --ripple-scale: 100%;
+    }
+    to {
+      --ripple-scale: 100%;
+    }
+  }
+}

package/labs/gb/components/shared/directives.d.ts

@@ -0,0 +1,93 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { DirectiveResult } from 'lit/async-directive.js';
+import { type ClassInfo } from 'lit/directives/class-map.js';
+/**
+ * A function that sets up logic for a directive's element.
+ *
+ * @param element The element attached to the directive.
+ * @param opts Options for setting up the element, including an AbortSignal for
+ *     cleanup.
+ */
+export type SetupElementFunction = (element: HTMLElement, opts: {
+    signal: AbortSignal;
+}) => void;
+/**
+ * All class map directives include AdditionalClasses to allow adding dynamic
+ * classes to the element using `classMap()`.
+ */
+export interface AdditionalClasses {
+    /**
+     * Additional classes to apply to the element.
+     */
+    classes?: ClassInfo;
+}
+/**
+ * Options for creating a class map directive.
+ *
+ * @param getClasses A function that returns the class names and truthy values
+ *     if they apply.
+ * @param setupElement An optional function to set up logic for the directive's
+ *     element.
+ */
+export interface ClassMapDirectiveOptions<State> {
+    getClasses: (state?: State) => ClassInfo;
+    setupElement?: SetupElementFunction;
+}
+/**
+ * Creates a Lit directive that behaves like `classMap()`, but also provides
+ * element setup and cleanup logic.
+ *
+ * These directives bind to `class="${componentDirectiveName()}"`.
+ *
+ * @example
+ * ```ts
+ * const toggleButton = createClassMapDirective({
+ *   getClasses: (state: ToggleButtonState) => ({
+ *     'toggle-button': true,
+ *     'toggle-button-selected': state.selected,
+ *   }),
+ *   setupElement: (element, opts) => {
+ *     element.addEventListener('click', () => {
+ *       state.selected = !state.selected;
+ *     }, opts);
+ *   },
+ * });
+ *
+ * html`
+ *   <button class="${toggleButton()}">Unselected</button>
+ *   <button class="${toggleButton({selected: true})}">Selected</button>
+ *   <button class="${toggleButton({classes: {'visible': isVisible}})}">
+ *     With additional classes
+ *   </button>
+ * `;
+ * ```
+ *
+ * @param options Options for creating the class map directive.
+ * @return A Lit `directive()` that binds to the class attribute.
+ */
+export declare function createClassMapDirective<State = {}>(options: ClassMapDirectiveOptions<State>): (state?: State & AdditionalClasses) => DirectiveResult;
+/**
+ * Creates a Lit directive that can be used to add setup and cleanup logic to
+ * an element.
+ *
+ * These directives bind as element parts.
+ *
+ * @example
+ * ```ts
+ * const logClick = createElementDirective((element, opts) => {
+ *   element.addEventListener('click', (event) => {
+ *     console.log('click', event);
+ *   }, opts);
+ * });
+ *
+ * html`<button ${logClick()}>Click me</button>`;
+ * ```
+ *
+ * @param setupElement The function to set up logic for the directive's element.
+ * @return A Lit `directive()` that binds as an element part.
+ */
+export declare function createElementDirective(setupElement: SetupElementFunction): () => DirectiveResult;

package/labs/gb/components/shared/directives.js

@@ -0,0 +1,111 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { noChange } from 'lit';
+import { AsyncDirective, directive, } from 'lit/async-directive.js';
+import { classMap } from 'lit/directives/class-map.js';
+/**
+ * Creates a Lit directive that behaves like `classMap()`, but also provides
+ * element setup and cleanup logic.
+ *
+ * These directives bind to `class="${componentDirectiveName()}"`.
+ *
+ * @example
+ * ```ts
+ * const toggleButton = createClassMapDirective({
+ *   getClasses: (state: ToggleButtonState) => ({
+ *     'toggle-button': true,
+ *     'toggle-button-selected': state.selected,
+ *   }),
+ *   setupElement: (element, opts) => {
+ *     element.addEventListener('click', () => {
+ *       state.selected = !state.selected;
+ *     }, opts);
+ *   },
+ * });
+ *
+ * html`
+ *   <button class="${toggleButton()}">Unselected</button>
+ *   <button class="${toggleButton({selected: true})}">Selected</button>
+ *   <button class="${toggleButton({classes: {'visible': isVisible}})}">
+ *     With additional classes
+ *   </button>
+ * `;
+ * ```
+ *
+ * @param options Options for creating the class map directive.
+ * @return A Lit `directive()` that binds to the class attribute.
+ */
+export function createClassMapDirective(options) {
+    return directive(class ComponentClassMapDirective extends SetupElementDirective {
+        constructor() {
+            super(...arguments);
+            this.setupElement = options.setupElement;
+        }
+        render(params) {
+            return classMap({
+                ...(params?.classes || {}),
+                ...options.getClasses(params),
+            });
+        }
+    });
+}
+/**
+ * Creates a Lit directive that can be used to add setup and cleanup logic to
+ * an element.
+ *
+ * These directives bind as element parts.
+ *
+ * @example
+ * ```ts
+ * const logClick = createElementDirective((element, opts) => {
+ *   element.addEventListener('click', (event) => {
+ *     console.log('click', event);
+ *   }, opts);
+ * });
+ *
+ * html`<button ${logClick()}>Click me</button>`;
+ * ```
+ *
+ * @param setupElement The function to set up logic for the directive's element.
+ * @return A Lit `directive()` that binds as an element part.
+ */
+export function createElementDirective(setupElement) {
+    return directive(class ElementDirective extends SetupElementDirective {
+        constructor() {
+            super(...arguments);
+            this.setupElement = setupElement;
+        }
+        render() {
+            return noChange;
+        }
+    });
+}
+/**
+ * A base class for Lit element and attribute directives that provides a setup
+ * method for initializing logic when a directive's element is connected.
+ */
+class SetupElementDirective extends AsyncDirective {
+    update({ element }, params) {
+        if (element !== this.element) {
+            this.element = element;
+            this.disconnected();
+            if (this.isConnected) {
+                this.reconnected();
+            }
+        }
+        return this.render(...params);
+    }
+    disconnected() {
+        this.cleanup?.abort();
+    }
+    reconnected() {
+        if (this.element && this.setupElement) {
+            this.cleanup = new AbortController();
+            this.setupElement(this.element, { signal: this.cleanup.signal });
+        }
+    }
+}
+//# sourceMappingURL=directives.js.map

package/labs/gb/components/shared/directives.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"directives.js","sourceRoot":"","sources":["directives.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAC,QAAQ,EAAC,MAAM,KAAK,CAAC;AAC7B,OAAO,EACL,cAAc,EAEd,SAAS,GAGV,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAAC,QAAQ,EAAiB,MAAM,6BAA6B,CAAC;AAsCrE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,MAAM,UAAU,uBAAuB,CACrC,OAAwC;IAExC,OAAO,SAAS,CACd,MAAM,0BAA2B,SAAQ,qBAAqB;QAA9D;;YAQqB,iBAAY,GAAG,OAAO,CAAC,YAAY,CAAC;QACzD,CAAC;QARC,MAAM,CAAC,MAAkC;YACvC,OAAO,QAAQ,CAAC;gBACd,GAAG,CAAC,MAAM,EAAE,OAAO,IAAI,EAAE,CAAC;gBAC1B,GAAG,OAAO,CAAC,UAAU,CAAC,MAAM,CAAC;aAC9B,CAAC,CAAC;QACL,CAAC;KAGF,CACF,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,UAAU,sBAAsB,CACpC,YAAkC;IAElC,OAAO,SAAS,CACd,MAAM,gBAAiB,SAAQ,qBAAqB;QAApD;;YAKqB,iBAAY,GAAG,YAAY,CAAC;QACjD,CAAC;QALC,MAAM;YACJ,OAAO,QAAQ,CAAC;QAClB,CAAC;KAGF,CACF,CAAC;AACJ,CAAC;AAED;;;GAGG;AACH,MAAe,qBAAsB,SAAQ,cAAc;IAmBhD,MAAM,CAAC,EAAC,OAAO,EAA8B,EAAE,MAAiB;QACvE,IAAI,OAAO,KAAK,IAAI,CAAC,OAAO,EAAE,CAAC;YAC7B,IAAI,CAAC,OAAO,GAAG,OAAsB,CAAC;YACtC,IAAI,CAAC,YAAY,EAAE,CAAC;YACpB,IAAI,IAAI,CAAC,WAAW,EAAE,CAAC;gBACrB,IAAI,CAAC,WAAW,EAAE,CAAC;YACrB,CAAC;QACH,CAAC;QAED,OAAO,IAAI,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC,CAAC;IAChC,CAAC;IAEkB,YAAY;QAC7B,IAAI,CAAC,OAAO,EAAE,KAAK,EAAE,CAAC;IACxB,CAAC;IAEkB,WAAW;QAC5B,IAAI,IAAI,CAAC,OAAO,IAAI,IAAI,CAAC,YAAY,EAAE,CAAC;YACtC,IAAI,CAAC,OAAO,GAAG,IAAI,eAAe,EAAE,CAAC;YACrC,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,OAAO,EAAE,EAAC,MAAM,EAAE,IAAI,CAAC,OAAO,CAAC,MAAM,EAAC,CAAC,CAAC;QACjE,CAAC;IACH,CAAC;CACF","sourcesContent":["/**\n * @license\n * Copyright 2026 Google LLC\n * SPDX-License-Identifier: Apache-2.0\n */\n\nimport {noChange} from 'lit';\nimport {\n  AsyncDirective,\n  AttributePart,\n  directive,\n  DirectiveResult,\n  ElementPart,\n} from 'lit/async-directive.js';\nimport {classMap, type ClassInfo} from 'lit/directives/class-map.js';\n\n/**\n * A function that sets up logic for a directive's element.\n *\n * @param element The element attached to the directive.\n * @param opts Options for setting up the element, including an AbortSignal for\n *     cleanup.\n */\nexport type SetupElementFunction = (\n  element: HTMLElement,\n  opts: {signal: AbortSignal},\n) => void;\n\n/**\n * All class map directives include AdditionalClasses to allow adding dynamic\n * classes to the element using `classMap()`.\n */\nexport interface AdditionalClasses {\n  /**\n   * Additional classes to apply to the element.\n   */\n  classes?: ClassInfo;\n}\n\n/**\n * Options for creating a class map directive.\n *\n * @param getClasses A function that returns the class names and truthy values\n *     if they apply.\n * @param setupElement An optional function to set up logic for the directive's\n *     element.\n */\nexport interface ClassMapDirectiveOptions<State> {\n  getClasses: (state?: State) => ClassInfo;\n  setupElement?: SetupElementFunction;\n}\n\n/**\n * Creates a Lit directive that behaves like `classMap()`, but also provides\n * element setup and cleanup logic.\n *\n * These directives bind to `class=\"${componentDirectiveName()}\"`.\n *\n * @example\n * ```ts\n * const toggleButton = createClassMapDirective({\n *   getClasses: (state: ToggleButtonState) => ({\n *     'toggle-button': true,\n *     'toggle-button-selected': state.selected,\n *   }),\n *   setupElement: (element, opts) => {\n *     element.addEventListener('click', () => {\n *       state.selected = !state.selected;\n *     }, opts);\n *   },\n * });\n *\n * html`\n *   <button class=\"${toggleButton()}\">Unselected</button>\n *   <button class=\"${toggleButton({selected: true})}\">Selected</button>\n *   <button class=\"${toggleButton({classes: {'visible': isVisible}})}\">\n *     With additional classes\n *   </button>\n * `;\n * ```\n *\n * @param options Options for creating the class map directive.\n * @return A Lit `directive()` that binds to the class attribute.\n */\nexport function createClassMapDirective<State = {}>(\n  options: ClassMapDirectiveOptions<State>,\n): (state?: State & AdditionalClasses) => DirectiveResult {\n  return directive(\n    class ComponentClassMapDirective extends SetupElementDirective {\n      render(params?: State & AdditionalClasses) {\n        return classMap({\n          ...(params?.classes || {}),\n          ...options.getClasses(params),\n        });\n      }\n\n      protected override setupElement = options.setupElement;\n    },\n  );\n}\n\n/**\n * Creates a Lit directive that can be used to add setup and cleanup logic to\n * an element.\n *\n * These directives bind as element parts.\n *\n * @example\n * ```ts\n * const logClick = createElementDirective((element, opts) => {\n *   element.addEventListener('click', (event) => {\n *     console.log('click', event);\n *   }, opts);\n * });\n *\n * html`<button ${logClick()}>Click me</button>`;\n * ```\n *\n * @param setupElement The function to set up logic for the directive's element.\n * @return A Lit `directive()` that binds as an element part.\n */\nexport function createElementDirective(\n  setupElement: SetupElementFunction,\n): () => DirectiveResult {\n  return directive(\n    class ElementDirective extends SetupElementDirective {\n      render() {\n        return noChange;\n      }\n\n      protected override setupElement = setupElement;\n    },\n  );\n}\n\n/**\n * A base class for Lit element and attribute directives that provides a setup\n * method for initializing logic when a directive's element is connected.\n */\nabstract class SetupElementDirective extends AsyncDirective {\n  /**\n   * Called when the directive's element changes. Use this method to add\n   * event listeners or perform other setup logic.\n   *\n   * The `signal` option is used to clean up setup logic when the element is\n   * disconnected.\n   *\n   * @param element The element attached to the directive.\n   * @param signal An AbortSignal to clean up event listeners and other logic.\n   */\n  protected setupElement?: (\n    element: HTMLElement,\n    opts: {signal: AbortSignal},\n  ) => void;\n\n  private element?: HTMLElement;\n  private cleanup?: AbortController;\n\n  override update({element}: ElementPart | AttributePart, params: unknown[]) {\n    if (element !== this.element) {\n      this.element = element as HTMLElement;\n      this.disconnected();\n      if (this.isConnected) {\n        this.reconnected();\n      }\n    }\n\n    return this.render(...params);\n  }\n\n  protected override disconnected() {\n    this.cleanup?.abort();\n  }\n\n  protected override reconnected() {\n    if (this.element && this.setupElement) {\n      this.cleanup = new AbortController();\n      this.setupElement(this.element, {signal: this.cleanup.signal});\n    }\n  }\n}\n"]}

package/labs/gb/components/shared/has-slotted.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Emulates the `:has-slotted` CSS pseudo class by adding a `.has-slotted` class
+ * to `<slot>` elements when they have assigned nodes.
+ */
+export declare const hasSlotted: () => import("lit-html/directive.js").DirectiveResult;

package/labs/gb/components/shared/has-slotted.js

@@ -0,0 +1,19 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { createElementDirective } from './directives.js';
+/**
+ * Emulates the `:has-slotted` CSS pseudo class by adding a `.has-slotted` class
+ * to `<slot>` elements when they have assigned nodes.
+ */
+export const hasSlotted = createElementDirective((element, opts) => {
+    if (!element.matches('slot')) {
+        throw new Error('hasSlotted() must be used on a <slot> element.');
+    }
+    element.addEventListener('slotchange', (event) => {
+        element.classList.toggle('has-slotted', element.assignedNodes().length > 0);
+    }, opts);
+});
+//# sourceMappingURL=has-slotted.js.map

package/labs/gb/components/shared/has-slotted.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"has-slotted.js","sourceRoot":"","sources":["has-slotted.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAC,sBAAsB,EAAC,MAAM,iBAAiB,CAAC;AAEvD;;;GAGG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG,sBAAsB,CAAC,CAAC,OAAO,EAAE,IAAI,EAAE,EAAE;IACjE,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC;QAC7B,MAAM,IAAI,KAAK,CAAC,gDAAgD,CAAC,CAAC;IACpE,CAAC;IAED,OAAO,CAAC,gBAAgB,CACtB,YAAY,EACZ,CAAC,KAAK,EAAE,EAAE;QACR,OAAO,CAAC,SAAS,CAAC,MAAM,CACtB,aAAa,EACZ,OAA2B,CAAC,aAAa,EAAE,CAAC,MAAM,GAAG,CAAC,CACxD,CAAC;IACJ,CAAC,EACD,IAAI,CACL,CAAC;AACJ,CAAC,CAAC,CAAC","sourcesContent":["/**\n * @license\n * Copyright 2026 Google LLC\n * SPDX-License-Identifier: Apache-2.0\n */\n\nimport {createElementDirective} from './directives.js';\n\n/**\n * Emulates the `:has-slotted` CSS pseudo class by adding a `.has-slotted` class\n * to `<slot>` elements when they have assigned nodes.\n */\nexport const hasSlotted = createElementDirective((element, opts) => {\n  if (!element.matches('slot')) {\n    throw new Error('hasSlotted() must be used on a <slot> element.');\n  }\n\n  element.addEventListener(\n    'slotchange',\n    (event) => {\n      element.classList.toggle(\n        'has-slotted',\n        (element as HTMLSlotElement).assignedNodes().length > 0,\n      );\n    },\n    opts,\n  );\n});\n"]}

package/labs/gb/components/shared/pseudo-classes.d.ts

@@ -0,0 +1,33 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Cross-component classes for emulating pseudo-classes.
+ *
+ * All components that style with psuedo-classes for their DOM structure also
+ * support emulating these states.
+ *
+ * @example
+ * ```html
+ * <button class="ripple active">Pressed ripple</button>
+ * ```
+ */
+export declare const PSEUDO_CLASSES: {
+    active: string;
+    checked: string;
+    disabled: string;
+    focus: string;
+    focusVisible: string;
+    hover: string;
+    indeterminate: string;
+    invalid: string;
+};
+/**
+ * Returns whether the element is disabled.
+ *
+ * @param element The element to check.
+ * @return true if the element is disabled.
+ */
+export declare function isDisabled(element: Element): boolean;

package/labs/gb/components/shared/pseudo-classes.js

@@ -0,0 +1,36 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Cross-component classes for emulating pseudo-classes.
+ *
+ * All components that style with psuedo-classes for their DOM structure also
+ * support emulating these states.
+ *
+ * @example
+ * ```html
+ * <button class="ripple active">Pressed ripple</button>
+ * ```
+ */
+export const PSEUDO_CLASSES = {
+    active: 'active',
+    checked: 'checked',
+    disabled: 'disabled',
+    focus: 'focus',
+    focusVisible: 'focus-visible',
+    hover: 'hover',
+    indeterminate: 'indeterminate',
+    invalid: 'invalid',
+};
+/**
+ * Returns whether the element is disabled.
+ *
+ * @param element The element to check.
+ * @return true if the element is disabled.
+ */
+export function isDisabled(element) {
+    return element.matches('.disabled,:disabled,[disabled],[aria-disabled=true]');
+}
+//# sourceMappingURL=pseudo-classes.js.map