material 3.2.6 → 3.2.7

package/dist/core/compose/utils/type-guards.d.ts

@@ -1,27 +1,12 @@
-/**
- * Utility functions for type checking component capabilities
- */
 import { ElementComponent } from "../component.js";
-/**
- * Interface for components with lifecycle
- */
 export interface ComponentWithLifecycle extends ElementComponent {
     lifecycle: {
         destroy: () => void;
         [key: string]: unknown;
     };
 }
-/**
- * Interface for components with emit method
- */
 export interface ComponentWithEmit extends ElementComponent {
     emit: (event: string, data: unknown) => unknown;
 }
-/**
- * Type guard to check if component has lifecycle
- */
 export declare function hasLifecycle(component: object): component is ComponentWithLifecycle;
-/**
- * Type guard to check if component has emit method
- */
 export declare function hasEmit(component: object): component is ComponentWithEmit;

package/dist/core/config/component.d.ts

@@ -1,8 +1,4 @@
 import type { EventCondition } from "../dom/create.js";
-/**
- * Base component configuration interface
- * Common configuration properties shared by all components
- */
 export interface BaseComponentConfig {
     componentName?: string;
     class?: string | string[];
@@ -20,56 +16,15 @@ export interface BaseComponentConfig {
     ariaLabelledBy?: string;
     ariaHidden?: boolean;
 }
-/**
- * Creates a base configuration for any component
- * Automatically merges global defaults if available
- *
- * @param {T} defaults - Default configuration for the component
- * @param {Partial<T>} userConfig - User provided configuration
- * @param {string} componentName - The name of the component
- * @returns {T} Complete configuration with defaults applied
- *
- * @example
- * // In button/config.ts
- * export const createBaseConfig = (config: ButtonConfig = {}) =>
- *   createComponentConfig(defaultConfig, config, 'button');
- */
 export declare const createComponentConfig: <T extends BaseComponentConfig & object>(defaults: T, userConfig: Partial<T> | undefined, componentName: string) => T & {
     componentName: string;
     prefix: string;
 };
-/**
- * Processes class names for an element, handling arrays, nulls and conditional classes
- *
- * @param {string | string[] | null} classNames - Class names to process
- * @returns {string} Space-separated class names as a string
- *
- * @example
- * // Returns 'mtrl-card mtrl-card--elevated custom-class'
- * processClassNames(['mtrl-card', 'mtrl-card--elevated', 'custom-class']);
- *
- * // Returns 'mtrl-card'
- * processClassNames(['mtrl-card', null, undefined]);
- */
 export declare const processClassNames: (classNames: string | string[] | null) => string;
-/**
- * Creates a configuration object for withElement HOC
- *
- * @param {BaseComponentConfig} config - Component configuration
- * @param {Object} options - Element options
- * @returns {Object} Configuration object for withElement
- */
 export declare const createElementConfig: (config: BaseComponentConfig, options: {
     tag: string;
     attributes?: Record<string, unknown>;
     className?: string | (string | null | undefined)[] | null;
-    /**
-     * Styles the component computes for itself, as properties. Merged under
-     * `config.style`, so a consumer's own style still wins. Added with
-     * Menu built these into the style *attribute* as a joined
-     * string, where CSS text has no camelCase and `maxHeight` was silently
-     * dropped by the parser.
-     */
     style?: Partial<CSSStyleDeclaration>;
     html?: string;
     text?: string;

package/dist/core/config/global.d.ts

@@ -1,49 +1,6 @@
-/**
- * Lightweight Global Configuration System for mtrl
- *
- * This system allows setting default configurations for all components
- * without adding complexity or performance overhead.
- */
 export interface ComponentConfigMap {
 }
-/**
- * Sets global defaults for a specific component
- *
- * @param component - Component name
- * @param config - Default configuration to apply
- *
- * @example
- * ```typescript
- * // Set all buttons to be square by default
- * setComponentDefaults('button', {
- *   shape: 'square',
- *   size: 'm'
- * });
- * ```
- */
 export declare function setComponentDefaults<K extends keyof ComponentConfigMap>(component: K, config: ComponentConfigMap[K]): void;
-/**
- * Gets global defaults for a component
- *
- * @param component - Component name
- * @returns Component defaults or empty object
- */
 export declare function getComponentDefaults<K extends keyof ComponentConfigMap>(component: K): ComponentConfigMap[K];
-/**
- * Sets global defaults for multiple components at once
- *
- * @param configs - Map of component names to their default configs
- *
- * @example
- * ```typescript
- * setGlobalDefaults({
- *   button: { shape: 'square', size: 'm' },
- *   "text-field": { variant: 'outlined' }
- * });
- * ```
- */
 export declare function setGlobalDefaults(configs: Partial<ComponentConfigMap>): void;
-/**
- * Clears all global defaults
- */
 export declare function clearGlobalDefaults(): void;

package/dist/core/config.d.ts

@@ -1,47 +1,12 @@
-/**
- * Library prefix used for all components
- */
 export declare const PREFIX = "mtrl";
-/**
- * Gets a prefixed component class name
- * @param type - Component type
- * @returns Prefixed class name
- */
 export declare const getComponentClass: (type: string) => string;
-/**
- * Gets a BEM modifier class name
- * @param baseClass - Base class name
- * @param modifier - Modifier name
- * @returns Modifier class name
- */
 export declare const getModifierClass: (baseClass: string, modifier: string) => string;
-/**
- * Gets a BEM element class name
- * @param baseClass - Base class name
- * @param element - Element name
- * @returns Element class name
- */
 export declare const getElementClass: (baseClass: string, element: string) => string;
-/**
- * Theme configuration interface
- */
 export interface ThemeConfig {
-    /**
-     * Theme name
-     */
     name: string;
-    /**
-     * Theme CSS variables
-     */
     variables: Record<string, string>;
-    /**
-     * Theme variants
-     */
     variants: Record<string, unknown>;
 }
-/**
- * Component configuration interface
- */
 export interface ComponentConfig {
     prefix: string;
     type: string;
@@ -53,45 +18,21 @@ export interface ComponentConfig {
     withVariants: (...variants: string[]) => VariantComponentConfig;
     withStates: (...states: string[]) => StateComponentConfig;
 }
-/**
- * Themed component configuration interface
- */
 export interface ThemedComponentConfig extends ComponentConfig {
     theme: string;
     getThemeClass: (variant: string) => string;
     getCssVariables: () => Record<string, string>;
 }
-/**
- * Variant component configuration interface
- */
 export interface VariantComponentConfig extends ComponentConfig {
     variants: string[];
     hasVariant: (variant: string) => boolean;
     getVariantClass: (variant: string) => string | null;
 }
-/**
- * State component configuration interface
- */
 export interface StateComponentConfig extends ComponentConfig {
     states: string[];
     getStateClass: (state: string) => string | null;
 }
-/**
- * CSS class generation utilities
- */
 export declare const classNames: {
-    /**
-     * Creates a BEM-style class name
-     * @param block - Block name
-     * @param element - Element name
-     * @param modifier - Modifier name
-     * @returns BEM class name
-     */
     bem: (block: string, element?: string, modifier?: string) => string;
-    /**
-     * Joins class names, filtering out falsy values
-     * @param classes - Class names to join
-     * @returns Joined class names
-     */
     join: (...classes: (string | undefined | null | false)[]) => string;
 };

package/dist/core/dom/attributes.d.ts

@@ -1,50 +1,9 @@
-/**
- * @module core/dom
- * @description DOM attribute helpers
- */
-/**
- * Set attributes on an element with performance optimizations
- * Fast path for single attribute, efficient iteration for multiple
- *
- * @param {HTMLElement | SVGElement} element - Element to set attributes on
- * @param {object} attributes - Attributes to set
- * @returns {HTMLElement | SVGElement} The element for chaining
- */
 export declare const setAttributes: <E extends HTMLElement | SVGElement>(element: E, attributes?: object) => E;
-/**
- * Remove attributes from an element
- * Standard for loop is fastest for array iteration
- *
- * @param {HTMLElement} element - Element to remove attributes from
- * @param {string[]} attributes - Attributes to remove
- * @returns {HTMLElement} The element for chaining
- */
 export declare const removeAttributes: (element: HTMLElement, attributes?: string[]) => HTMLElement;
-/**
- * Batch attribute operations for better performance when setting many attributes
- * Single pass through operations array for optimal performance
- *
- * @param {HTMLElement} element - Element to modify
- * @param {Array<{action: "set" | "remove", key: string, value?: unknown}>} operations - Array of attribute operations
- * @returns {HTMLElement} The element for chaining
- */
 export declare const batchAttributes: (element: HTMLElement, operations: Array<{
     action: "set" | "remove";
     key: string;
     value?: unknown;
 }>) => HTMLElement;
-/**
- * Check if element has attribute
- * @param element - Element to check
- * @param attribute - Attribute name to check
- * @returns True if element has the attribute
- */
 export declare const hasAttribute: (element: HTMLElement, attribute: string) => boolean;
-/**
- * Get attribute value with default
- * @param element - Element to get attribute from
- * @param attribute - Attribute name
- * @param defaultValue - Default value if attribute doesn't exist
- * @returns Attribute value or default
- */
 export declare const getAttribute: (element: HTMLElement, attribute: string, defaultValue?: string) => string;

package/dist/core/dom/classes.d.ts

@@ -1,54 +1,5 @@
-/**
- * @module core/dom
- * @description DOM manipulation utilities optimized for performance
- */
-/**
- * Normalize classes to array of unique strings with optimization and caching
- * - String with space-separated classes
- * - Array of strings
- * - Mixed array of strings and space-separated classes
- *
- * @param {...(string | string[])} classes - Classes to normalize
- * @returns {string[]} Array of unique, non-empty class names
- */
 export declare const normalizeClasses: (...classes: (string | string[])[]) => string[];
-/**
- * Add prefixed classes to element with optimizations
- * Automatically adds prefix to classes that don't already have it
- * Optimized for minimal DOM interactions and single-class scenarios
- *
- * @param {HTMLElement} element - Target element
- * @param {...(string | string[])} classes - Classes to add
- * @returns {HTMLElement} Modified element for chaining
- */
 export declare const addClass: (element: HTMLElement, ...classes: (string | string[])[]) => HTMLElement;
-/**
- * Remove prefixed classes from element with optimizations
- * Handles exact class names as specified with automatic prefixing
- * Optimized for single-class scenarios and batch operations
- *
- * @param {HTMLElement} element - Target element
- * @param {...(string | string[])} classes - Classes to remove
- * @returns {HTMLElement} Modified element for chaining
- */
 export declare const removeClass: (element: HTMLElement, ...classes: (string | string[])[]) => HTMLElement;
-/**
- * Toggle prefixed classes on element with optimizations
- * Automatically adds prefix to classes that don't already have it
- * Optimized for single-class scenarios
- *
- * @param {HTMLElement} element - Target element
- * @param {...(string | string[])} classes - Classes to toggle
- * @returns {HTMLElement} Modified element for chaining
- */
 export declare const toggleClass: (element: HTMLElement, ...classes: (string | string[])[]) => HTMLElement;
-/**
- * Check if element has all specified prefixed classes with optimizations
- * Automatically adds prefix to classes that don't already have it
- * Returns true only if ALL specified classes are present
- *
- * @param {HTMLElement} element - Target element
- * @param {...(string | string[])} classes - Classes to check
- * @returns {boolean} True if element has all specified classes
- */
 export declare const hasClass: (element: HTMLElement, ...classes: (string | string[])[]) => boolean;

package/dist/core/dom/create.d.ts

@@ -1,151 +1,53 @@
-/**
- * @module core/dom
- * @description DOM manipulation utilities
- */
-/**
- * Event handler function type
- */
 export type EventHandler = (event: Event) => void;
-/**
- * Element type that can be either HTMLElement or SVGElement
- */
 export type DOMElement = HTMLElement | SVGElement;
-/**
- * Component context passed to created elements for event forwarding
- */
 export interface ElementContext {
-    /** Emits forwarded events */
     emit?(event: string, data: ForwardedEventPayload): void;
-    /** Subscribes to events */
     on?(event: string, handler: (...args: unknown[]) => void): unknown;
 }
-/**
- * Event condition type
- * Declared through a method signature so conditions typed for a specific
- * component or event subtype stay assignable under strictFunctionTypes
- */
 export type EventCondition = boolean | {
     condition(context: ElementContext & {
         element: DOMElement;
     }, event: Event): boolean;
 }["condition"];
-/**
- * Options for element creation with comprehensive configuration
- */
 export interface CreateElementOptions {
-    /** HTML tag name */
     tag?: string;
-    /** Container to append element to */
     container?: HTMLElement | null;
-    /** Inner HTML content */
     html?: string;
-    /** Text content */
     text?: string;
-    /** Element ID */
     id?: string;
-    /** Form element name */
     name?: string;
-    /** Element title (native browser tooltip on hover) */
     title?: string;
-    /** Keyboard navigation order (-1 to remove from tab order, 0+ for custom order) */
     tabIndex?: number;
-    /** Inline styles (string or object) */
-    /**
-     * Inline styles. Object only: a style string is written verbatim to the
-     * style attribute, so one interpolated value can carry extra declarations
-     * Assigning per property confines a value to that property.
-     */
     style?: Partial<CSSStyleDeclaration>;
-    /** Dataset attributes (e.g., { name: 'value' } → data-name="value") */
     data?: Record<string, string>;
-    /** ARIA role (e.g., 'button', 'menuitem', 'dialog') */
     role?: string;
-    /** Accessible label for screen readers */
     ariaLabel?: string;
-    /** ID of element that describes this element */
     ariaDescribedBy?: string;
-    /** ID of element that labels this element */
     ariaLabelledBy?: string;
-    /** Hide from screen readers */
     ariaHidden?: boolean;
-    /** CSS classes (will be automatically prefixed with 'mtrl-') - alias for className */
     class?: string | string[];
-    /** CSS classes (will be automatically prefixed with 'mtrl-') - alias for class */
     className?: string | string[];
-    /** HTML attributes */
     attributes?: object;
-    /** Events to forward when component has emit method */
     forwardEvents?: Record<string, EventCondition>;
-    /** Callback after element creation */
     onCreate?(element: HTMLElement, context?: ElementContext): void;
-    /** Component context */
     context?: ElementContext & object;
 }
-/**
- * Options for SVG element creation
- */
 export interface CreateSVGElementOptions extends Omit<CreateElementOptions, "container" | "onCreate"> {
     container?: DOMElement | null;
     onCreate?(element: SVGElement, context?: ElementContext): void;
 }
-/**
- * Event handler storage
- */
 export interface EventHandlerStorage {
     [eventName: string]: EventHandler;
 }
-/**
- * What `forwardEvents` hands the component's emitter.
- *
- * One shape for every forwarded native event, emitted by `setupEventForwarding`
- * below as `{ event, element, originalEvent: event }`. Eleven components
- * configure `forwardEvents`, so this lives here rather than being redeclared
- * per component: each component has a typed event map, and without
- * a shared payload that would mean the same three fields written out again in
- * every one of them.
- *
- * `event` and `originalEvent` are the same object. Both names have always
- * been provided and consumers use both, so neither is removed here.
- * The default root covers HTML and SVG; component event maps can specialize
- * it to their actual element type.
- */
 export interface ForwardedEventPayload<E extends Event = Event, TElement extends DOMElement = DOMElement> {
-    /** The DOM event that triggered the forward. */
     event: E;
-    /** The element the listener is attached to, which is the component root. */
     element: TElement;
-    /** The same DOM event as `event`. */
     originalEvent: E;
 }
-/**
- * Create an HTML element with comprehensive options and optimizations
- * Fast paths for common scenarios, full feature support for complex cases
- *
- * @param {CreateElementOptions} options - Element creation options
- * @returns {HTMLElement} Created HTML element
- */
 export declare const createElement: (options?: CreateElementOptions) => HTMLElement;
-/**
- * Create a pooled HTML element
- * @param options - Element creation options
- * @returns Created HTML element from pool
- */
 export declare const createElementPooled: (options?: CreateElementOptions) => HTMLElement;
-/**
- * Release an element back to the pool
- * @param element - Element to release
- */
 export declare const releaseElement: (element: HTMLElement) => void;
-/**
- * Create an SVG element
- * @param options - SVG element creation options
- * @returns Created SVG element
- */
 export declare const createSVGElement: (options?: CreateSVGElementOptions) => SVGElement;
-/**
- * Remove event handlers from an element
- * @param element - Element to clean up
- */
 export declare const removeEventHandlers: (element: HTMLElement | SVGElement) => void;
 declare global {
     interface HTMLElement {

package/dist/core/dom/events.d.ts

@@ -1,69 +1,17 @@
-/**
- * @module core/dom
- * @description DOM manipulation utilities
- */
-/**
- * Event manager interface for handling DOM events
- */
 export interface EventManager {
-    /**
-     * Add an event listener with options
-     * @param event - Event name
-     * @param handler - Event handler
-     * @param options - addEventListener options
-     * @returns EventManager instance for chaining
-     */
     on: <T extends Event>(event: string, handler: (e: T) => void, options?: AddEventListenerOptions) => EventManager;
-    /**
-     * Remove an event listener
-     * @param event - Event name
-     * @param handler - Event handler
-     * @returns EventManager instance for chaining
-     */
     off: <T extends Event>(event: string, handler: (e: T) => void) => EventManager;
-    /**
-     * Temporarily disable all event listeners
-     * @returns EventManager instance for chaining
-     */
     pause: () => EventManager;
-    /**
-     * Re-enable all event listeners
-     * @returns EventManager instance for chaining
-     */
     resume: () => EventManager;
-    /**
-     * Remove all event listeners and clean up
-     */
     destroy: () => void;
-    /**
-     * Get all active handlers
-     * @returns Map of active handlers
-     */
     getHandlers: () => Map<string, HandlerInfo>;
-    /**
-     * Check if a specific handler exists
-     * @param event - Event name
-     * @param handler - Event handler
-     * @returns Whether handler exists
-     */
     hasHandler: <T extends Event>(event: string, handler: (e: T) => void) => boolean;
 }
-/**
- * Handler information
- */
 interface HandlerInfo {
     original: EventListener;
     enhanced: EventListener;
     event: string;
     options: AddEventListenerOptions;
 }
-/**
- * Creates an event manager to handle DOM events with enhanced functionality.
- * Provides a robust interface for managing event listeners with error handling,
- * cleanup, and lifecycle management.
- *
- * @param element - DOM element to attach events to
- * @returns Event manager interface
- */
 export declare const createEventManager: (element: HTMLElement) => EventManager;
 export {};

package/dist/core/dom/focus.d.ts

@@ -1,36 +1,4 @@
-/**
- * The focused element as seen from a node's own root: the shadow root it
- * lives in, or the document.
- *
- * `document.activeElement` stops at the shadow host when focus is inside a
- * shadow root, so a component rendered in one never finds its focused item
- * there. A detached node has neither root, and gets the document's.
- *
- * @param node - A node of the component, usually its element
- * @returns The active element of that node's root, or null
- */
 export declare const activeElementOf: (node: Node) => Element | null;
-/**
- * The element that really has focus, looked for through open shadow roots:
- * where focus goes back to after an overlay closes, when the overlay may sit
- * in another root than whatever opened it.
- *
- * @returns The innermost focused element, or null
- */
 export declare const deepActiveElement: () => Element | null;
-/**
- * The tab stops in a container, in the order Tab reaches them: through slots
- * to what is assigned to them and into shadow roots, which is where the
- * content of a web component sits. Slots are told by shape, as the roots are
- * above.
- */
 export declare const tabStops: (container: Element) => HTMLElement[];
-/**
- * Keeps Tab inside a modal: from its last tab stop to its first, and Shift+Tab
- * from the first (or the modal itself) to the last. Between them the browser
- * moves focus as it always does. For a keydown listener on the modal.
- *
- * @param container - The modal, which the keydown reached
- * @param event - The keydown
- */
 export declare const wrapTab: (container: HTMLElement, event: KeyboardEvent) => void;

package/dist/core/dom/html.d.ts

@@ -1,34 +1,10 @@
-/** A value the browser's Trusted Types API accepts for innerHTML. */
 export interface TrustedHTMLLike {
     toString(): string;
 }
-/** Markup a component accepts: a string, or a TrustedHTML from a policy. */
 export type HTMLInput = string | TrustedHTMLLike;
 export interface HTMLPolicy {
-    /**
-     * Called with every markup string before it is written. Return the markup
-     * to write: a sanitized string, or a TrustedHTML from a Trusted Types
-     * policy. Values that are already TrustedHTML are not passed through it.
-     */
     sanitize: (html: string) => HTMLInput;
 }
-/**
- * Sets the policy every component's markup goes through, or clears it with
- * null.
- *
- * @example
- * // DOMPurify
- * configureHTML({ sanitize: (html) => DOMPurify.sanitize(html) });
- *
- * // Trusted Types: a policy the page's CSP allows
- * const trusted = window.trustedTypes.createPolicy('app', { createHTML: (html) => DOMPurify.sanitize(html) });
- * configureHTML({ sanitize: (html) => trusted.createHTML(html) });
- */
 export declare const configureHTML: (next: HTMLPolicy | null) => void;
-/** The policy in force, if any. */
 export declare const getHTMLPolicy: () => HTMLPolicy | null;
-/**
- * Writes markup into an element, through the policy when one is set.
- * An empty string empties the element without touching innerHTML.
- */
 export declare const setHTML: (element: Element, html: HTMLInput | null | undefined) => void;