material 3.2.6 → 3.3.0

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

@@ -1,7 +1,4 @@
 import { BaseComponent, ElementComponent } from "../component.js";
-/**
- * Component managers that can be passed to lifecycle
- */
 export interface ComponentManagers {
     events?: {
         destroy: () => void;
@@ -14,48 +11,15 @@ export interface ComponentManagers {
     };
     [key: string]: unknown;
 }
-/**
- * Lifecycle methods interface
- */
 export interface Lifecycle {
-    /**
-     * Registers a handler for mount event
-     * @param handler - Function to call when component is mounted
-     * @returns Unsubscribe function
-     */
     onMount: (handler: () => void) => () => void;
-    /**
-     * Registers a handler for unmount event
-     * @param handler - Function to call when component is unmounted
-     * @returns Unsubscribe function
-     */
     onUnmount: (handler: () => void) => () => void;
-    /**
-     * Mounts the component
-     */
     mount: () => void;
-    /**
-     * Unmounts the component
-     */
     unmount: () => void;
-    /**
-     * Checks if component is mounted
-     */
     isMounted: () => boolean;
-    /**
-     * Destroys the component
-     */
     destroy: () => void;
 }
-/**
- * Component with lifecycle capabilities
- */
 export interface LifecycleComponent extends BaseComponent {
     lifecycle: Lifecycle;
 }
-/**
- * Adds lifecycle management to a component
- *
- * @returns Function that enhances a component with lifecycle management
- */
 export declare const withLifecycle: () => <T extends BaseComponent & Partial<Pick<ElementComponent, "element" | "destroy">>>(component: T) => T & LifecycleComponent;

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

@@ -1,7 +1,4 @@
 import { BaseComponent, ElementComponent } from "../component.js";
-/**
- * Available position values
- */
 export declare enum POSITIONS {
     LEFT = "left",
     RIGHT = "right",
@@ -11,40 +8,16 @@ export declare enum POSITIONS {
     END = "end",
     CENTER = "center"
 }
-/**
- * Configuration for position feature
- */
 export interface PositionConfig {
     position?: string;
     prefix?: string;
     componentName?: string;
 }
-/**
- * Position manager interface
- */
 export interface PositionManager {
-    /**
-     * Sets the component's position
-     * @param newPosition - New position value
-     * @returns Position manager for chaining
-     */
     setPosition: (newPosition: string) => PositionManager;
-    /**
-     * Gets the current position
-     * @returns Current position
-     */
     getPosition: () => string;
 }
-/**
- * Component with position capabilities
- */
 export interface PositionComponent extends BaseComponent {
     position: PositionManager;
 }
-/**
- * Adds positioning functionality to a component
- *
- * @param config - Configuration object containing position information
- * @returns Function that enhances a component with position capabilities
- */
 export declare const withPosition: <T extends PositionConfig & object>(config: T) => <C extends ElementComponent>(component: C) => C & PositionComponent;

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

@@ -1,47 +1,18 @@
 import { BaseComponent, ElementComponent } from "../component.js";
 import { LifecycleComponent } from "./lifecycle.js";
-/**
- * Ripple configuration interface
- */
 export interface RippleConfig {
-    /**
-     * How long, in milliseconds, a released wave lingers before it is removed
-     */
     duration?: number;
 }
-/**
- * Ripple controller interface
- */
 export interface RippleController {
-    /**
-     * Mounts ripple effect to an element
-     * @param element - Target element
-     */
     mount: (element: HTMLElement) => void;
-    /**
-     * Unmounts ripple effect from an element
-     * @param element - Target element
-     */
     unmount: (element: HTMLElement) => void;
 }
-/**
- * Configuration for ripple feature
- */
 export interface RippleFeatureConfig {
     ripple?: boolean;
     rippleConfig?: RippleConfig;
 }
-/**
- * Component with ripple capabilities
- */
 export interface RippleComponent extends BaseComponent {
     ripple: RippleController;
 }
 export declare const createRipple: (config?: RippleConfig) => RippleController;
-/**
- * Adds ripple effect functionality to a component
- *
- * @param config - Configuration object
- * @returns Function that enhances a component with ripple effect
- */
 export declare const withRipple: <T extends RippleFeatureConfig & object>(config: T) => <C extends ElementComponent & Partial<LifecycleComponent>>(component: C) => C & RippleComponent;

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

@@ -1,16 +1,7 @@
 import { ElementComponent } from "../component.js";
-/**
- * Configuration for size feature
- */
 export interface SizeConfig {
     size?: string;
     prefix?: string;
     componentName?: string;
 }
-/**
- * Adds a size class to a component
- *
- * @param config - Configuration object containing size information
- * @returns Function that enhances a component with the size class
- */
 export declare const withSize: <T extends SizeConfig & object>(config: T) => <C extends ElementComponent>(component: C) => C;

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

@@ -1,15 +1,6 @@
 import { ElementComponent } from "../component.js";
-/**
- * Configuration for style feature
- */
 export interface StyleConfig {
     variant?: string;
     size?: string;
 }
-/**
- * Adds style classes to a component based on configuration
- *
- * @param config - Configuration object containing style information
- * @returns Function that enhances a component with style classes
- */
 export declare const withStyle: <T extends StyleConfig & object>(config?: T) => <C extends ElementComponent>(component: C) => C;

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

@@ -1,61 +1,16 @@
 import { BaseComponent, ElementComponent } from "../component.js";
-/**
- * Text manager interface
- */
 export interface TextManager {
-    /**
-     * Sets text content
-     * @param text - Text content to set
-     * @returns TextManager instance for chaining
-     */
-    /** Text, or a node placed inside the text element (the web components pass a `<slot>`). */
     setText: (text: string | Node) => TextManager;
-    /**
-     * Gets current text content
-     * @returns Current text
-     */
     getText: () => string;
-    /**
-     * Gets text element
-     * @returns Text element or null if not created
-     */
     getElement: () => HTMLElement | null;
 }
-/**
- * Configuration for text feature
- */
 export interface TextConfig {
-    /**
-     * Initial text content
-     */
-    /** Text, or a node placed inside the text element. */
     text?: string | Node;
-    /**
-     * CSS class prefix
-     */
     prefix?: string;
-    /**
-     * Component name for class generation
-     */
     componentName?: string;
-    /**
-     * Element to insert text before (optional)
-     */
     beforeElement?: HTMLElement;
 }
-/**
- * Component with text capabilities
- */
 export interface TextComponent extends BaseComponent {
-    /**
-     * Text manager
-     */
     text: TextManager;
 }
-/**
- * Adds text management to a component
- *
- * @param config - Configuration object containing text information
- * @returns Function that enhances a component with text capabilities
- */
 export declare const withText: <T extends TextConfig & object>(config: T) => <C extends ElementComponent>(component: C) => C & TextComponent;

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

@@ -1,114 +1,26 @@
 import { ElementComponent } from "../component.js";
-/**
- * Configuration for text input feature
- */
 export interface TextInputConfig {
-    /**
-     * Input type (text, password, etc.)
-     */
     type?: string;
-    /**
-     * Whether to use textarea instead of input
-     */
     multiline?: boolean;
-    /**
-     * Input name attribute
-     */
     name?: string;
-    /**
-     * Whether input is required
-     */
     required?: boolean;
-    /**
-     * Whether input is disabled
-     */
     disabled?: boolean;
-    /**
-     * Maximum allowed length
-     */
     maxLength?: number;
-    /**
-     * Input validation pattern
-     */
     pattern?: string;
-    /**
-     * Autocomplete setting
-     */
     autocomplete?: string;
-    /**
-     * Initial input value
-     */
     value?: string;
-    /**
-     * Placeholder attribute
-     */
     placeholder?: string;
-    /**
-     * Whether input is readonly
-     */
     readonly?: boolean;
 }
-/**
- * What withTextInput adds to a component.
- *
- * Declared apart from TextInputComponent because the enhancer returns
- * `C & TextInputFeature`, and C -- the component being enhanced -- already
- * carries the element half. Naming the whole of TextInputComponent on the way
- * out is what narrowed `addClass` back to a bare ElementComponent. It has to be
- * its own interface rather than a Pick of TextInputComponent: an indexed access
- * binds `this` to the type being indexed, so the methods below would report
- * TextInputComponent and the polymorphism would be lost at the step that needs
- * it.
- */
 export interface TextInputFeature {
-    /**
-     * Input element
-     */
     input: HTMLInputElement | HTMLTextAreaElement;
-    /**
-     * Sets the input value
-     * @param value - Value to set
-     * @returns Component instance for chaining
-     */
     setValue(value: string): this;
-    /**
-     * Gets the current input value
-     * @returns Current value
-     */
     getValue: () => string;
-    /**
-     * Sets an attribute on the input
-     * @param name - Attribute name
-     * @param value - Attribute value
-     * @returns Component instance for chaining
-     */
     setAttribute(name: string, value: string): this;
-    /**
-     * Gets an attribute from the input
-     * @param name - Attribute name
-     * @returns Attribute value
-     */
     getAttribute(name: string): string | null;
-    /**
-     * Removes an attribute from the input
-     * @param name - Attribute name
-     * @returns Component instance for chaining
-     */
     removeAttribute(name: string): this;
-    /**
-     * Event emission method if available
-     */
     emit?(event: string, data: unknown): this;
 }
-/**
- * Component with text input element and related methods
- */
 export interface TextInputComponent extends ElementComponent, TextInputFeature {
 }
-/**
- * Enhances a component with text input functionality
- *
- * @param config - Text input configuration
- * @returns Function that enhances a component with text input capabilities
- */
 export declare const withTextInput: <T extends TextInputConfig & object>(config?: T) => <C extends ElementComponent>(component: C) => C & TextInputFeature;

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

@@ -1,60 +1,16 @@
 import { BaseComponent, ElementComponent } from "../component.js";
-/**
- * Configuration for text label feature
- */
 export interface TextLabelConfig {
-    /**
-     * Label text
-     */
-    /**
-     * The label: text, or a node placed inside the label element (the
-     * web components pass a `<slot>` so the page's content is the label).
-     */
     label?: string | Node;
-    /**
-     * Label position ('start' or 'end')
-     */
     labelPosition?: "start" | "end";
-    /**
-     * CSS class prefix
-     */
     prefix?: string;
-    /**
-     * Component name for class generation
-     */
     componentName?: string;
 }
-/**
- * Label manager interface
- */
 export interface LabelManager {
-    /**
-     * Sets the label text
-     * @param text - Text to set
-     * @returns LabelManager instance for chaining
-     */
     setText: (text: string) => LabelManager;
-    /**
-     * Gets the current label text
-     * @returns Current text
-     */
     getText: () => string;
-    /**
-     * Gets the label element
-     * @returns Label element
-     */
     getElement: () => HTMLElement;
 }
-/**
- * Component with label capabilities
- */
 export interface LabelComponent extends BaseComponent {
     label: LabelManager;
 }
-/**
- * Adds a text label to a component
- *
- * @param config - Configuration object containing label information
- * @returns Function that enhances a component with a label
- */
 export declare const withTextLabel: <T extends TextLabelConfig & object>(config?: T) => <C extends ElementComponent>(component: C) => C & LabelComponent;

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

@@ -1,15 +1,5 @@
-/**
- * @module core/compose/features
- * @description Adds throttled event handling capabilities to components
- */
 import { BaseComponent, ElementComponent } from "../component.js";
-/**
- * Configuration for throttled event handlers
- */
 export interface ThrottleConfig {
-    /**
-     * Event handlers with throttle settings
-     */
     throttledEvents?: Record<string, {
         handler: (event: Event) => void;
         wait: number;
@@ -19,56 +9,12 @@ export interface ThrottleConfig {
         };
     }>;
 }
-/**
- * Component with throttled event capabilities
- */
 export interface ThrottleComponent extends BaseComponent {
-    /**
-     * Adds a throttled event listener
-     * @param event - Event name
-     * @param handler - Event handler
-     * @param wait - Throttle interval in milliseconds
-     * @param options - Throttle options
-     * @returns ThrottleComponent for chaining
-     */
     addThrottledEvent: (event: string, handler: (event: Event) => void, wait: number, options?: {
         leading?: boolean;
         trailing?: boolean;
     }) => ThrottleComponent;
-    /**
-     * Removes a throttled event listener
-     * @param event - Event name
-     * @returns ThrottleComponent for chaining
-     */
     removeThrottledEvent: (event: string) => ThrottleComponent;
 }
-/**
- * Adds throttled event handling capabilities to a component
- *
- * @param config - Configuration object containing throttled event settings
- * @returns Function that enhances a component with throttled event handling
- *
- * @example
- * ```ts
- * // Add throttled events to a component
- * const component = pipe(
- *   createBase,
- *   withElement(...),
- *   withThrottle({
- *     throttledEvents: {
- *       'scroll': {
- *         handler: (e) => updateScrollPosition(e),
- *         wait: 100
- *       },
- *       'mousemove': {
- *         handler: handleMouseMove,
- *         wait: 50,
- *         options: { leading: true, trailing: false }
- *       }
- *     }
- *   })
- * )(config);
- * ```
- */
 export declare const withThrottle: <T extends ThrottleConfig & object>(config?: T) => <C extends ElementComponent>(component: C) => C & ThrottleComponent;
 export default withThrottle;

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

@@ -1,46 +1,12 @@
-/**
- * @module core/compose/features
- */
 import { BaseComponent, ElementComponent } from "../component.js";
-/**
- * Configuration for track feature
- */
 export interface TrackConfig {
-    /**
-     * CSS class prefix
-     */
     prefix: string;
-    /**
-     * Component name for class generation
-     */
     componentName: string;
-    /**
-     * Custom icon HTML or 'none'
-     */
     icon?: string;
-    /**
-     * Icon HTML shown in the unselected handle, which then grows to 24dp: M3's
-     * "icon on selected and unselected switch" configuration.
-     */
     unselectedIcon?: string;
 }
-/**
- * Component with track and thumb elements
- */
 export interface TrackComponent extends BaseComponent {
-    /**
-     * Track element
-     */
     track: HTMLElement;
-    /**
-     * Thumb element
-     */
     thumb: HTMLElement;
 }
-/**
- * Adds track and thumb elements to a component
- *
- * @param config - Track configuration
- * @returns Function that enhances a component with track and thumb elements
- */
 export declare const withTrack: <T extends TrackConfig>(config: T) => <C extends ElementComponent>(component: C) => C & TrackComponent;

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

@@ -1,16 +1,7 @@
 import { ElementComponent } from "../component.js";
-/**
- * Configuration for variant feature
- */
 export interface VariantConfig {
     variant?: string;
     prefix?: string;
     componentName?: string;
 }
-/**
- * Adds a variant class to a component
- *
- * @param config - Configuration object containing variant information
- * @returns Function that enhances a component with the variant class
- */
 export declare const withVariant: <T extends VariantConfig & object>(config: T) => <C extends ElementComponent>(component: C) => C;

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
- */