material 3.2.5 → 3.2.7

package/dist/core/compose/features/withEvents.d.ts

@@ -1,45 +1,15 @@
 import { BaseComponent, ElementComponent } from "../component.js";
-/**
- * Event manager interface
- */
 export interface EnhancedEventManager {
-    /**
-     * Add an event listener
-     */
     on: (event: string, handler: Function) => EnhancedEventManager;
-    /**
-     * Remove an event listener
-     */
     off: (event: string, handler: Function) => EnhancedEventManager;
-    /**
-     * Add multiple event listeners at once
-     */
     addListeners: (listeners: Record<string, Function>) => EnhancedEventManager;
-    /**
-     * Remove multiple event listeners at once
-     */
     removeListeners: (listeners: Record<string, Function>) => EnhancedEventManager;
-    /**
-     * One-time event handler
-     */
     once: (event: string, handler: Function) => EnhancedEventManager;
-    /**
-     * Clean up all event listeners
-     */
     destroy: () => void;
 }
-/**
- * Component with enhanced event capabilities
- */
 export interface EnhancedEventComponent extends BaseComponent {
     events: EnhancedEventManager;
     on(event: string, handler: Function): this;
     off(event: string, handler: Function): this;
 }
-/**
- * Adds enhanced event handling capabilities to a component
- *
- * @param target - Optional custom event target
- * @returns Function that enhances a component with event capabilities
- */
 export declare const withEvents: (target?: HTMLElement) => <C extends ElementComponent>(component: C) => C & EnhancedEventComponent;

package/dist/core/compose/index.d.ts

@@ -1,7 +1,3 @@
-/**
- * @module core/compose
- * @description Core composition utilities for creating and combining components
- */
 export { pipe, compose, transform } from "./pipe.js";
 export { createComponent } from "./base.js";
 export { createBase, withElement } from "./component.js";

package/dist/core/compose/pipe.d.ts

@@ -1,22 +1,3 @@
-/**
- * @namespace compose
- * @description Core composition utilities for creating and combining components
- */
-/**
- * Performs left-to-right function composition.
- * Each function takes the return value of the previous function as its input.
- *
- * @memberof compose
- * @function pipe
- * @param {...Function} fns - Functions to compose
- * @returns {Function} Composed function that passes its argument through the pipeline
- *
- * @example
- * const addOne = x => x + 1;
- * const double = x => x * 2;
- * const addOneThenDouble = pipe(addOne, double);
- * console.log(addOneThenDouble(3)); // Output: 8
- */
 export declare function pipe<A, B>(f1: (arg: A) => B): (x: A) => B;
 export declare function pipe<A, B, C>(f1: (arg: A) => B, f2: (arg: B) => C): (x: A) => C;
 export declare function pipe<A, B, C, D>(f1: (arg: A) => B, f2: (arg: B) => C, f3: (arg: C) => D): (x: A) => D;
@@ -38,21 +19,6 @@ export declare function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q,
 export declare function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T>(f1: (arg: A) => B, f2: (arg: B) => C, f3: (arg: C) => D, f4: (arg: D) => E, f5: (arg: E) => F, f6: (arg: F) => G, f7: (arg: G) => H, f8: (arg: H) => I, f9: (arg: I) => J, f10: (arg: J) => K, f11: (arg: K) => L, f12: (arg: L) => M, f13: (arg: M) => N, f14: (arg: N) => O, f15: (arg: O) => P, f16: (arg: P) => Q, f17: (arg: Q) => R, f18: (arg: R) => S, f19: (arg: S) => T): (x: A) => T;
 export declare function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U>(f1: (arg: A) => B, f2: (arg: B) => C, f3: (arg: C) => D, f4: (arg: D) => E, f5: (arg: E) => F, f6: (arg: F) => G, f7: (arg: G) => H, f8: (arg: H) => I, f9: (arg: I) => J, f10: (arg: J) => K, f11: (arg: K) => L, f12: (arg: L) => M, f13: (arg: M) => N, f14: (arg: N) => O, f15: (arg: O) => P, f16: (arg: P) => Q, f17: (arg: Q) => R, f18: (arg: R) => S, f19: (arg: S) => T, f20: (arg: T) => U): (x: A) => U;
 export declare function pipe<T>(...fns: Array<(arg: T) => T>): (x: T) => T;
-/**
- * Performs right-to-left function composition.
- * This is the mathematical composition order: (f ∘ g)(x) = f(g(x))
- *
- * @memberof compose
- * @function compose
- * @param {...Function} fns - Functions to compose
- * @returns {Function} Composed function following mathematical composition order
- *
- * @example
- * const addOne = x => x + 1;
- * const double = x => x * 2;
- * const doubleTheAddOne = compose(addOne, double);
- * console.log(doubleTheAddOne(3)); // Output: 7
- */
 export declare function compose<A, B>(f1: (arg: A) => B): (x: A) => B;
 export declare function compose<A, B, C>(f2: (arg: B) => C, f1: (arg: A) => B): (x: A) => C;
 export declare function compose<A, B, C, D>(f3: (arg: C) => D, f2: (arg: B) => C, f1: (arg: A) => B): (x: A) => D;
@@ -74,25 +40,4 @@ export declare function compose<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P,
 export declare function compose<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T>(f19: (arg: S) => T, f18: (arg: R) => S, f17: (arg: Q) => R, f16: (arg: P) => Q, f15: (arg: O) => P, f14: (arg: N) => O, f13: (arg: M) => N, f12: (arg: L) => M, f11: (arg: K) => L, f10: (arg: J) => K, f9: (arg: I) => J, f8: (arg: H) => I, f7: (arg: G) => H, f6: (arg: F) => G, f5: (arg: E) => F, f4: (arg: D) => E, f3: (arg: C) => D, f2: (arg: B) => C, f1: (arg: A) => B): (x: A) => T;
 export declare function compose<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U>(f20: (arg: T) => U, f19: (arg: S) => T, f18: (arg: R) => S, f17: (arg: Q) => R, f16: (arg: P) => Q, f15: (arg: O) => P, f14: (arg: N) => O, f13: (arg: M) => N, f12: (arg: L) => M, f11: (arg: K) => L, f10: (arg: J) => K, f9: (arg: I) => J, f8: (arg: H) => I, f7: (arg: G) => H, f6: (arg: F) => G, f5: (arg: E) => F, f4: (arg: D) => E, f3: (arg: C) => D, f2: (arg: B) => C, f1: (arg: A) => B): (x: A) => U;
 export declare function compose<T>(...fns: Array<(arg: T) => T>): (x: T) => T;
-/**
- * Creates a function that applies transformations to an object with shared context.
- * Useful for applying multiple transformations while maintaining a shared state.
- *
- * @memberof compose
- * @function transform
- * @param {...Function} transformers - Functions that transform the object
- * @returns {Function} Function that applies all transformations with shared context
- *
- * @example
- * const withName = (obj, context) => ({ ...obj, name: context.name });
- * const withAge = (obj, context) => ({ ...obj, age: context.age });
- * const createPerson = transform(withName, withAge);
- *
- * const person = createPerson({}, { name: 'John', age: 30 });
- * // Result: { name: 'John', age: 30 }
- */
 export declare const transform: <T, C = Record<string, unknown>>(...transformers: Array<(obj: T, context: C) => Partial<T>>) => (obj: T, context?: C) => T;
-/**
- * @typedef {Object} TransformContext
- * @property {any} [key] - Any contextual data needed by transformers
- */ 

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 {