mtrl 0.4.4 → 0.5.0

package/dist/components/textfield/features/error.d.ts

@@ -0,0 +1,54 @@
+import { BaseComponent, ElementComponent } from "../../../core/compose/component";
+/**
+ * Configuration for error feature
+ */
+export interface ErrorConfig {
+    /**
+     * Initial error state
+     */
+    error?: boolean;
+    /**
+     * CSS class prefix
+     */
+    prefix?: string;
+    /**
+     * Component name
+     */
+    componentName?: string;
+    [key: string]: any;
+}
+/**
+ * Component with supporting text capabilities (if available)
+ */
+interface ComponentWithSupportingText extends ElementComponent {
+    setSupportingText?: (text: string, isError?: boolean) => void;
+    supportingTextElement?: HTMLElement | null;
+}
+/**
+ * Component with error state capabilities
+ */
+export interface ErrorComponent extends BaseComponent {
+    /**
+     * Current error state
+     */
+    errorState: boolean;
+    /**
+     * Sets error state
+     * @param error - Whether to show error state
+     * @param message - Optional error message to display
+     * @returns Component instance for chaining
+     */
+    setError: (error: boolean, message?: string) => ErrorComponent;
+    /**
+     * Gets current error state
+     * @returns Whether component is in error state
+     */
+    isError: () => boolean;
+}
+/**
+ * Adds error state management to a component
+ * @param config - Configuration with error settings
+ * @returns Function that enhances a component with error state
+ */
+export declare const withError: <T extends ErrorConfig>(config: T) => <C extends ComponentWithSupportingText>(component: C) => C & ErrorComponent;
+export {};

package/dist/components/textfield/features/index.d.ts

@@ -5,6 +5,7 @@ export { withSuffixText } from "./suffix-text";
 export { withSupportingText } from "./supporting-text";
 export { withPlacement } from "./placement";
 export { withDensity } from "./density";
+export { withError } from "./error";
 export type { LeadingIconComponent, LeadingIconConfig } from "./leading-icon";
 export type { TrailingIconComponent, TrailingIconConfig, } from "./trailing-icon";
 export type { PrefixTextComponent, PrefixTextConfig } from "./prefix-text";

package/dist/components/textfield/features/placement.d.ts

@@ -1,4 +1,4 @@
-import { BaseComponent, ElementComponent } from '../../../core/compose/component';
+import { BaseComponent, ElementComponent } from "../../../core/compose/component";
 /**
  * Extended element component with input field
  */

package/dist/components/textfield/features/supporting-text.d.ts

@@ -1,4 +1,4 @@
-import { BaseComponent, ElementComponent } from '../../../core/compose/component';
+import { BaseComponent, ElementComponent } from "../../../core/compose/component";
 /**
  * Extended element component with lifecycle
  */

package/dist/components/textfield/types.d.ts

@@ -148,6 +148,10 @@ export interface TextfieldComponent {
     removeSuffixText: () => TextfieldComponent;
     /** Manually update element positions (useful after DOM changes) */
     updatePositions: () => TextfieldComponent;
+    /** Sets the error state of the textfield */
+    setError: (error: boolean, message?: string) => TextfieldComponent;
+    /** Gets the current error state */
+    isError: () => boolean;
     /** Sets the density of the textfield */
     setDensity: (density: TextfieldDensity | string) => TextfieldComponent;
     /** Gets the current density setting */
@@ -220,5 +224,8 @@ export interface BaseComponent {
     lifecycle?: {
         destroy: () => void;
     };
+    errorState?: boolean;
+    setError?: (error: boolean, message?: string) => void;
+    isError?: () => boolean;
     [key: string]: unknown;
 }

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

@@ -1,4 +1,4 @@
-import { BaseComponent, ElementComponent } from '../component';
+import { BaseComponent, ElementComponent } from "../component";
 /**
  * Icon manager interface
  */
@@ -31,7 +31,7 @@ export interface IconConfig {
     /**
      * Icon position ('start' or 'end')
      */
-    iconPosition?: 'start' | 'end';
+    iconPosition?: "start" | "end";
     /**
      * Icon size variant
      */

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

@@ -15,7 +15,6 @@ export { withEvents as withEnhancedEvents } from './withEvents';
 export { withBadge } from './badge';
 export { withThrottle } from './throttle';
 export { withDebounce } from './debounce';
-export { withGestures } from './gestures';
 export { withDisabled } from './disabled';
 export { withLifecycle } from './lifecycle';
 export type { EventComponent } from './events';
@@ -33,4 +32,3 @@ export type { EnhancedEventComponent } from './withEvents';
 export type { BadgeComponent, BadgeConfig } from './badge';
 export type { ThrottleComponent, ThrottleConfig } from './throttle';
 export type { DebounceComponent, DebounceConfig } from './debounce';
-export type { GesturesComponent, GesturesFeatureConfig } from './gestures';

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

@@ -39,6 +39,10 @@ export interface TextInputConfig {
      * Initial input value
      */
     value?: string;
+    /**
+     * Placeholder attribute
+     */
+    placeholder?: string;
     [key: string]: any;
 }
 /**

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

@@ -1,4 +1,4 @@
-import { BaseComponent, ElementComponent } from '../component';
+import { BaseComponent, ElementComponent } from "../component";
 /**
  * Configuration for text label feature
  */
@@ -10,7 +10,7 @@ export interface TextLabelConfig {
     /**
      * Label position ('start' or 'end')
      */
-    labelPosition?: 'start' | 'end';
+    labelPosition?: "start" | "end";
     /**
      * CSS class prefix
      */

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

@@ -5,11 +5,7 @@
 export { pipe, compose, transform } from './pipe';
 export { createComponent } from './base';
 export { createBase, withElement } from './component';
-export { withEvents, withIcon, withSize, withPosition, withText, withVariant, withDisabled, withLifecycle, withRipple, withInput, withCheckable, withStyle, withTextInput, withTextLabel, withTrack, withEnhancedEvents, withThrottle, withDebounce, withGestures } from './features';
-export { withTapGesture } from './features/gestures/tap';
-export { withSwipeGesture } from './features/gestures/swipe';
-export { withLongPressGesture } from './features/gestures/longpress';
-export { withPanGesture } from './features/gestures/pan';
+export { withEvents, withIcon, withSize, withPosition, withText, withVariant, withDisabled, withLifecycle, withRipple, withInput, withCheckable, withStyle, withTextInput, withTextLabel, withTrack, withEnhancedEvents, withThrottle, withDebounce } from './features';
 export type { Component } from './base';
 export type { BaseComponent, ElementComponent, TouchState, WithElementOptions } from './component';
 export type { EventComponent, TextComponent, IconComponent, LifecycleComponent, Lifecycle, DisabledComponent, DisabledManager, RippleComponent, InputComponent, CheckableComponent, CheckableManager, TextInputComponent, LabelComponent, TrackComponent, EnhancedEventComponent, ThrottleComponent, ThrottleConfig, DebounceComponent, DebounceConfig, GesturesComponent, GesturesFeatureConfig } from './features';

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

@@ -3,7 +3,8 @@
  * @description DOM attribute helpers
  */
 /**
- * Sets attributes on an HTML element
+ * Set attributes on an element with performance optimizations
+ * Fast path for single attribute, efficient iteration for multiple
  *
  * @param {HTMLElement} element - Element to set attributes on
  * @param {Record<string, any>} attributes - Attributes to set
@@ -11,10 +12,39 @@
  */
 export declare const setAttributes: (element: HTMLElement, attributes?: Record<string, any>) => HTMLElement;
 /**
- * Removes attributes from an HTML element
+ * 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?: any}>} 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?: any;
+}>) => 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

@@ -3,47 +3,49 @@
  * @description DOM manipulation utilities optimized for performance
  */
 /**
- * Normalizes class names input by handling various formats:
+ * 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 classes - Classes to normalize
- * @returns Array of unique, non-empty class names
+ * @param {...(string | string[])} classes - Classes to normalize
+ * @returns {string[]} Array of unique, non-empty class names
  */
 export declare const normalizeClasses: (...classes: (string | string[])[]) => string[];
 /**
- * Adds multiple classes to an element
+ * Add prefixed classes to element with optimizations
  * Automatically adds prefix to classes that don't already have it
- * Optimized for minimal array operations and DOM interactions
+ * 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
+ * @returns {HTMLElement} Modified element for chaining
  */
 export declare const addClass: (element: HTMLElement, ...classes: (string | string[])[]) => HTMLElement;
 /**
- * Removes multiple classes from an element
- * Handles only exact class names as specified (no automatic prefixing)
- * For better performance, clients should know exactly which classes to remove
+ * 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
+ * @returns {HTMLElement} Modified element for chaining
  */
 export declare const removeClass: (element: HTMLElement, ...classes: (string | string[])[]) => HTMLElement;
 /**
- * Toggles multiple classes on an element
+ * 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
+ * @returns {HTMLElement} Modified element for chaining
  */
 export declare const toggleClass: (element: HTMLElement, ...classes: (string | string[])[]) => HTMLElement;
 /**
- * Checks if an element has all specified classes
+ * 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

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

@@ -7,7 +7,7 @@
  */
 export type EventHandler = (event: Event) => void;
 /**
- * Event condition type - either a boolean or a function that returns a boolean
+ * Event condition type
  */
 export type EventCondition = boolean | ((context: any, event: Event) => boolean);
 /**
@@ -15,140 +15,88 @@ export type EventCondition = boolean | ((context: any, event: Event) => boolean)
  */
 export type DOMElement = HTMLElement | SVGElement;
 /**
- * Options for element creation
+ * Options for element creation with comprehensive configuration
  */
 export interface CreateElementOptions {
-    /**
-     * HTML tag name
-     */
+    /** HTML tag name */
     tag?: string;
-    /**
-     * Container to append element to
-     */
+    /** Container to append element to */
     container?: HTMLElement | null;
-    /**
-     * Inner HTML content
-     */
+    /** Inner HTML content */
     html?: string;
-    /**
-     * Text content
-     */
+    /** Text content */
     text?: string;
-    /**
-     * Element ID
-     */
+    /** Element ID */
     id?: string;
-    /**
-     * Element ariaLabel
-     */
+    /** Element aria-label */
     ariaLabel?: string;
-    /**
-     * Dataset attributes
-     */
+    /** Dataset attributes */
     data?: Record<string, string>;
-    /**
-     * CSS classes (will be automatically prefixed with 'mtrl-')
-     * Alias for 'className'
-     */
+    /** 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'
-     */
+    /** CSS classes (will be automatically prefixed with 'mtrl-') - alias for class */
     className?: string | string[];
-    /**
-     * CSS classes that will NOT be prefixed
-     * Added as-is to the element
-     */
+    /** CSS classes that will NOT be prefixed - added as-is to the element */
     rawClass?: string | string[];
-    /**
-     * HTML attributes
-     */
+    /** HTML attributes */
     attributes?: Record<string, any>;
-    /**
-     * Events to forward when component has emit method
-     */
+    /** Events to forward when component has emit method */
     forwardEvents?: Record<string, EventCondition>;
-    /**
-     * Callback after element creation
-     */
+    /** Callback after element creation */
     onCreate?: (element: HTMLElement, context?: any) => void;
-    /**
-     * Component context
-     */
+    /** Component context */
     context?: any;
-    /**
-     * Additional attributes
-     */
+    /** Additional attributes via spread */
     [key: string]: any;
 }
 /**
- * Options for SVG element creation, extends regular element options
+ * Options for SVG element creation
  */
 export interface CreateSVGElementOptions extends Omit<CreateElementOptions, "container" | "onCreate"> {
-    /**
-     * Container to append element to
-     */
     container?: DOMElement | null;
-    /**
-     * Callback after element creation
-     */
     onCreate?: (element: SVGElement, context?: any) => void;
 }
 /**
- * Event handler storage to facilitate cleanup
+ * Event handler storage
  */
 export interface EventHandlerStorage {
     [eventName: string]: EventHandler;
 }
 /**
- * Creates an HTML element with the specified options
+ * 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;
 /**
- * Creates an SVG element with the specified options
- *
- * @param {CreateSVGElementOptions} options - SVG element creation options
- * @returns {SVGElement} Created SVG element
+ * Create a pooled HTML element
+ * @param options - Element creation options
+ * @returns Created HTML element from pool
  */
-export declare const createSVGElement: (options?: CreateSVGElementOptions) => SVGElement;
+export declare const createElementPooled: (options?: CreateElementOptions) => HTMLElement;
 /**
- * Removes event handlers from an element
- * @param element - Element to cleanup
+ * Release an element back to the pool
+ * @param element - Element to release
  */
-export declare const removeEventHandlers: (element: HTMLElement | SVGElement) => void;
+export declare const releaseElement: (element: HTMLElement) => void;
 /**
- * Higher-order function to add attributes to an element
- * @param {Record<string, any>} attributes - Attributes to add
- * @returns {(element: HTMLElement) => HTMLElement} Element transformer
+ * Create an SVG element
+ * @param options - SVG element creation options
+ * @returns Created SVG element
  */
-export declare const withAttributes: (attributes: Record<string, any>) => (element: HTMLElement) => HTMLElement;
-/**
- * Higher-order function to add classes to an element
- * @param {...(string | string[])} classes - Classes to add
- * @returns {(element: HTMLElement) => HTMLElement} Element transformer
- */
-export declare const withClasses: (...classes: (string | string[])[]) => (element: HTMLElement) => HTMLElement;
+export declare const createSVGElement: (options?: CreateSVGElementOptions) => SVGElement;
 /**
- * Higher-order function to add content to an element
- * @param {Node|string} content - Content to add
- * @returns {(element: HTMLElement) => HTMLElement} Element transformer
+ * Remove event handlers from an element
+ * @param element - Element to clean up
  */
-export declare const withContent: (content: Node | string) => (element: HTMLElement) => HTMLElement;
+export declare const removeEventHandlers: (element: HTMLElement | SVGElement) => void;
 declare global {
     interface HTMLElement {
-        /**
-         * Storage for event handlers to enable cleanup
-         */
         __eventHandlers?: EventHandlerStorage;
     }
     interface SVGElement {
-        /**
-         * Storage for event handlers to enable cleanup
-         */
         __eventHandlers?: EventHandlerStorage;
     }
 }

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

@@ -1,6 +1,6 @@
-export { createElement, createSVGElement } from './create';
-export type { CreateElementOptions } from './create';
-export { setAttributes, removeAttributes } from './attributes';
-export { addClass, removeClass, toggleClass, hasClass, normalizeClasses } from './classes';
-export { createEventManager } from './events';
-export type { EventManager } from './events';
+export { createElement, createSVGElement } from "./create";
+export type { CreateElementOptions } from "./create";
+export { setAttributes, removeAttributes, batchAttributes, hasAttribute, getAttribute, } from "./attributes";
+export { addClass, removeClass, toggleClass, hasClass, normalizeClasses, } from "./classes";
+export { createEventManager } from "./events";
+export type { EventManager } from "./events";

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

@@ -1,13 +1,4 @@
-/**
- * Normalizes class names input by handling various formats:
- * - String with space-separated classes
- * - Array of strings
- * - Mixed array of strings and space-separated classes
- *
- * @param classes - Classes to normalize
- * @returns Array of unique, non-empty class names
- */
-export declare const normalizeClasses: (...classes: (string | string[])[]) => string[];
+export { normalizeClasses } from "./classes";
 /**
  * Creates a DOM element with attributes
  *

package/dist/core/index.d.ts

@@ -7,25 +7,21 @@
  *
  * @packageDocumentation
  */
-export * from './compose';
-export * from './dom';
-export { createEmitter } from './state/emitter';
-export type { Emitter, EventCallback } from './state/emitter';
-export { createStore, loggingMiddleware, deriveFiltered } from './state/store';
-export type { Store, StoreOptions, Selector, Computation, Updater } from './state/store';
-export { createLifecycle } from './state/lifecycle';
-export type { LifecycleManager, LifecycleManagers } from './state/lifecycle';
-export { createDisabled } from './state/disabled';
-export type { DisabledState } from './state/disabled';
-export { createEventManager as createStateEventManager } from './state/events';
-export type { EventManagerState } from './state/events';
-export * from './layout';
-export * from './collection';
-export * from './canvas';
-export { PREFIX, COMPONENTS, STATES, classNames, getComponentClass, getModifierClass, getElementClass } from './config';
-export { setComponentDefaults, getComponentDefaults, setGlobalDefaults, clearGlobalDefaults, type ComponentConfigMap } from './config/global';
-export { when, classNames as joinClasses, isObject, byString, hasTouchSupport, normalizeEvent, throttle, debounce, once, getInheritedBackground } from './utils';
-export { createGestureManager } from './gestures';
-export type { GestureManager, GestureConfig, GestureEvent, TapEvent, SwipeEvent, LongPressEvent, PinchEvent, RotateEvent, PanEvent, AnyGestureEvent, GestureHandler } from './gestures';
-export type { ThemeConfig, ComponentConfig, ThemedComponentConfig, VariantComponentConfig, StateComponentConfig } from './config';
-export type { NormalizedEvent } from './utils/mobile';
+export * from "./compose";
+export * from "./dom";
+export { createEmitter } from "./state/emitter";
+export type { Emitter, EventCallback } from "./state/emitter";
+export { createStore, loggingMiddleware, deriveFiltered } from "./state/store";
+export type { Store, StoreOptions, Selector, Computation, Updater, } from "./state/store";
+export { createLifecycle } from "./state/lifecycle";
+export type { LifecycleManager, LifecycleManagers } from "./state/lifecycle";
+export { createDisabled } from "./state/disabled";
+export type { DisabledState } from "./state/disabled";
+export { createEventManager as createStateEventManager } from "./state/events";
+export type { EventManagerState } from "./state/events";
+export * from "./canvas";
+export { PREFIX, COMPONENTS, STATES, classNames, getComponentClass, getModifierClass, getElementClass, } from "./config";
+export { setComponentDefaults, getComponentDefaults, setGlobalDefaults, clearGlobalDefaults, type ComponentConfigMap, } from "./config/global";
+export { when, classNames as joinClasses, isObject, byString, hasTouchSupport, normalizeEvent, throttle, debounce, once, getInheritedBackground, } from "./utils";
+export type { ThemeConfig, ComponentConfig, ThemedComponentConfig, VariantComponentConfig, StateComponentConfig, } from "./config";
+export type { NormalizedEvent } from "./utils/mobile";