mtrl 0.8.0 → 0.9.1

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

@@ -5,7 +5,6 @@ import { BaseComponent, ElementComponent } from "../component.js";
 export interface DisabledConfig {
     disabled?: boolean;
     componentName?: string;
-    [key: string]: any;
 }
 /**
  * Disabled state manager interface
@@ -44,4 +43,4 @@ export interface DisabledComponent extends BaseComponent {
  * @param config - Configuration object
  * @returns Function that enhances a component with disabled state management
  */
-export declare const withDisabled: <T extends DisabledConfig>(config: T) => <C extends ElementComponent>(component: C) => C & DisabledComponent;
+export declare const withDisabled: <T extends DisabledConfig & object>(config: T) => <C extends ElementComponent>(component: C) => C & DisabledComponent;

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

@@ -1,6 +1,7 @@
 /**
  * @module core/compose/features
  */
+import { EventCallback } from "../../state/emitter.js";
 import { BaseComponent } from "../component.js";
 /**
  * Component with event capabilities
@@ -12,21 +13,21 @@ export interface EventComponent extends BaseComponent {
      * @param handler - Event handler
      * @returns Component instance for chaining
      */
-    on(event: string, handler: (...args: any[]) => void): EventComponent;
+    on(event: string, handler: EventCallback): EventComponent;
     /**
      * Unsubscribe from an event
      * @param event - Event name
      * @param handler - Event handler
      * @returns Component instance for chaining
      */
-    off(event: string, handler: (...args: any[]) => void): EventComponent;
+    off(event: string, handler: EventCallback): EventComponent;
     /**
      * Emit an event
      * @param event - Event name
      * @param data - Event data
      * @returns Component instance for chaining
      */
-    emit(event: string, data?: any): EventComponent;
+    emit(event: string, data?: unknown): EventComponent;
 }
 /**
  * Adds event handling capabilities to a component

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

@@ -48,10 +48,6 @@ export interface IconConfig {
      * Text content (for determining button styling)
      */
     text?: string;
-    /**
-     * Additional configuration options
-     */
-    [key: string]: unknown;
 }
 /**
  * Component with icon capabilities
@@ -68,4 +64,4 @@ export interface IconComponent extends BaseComponent {
  * @param config - Configuration object containing icon information
  * @returns Function that enhances a component with icon capabilities
  */
-export declare const withIcon: <T extends IconConfig>(config: T) => <C extends ElementComponent>(component: C) => C & IconComponent;
+export declare const withIcon: <T extends IconConfig & object>(config: T) => <C extends ElementComponent>(component: C) => C & IconComponent;

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

@@ -35,7 +35,6 @@ export interface InputConfig {
      * Component name for classes
      */
     componentName?: string;
-    [key: string]: any;
 }
 /**
  * Component with input element and related methods
@@ -59,7 +58,7 @@ export interface InputComponent extends ElementComponent {
     /**
      * Event emission method if available
      */
-    emit?: (event: string, data: any) => InputComponent;
+    emit?: (event: string, data: unknown) => InputComponent;
 }
 /**
  * Creates an input element and adds it to a component
@@ -68,4 +67,4 @@ export interface InputComponent extends ElementComponent {
  * @param config - Input configuration
  * @returns Function that enhances a component with input functionality
  */
-export declare const withInput: <T extends InputConfig>(config?: T) => <C extends ElementComponent>(component: C) => C & InputComponent;
+export declare const withInput: <T extends InputConfig & object>(config?: T) => <C extends ElementComponent>(component: C) => C & InputComponent;

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

@@ -12,7 +12,7 @@ export interface ComponentManagers {
     icon?: {
         getElement: () => HTMLElement | null;
     };
-    [key: string]: any;
+    [key: string]: unknown;
 }
 /**
  * Lifecycle methods interface
@@ -58,4 +58,4 @@ export interface LifecycleComponent extends BaseComponent {
  *
  * @returns Function that enhances a component with lifecycle management
  */
-export declare const withLifecycle: () => <T extends ElementComponent>(component: T) => T & LifecycleComponent;
+export declare const withLifecycle: () => <T extends BaseComponent & Partial<Pick<ElementComponent, "element" | "destroy">>>(component: T) => T & LifecycleComponent;

package/dist/core/compose/features/lifecycle.js

@@ -2,22 +2,22 @@ import { getCleanup } from "../cleanup.js";
 import { createEmitter } from "../../state/emitter.js";
 function hasEvents(component) {
     return 'events' in component &&
-        component.events &&
         typeof component.events === 'object' &&
+        component.events !== null &&
         'destroy' in component.events &&
         typeof component.events.destroy === 'function';
 }
 function hasText(component) {
     return 'text' in component &&
-        component.text &&
         typeof component.text === 'object' &&
+        component.text !== null &&
         'getElement' in component.text &&
         typeof component.text.getElement === 'function';
 }
 function hasIcon(component) {
     return 'icon' in component &&
-        component.icon &&
         typeof component.icon === 'object' &&
+        component.icon !== null &&
         'getElement' in component.icon &&
         typeof component.icon.getElement === 'function';
 }

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

@@ -18,7 +18,6 @@ export interface PositionConfig {
     position?: string;
     prefix?: string;
     componentName?: string;
-    [key: string]: any;
 }
 /**
  * Position manager interface
@@ -48,4 +47,4 @@ export interface PositionComponent extends BaseComponent {
  * @param config - Configuration object containing position information
  * @returns Function that enhances a component with position capabilities
  */
-export declare const withPosition: <T extends PositionConfig>(config: T) => <C extends ElementComponent>(component: C) => C & PositionComponent;
+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

@@ -38,7 +38,6 @@ export interface RippleController {
 export interface RippleFeatureConfig {
     ripple?: boolean;
     rippleConfig?: RippleConfig;
-    [key: string]: any;
 }
 /**
  * Component with ripple capabilities
@@ -58,4 +57,4 @@ export declare const createRipple: (config?: RippleConfig) => RippleController;
  * @param config - Configuration object
  * @returns Function that enhances a component with ripple effect
  */
-export declare const withRipple: <T extends RippleFeatureConfig>(config: T) => <C extends ElementComponent & Partial<LifecycleComponent>>(component: C) => C & RippleComponent;
+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

@@ -6,7 +6,6 @@ export interface SizeConfig {
     size?: string;
     prefix?: string;
     componentName?: string;
-    [key: string]: any;
 }
 /**
  * Adds a size class to a component
@@ -14,4 +13,4 @@ export interface SizeConfig {
  * @param config - Configuration object containing size information
  * @returns Function that enhances a component with the size class
  */
-export declare const withSize: <T extends SizeConfig>(config: T) => <C extends ElementComponent>(component: C) => C;
+export declare const withSize: <T extends SizeConfig & object>(config: T) => <C extends ElementComponent>(component: C) => C;

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

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

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

@@ -40,10 +40,6 @@ export interface TextConfig {
      * Element to insert text before (optional)
      */
     beforeElement?: HTMLElement;
-    /**
-     * Additional configuration options
-     */
-    [key: string]: any;
 }
 /**
  * Component with text capabilities
@@ -60,4 +56,4 @@ export interface TextComponent extends BaseComponent {
  * @param config - Configuration object containing text information
  * @returns Function that enhances a component with text capabilities
  */
-export declare const withText: <T extends TextConfig>(config: T) => <C extends ElementComponent>(component: C) => C & TextComponent;
+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

@@ -43,7 +43,6 @@ export interface TextInputConfig {
      * Placeholder attribute
      */
     placeholder?: string;
-    [key: string]: any;
 }
 /**
  * Component with text input capabilities
@@ -86,7 +85,7 @@ export interface TextInputComponent extends ElementComponent {
     /**
      * Event emission method if available
      */
-    emit?: (event: string, data: any) => TextInputComponent;
+    emit?: (event: string, data: unknown) => TextInputComponent;
 }
 /**
  * Enhances a component with text input functionality
@@ -94,4 +93,4 @@ export interface TextInputComponent extends ElementComponent {
  * @param config - Text input configuration
  * @returns Function that enhances a component with text input capabilities
  */
-export declare const withTextInput: <T extends TextInputConfig>(config?: T) => <C extends ElementComponent>(component: C) => C & TextInputComponent;
+export declare const withTextInput: <T extends TextInputConfig & object>(config?: T) => <C extends ElementComponent>(component: C) => C & TextInputComponent;

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

@@ -19,7 +19,6 @@ export interface TextLabelConfig {
      * Component name for class generation
      */
     componentName?: string;
-    [key: string]: any;
 }
 /**
  * Label manager interface
@@ -54,4 +53,4 @@ export interface LabelComponent extends BaseComponent {
  * @param config - Configuration object containing label information
  * @returns Function that enhances a component with a label
  */
-export declare const withTextLabel: <T extends TextLabelConfig>(config?: T) => <C extends ElementComponent>(component: C) => C & LabelComponent;
+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

@@ -18,7 +18,6 @@ export interface ThrottleConfig {
             trailing?: boolean;
         };
     }>;
-    [key: string]: any;
 }
 /**
  * Component with throttled event capabilities
@@ -71,5 +70,5 @@ export interface ThrottleComponent extends BaseComponent {
  * )(config);
  * ```
  */
-export declare const withThrottle: (config?: ThrottleConfig) => <C extends ElementComponent>(component: C) => C & ThrottleComponent;
+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

@@ -18,7 +18,6 @@ export interface TrackConfig {
      * Custom icon HTML or 'none'
      */
     icon?: string;
-    [key: string]: any;
 }
 /**
  * Component with track and thumb elements

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

@@ -6,7 +6,6 @@ export interface VariantConfig {
     variant?: string;
     prefix?: string;
     componentName?: string;
-    [key: string]: any;
 }
 /**
  * Adds a variant class to a component
@@ -14,4 +13,4 @@ export interface VariantConfig {
  * @param config - Configuration object containing variant information
  * @returns Function that enhances a component with the variant class
  */
-export declare const withVariant: <T extends VariantConfig>(config: T) => <C extends ElementComponent>(component: C) => C;
+export declare const withVariant: <T extends VariantConfig & object>(config: T) => <C extends ElementComponent>(component: C) => C;

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

@@ -7,7 +7,7 @@ export { createComponent } from "./base.js";
 export { createBase, withElement } from "./component.js";
 export { withEvents, withIcon, withSize, withPosition, withText, withVariant, withDisabled, withLifecycle, withRipple, withInput, withCheckable, withStyle, withTextInput, withTextLabel, withTrack, withEnhancedEvents, withThrottle, withDebounce, } from "./features/index.js";
 export type { Component } from "./base.js";
-export type { BaseComponent, ElementComponent, TouchState, WithElementOptions, } from "./component.js";
+export type { BaseComponent, BaseConfig, ElementComponent, TouchState, WithElementOptions, } from "./component.js";
 export type { EventComponent, TextComponent, IconComponent, LifecycleComponent, Lifecycle, DisabledComponent, DisabledManager, RippleComponent, InputComponent, CheckableComponent, CheckableManager, TextInputComponent, LabelComponent, TrackComponent, EnhancedEventComponent, ThrottleComponent, ThrottleConfig, DebounceComponent, DebounceConfig, } from "./features/index.js";
 export { hasLifecycle, hasEmit } from "./utils/type-guards.js";
 export type { ComponentWithLifecycle, ComponentWithEmit, } from "./utils/type-guards.js";

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

@@ -17,7 +17,27 @@
  * const addOneThenDouble = pipe(addOne, double);
  * console.log(addOneThenDouble(3)); // Output: 8
  */
-export declare const pipe: <T>(...fns: Array<(arg: any) => any>) => (x: T) => any;
+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;
+export declare function pipe<A, B, C, D, E>(f1: (arg: A) => B, f2: (arg: B) => C, f3: (arg: C) => D, f4: (arg: D) => E): (x: A) => E;
+export declare function pipe<A, B, C, D, E, F>(f1: (arg: A) => B, f2: (arg: B) => C, f3: (arg: C) => D, f4: (arg: D) => E, f5: (arg: E) => F): (x: A) => F;
+export declare function pipe<A, B, C, D, E, F, G>(f1: (arg: A) => B, f2: (arg: B) => C, f3: (arg: C) => D, f4: (arg: D) => E, f5: (arg: E) => F, f6: (arg: F) => G): (x: A) => G;
+export declare function pipe<A, B, C, D, E, F, G, H>(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): (x: A) => H;
+export declare function pipe<A, B, C, D, E, F, G, H, I>(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): (x: A) => I;
+export declare function pipe<A, B, C, D, E, F, G, H, I, J>(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): (x: A) => J;
+export declare function pipe<A, B, C, D, E, F, G, H, I, J, K>(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): (x: A) => K;
+export declare function pipe<A, B, C, D, E, F, G, H, I, J, K, L>(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): (x: A) => L;
+export declare function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M>(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): (x: A) => M;
+export declare function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N>(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): (x: A) => N;
+export declare function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>(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): (x: A) => O;
+export declare function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>(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): (x: A) => P;
+export declare function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q>(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): (x: A) => Q;
+export declare function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R>(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): (x: A) => R;
+export declare function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S>(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): (x: A) => S;
+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))
@@ -33,7 +53,27 @@ export declare const pipe: <T>(...fns: Array<(arg: any) => any>) => (x: T) => an
  * const doubleTheAddOne = compose(addOne, double);
  * console.log(doubleTheAddOne(3)); // Output: 7
  */
-export declare const compose: <T>(...fns: Array<(arg: any) => any>) => (x: T) => any;
+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;
+export declare function compose<A, B, C, D, E>(f4: (arg: D) => E, f3: (arg: C) => D, f2: (arg: B) => C, f1: (arg: A) => B): (x: A) => E;
+export declare function compose<A, B, C, D, E, F>(f5: (arg: E) => F, f4: (arg: D) => E, f3: (arg: C) => D, f2: (arg: B) => C, f1: (arg: A) => B): (x: A) => F;
+export declare function compose<A, B, C, D, E, F, G>(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) => G;
+export declare function compose<A, B, C, D, E, F, G, H>(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) => H;
+export declare function compose<A, B, C, D, E, F, G, H, I>(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) => I;
+export declare function compose<A, B, C, D, E, F, G, H, I, J>(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) => J;
+export declare function compose<A, B, C, D, E, F, G, H, I, J, K>(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) => K;
+export declare function compose<A, B, C, D, E, F, G, H, I, J, K, L>(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) => L;
+export declare function compose<A, B, C, D, E, F, G, H, I, J, K, L, M>(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) => M;
+export declare function compose<A, B, C, D, E, F, G, H, I, J, K, L, M, N>(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) => N;
+export declare function compose<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>(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) => O;
+export declare function compose<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>(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) => P;
+export declare function compose<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q>(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) => Q;
+export declare function compose<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R>(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) => R;
+export declare function compose<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S>(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) => S;
+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.
@@ -51,7 +91,7 @@ export declare const compose: <T>(...fns: Array<(arg: any) => any>) => (x: T) =>
  * const person = createPerson({}, { name: 'John', age: 30 });
  * // Result: { name: 'John', age: 30 }
  */
-export declare const transform: <T, C = Record<string, any>>(...transformers: Array<(obj: T, context: C) => Partial<T>>) => (obj: T, context?: C) => T;
+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/pipe.js

@@ -1,5 +1,9 @@
-export const pipe = (...fns) => (x) => fns.reduce((v, f) => f(v), x);
-export const compose = (...fns) => (x) => fns.reduceRight((v, f) => f(v), x);
+export function pipe(...fns) {
+    return (x) => fns.reduce((v, f) => f(v), x);
+}
+export function compose(...fns) {
+    return (x) => fns.reduceRight((v, f) => f(v), x);
+}
 export const transform = (...transformers) => (obj, context = {}) => transformers.reduce((acc, transformer) => ({
     ...acc,
     ...transformer(acc, context)

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

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

package/dist/core/compose/utils/type-guards.js

@@ -1,7 +1,7 @@
 export function hasLifecycle(component) {
     return 'lifecycle' in component &&
-        component.lifecycle &&
         typeof component.lifecycle === 'object' &&
+        component.lifecycle !== null &&
         'destroy' in component.lifecycle &&
         typeof component.lifecycle.destroy === 'function';
 }

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

@@ -1,3 +1,4 @@
+import type { EventCondition } from "../dom/create.js";
 /**
  * Base component configuration interface
  * Common configuration properties shared by all components
@@ -20,23 +21,25 @@ export interface BaseComponentConfig {
     ariaDescribedBy?: string;
     ariaLabelledBy?: string;
     ariaHidden?: boolean;
-    [key: string]: any;
 }
 /**
  * Creates a base configuration for any component
  * Automatically merges global defaults if available
  *
- * @param {BaseComponentConfig} defaults - Default configuration for the component
- * @param {BaseComponentConfig} userConfig - User provided configuration
+ * @param {T} defaults - Default configuration for the component
+ * @param {Partial<T>} userConfig - User provided configuration
  * @param {string} componentName - The name of the component
- * @returns {BaseComponentConfig} Complete configuration with defaults applied
+ * @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: (defaults: BaseComponentConfig, userConfig: BaseComponentConfig, componentName: string) => BaseComponentConfig;
+export declare const createComponentConfig: <T extends BaseComponentConfig & object>(defaults: T, userConfig: Partial<T>, componentName: string) => T & {
+    componentName: string;
+    prefix: string;
+};
 /**
  * Creates a class name with proper prefixing
  *
@@ -82,16 +85,16 @@ export declare const processClassNames: (classNames: string | string[] | null) =
  */
 export declare const createElementConfig: (config: BaseComponentConfig, options: {
     tag: string;
-    attributes?: Record<string, any>;
+    attributes?: Record<string, unknown>;
     className?: string | string[] | null;
     html?: string;
     text?: string;
-    forwardEvents?: Record<string, boolean | ((component: any, event: Event) => boolean)>;
+    forwardEvents?: Record<string, EventCondition>;
     interactive?: boolean;
 }) => {
     tag: string;
     componentName: string;
-    attributes: Record<string, any>;
+    attributes: Record<string, unknown>;
     className: string[];
     rawClass: string | string[];
     id: string;
@@ -107,6 +110,6 @@ export declare const createElementConfig: (config: BaseComponentConfig, options:
     ariaHidden: boolean;
     html: string;
     text: string;
-    forwardEvents: Record<string, boolean | ((component: any, event: Event) => boolean)>;
+    forwardEvents: Record<string, EventCondition>;
     interactive: boolean;
 };

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

@@ -5,24 +5,28 @@
  * without adding complexity or performance overhead.
  */
 import { ButtonConfig } from "../../components/button/types.js";
+import type { CardSchema } from "../../components/card/types.js";
+import type { CheckboxConfig } from "../../components/checkbox/types.js";
+import type { ChipConfig } from "../../components/chips/types.js";
+import type { DialogConfig } from "../../components/dialog/types.js";
 import type { NavigationRailConfig } from "../../components/navigation-rail/types.js";
+import type { SliderConfig } from "../../components/slider/types.js";
+import type { SwitchConfig } from "../../components/switch/types.js";
 import { TextfieldConfig } from "../../components/textfield/types.js";
 /**
  * Component configuration map
  * Add new components here as they support global config
- *
- * For components not yet integrated, use Partial<any> as a placeholder
  */
 export interface ComponentConfigMap {
     "navigation-rail"?: Partial<NavigationRailConfig>;
     button?: Partial<ButtonConfig>;
     textfield?: Partial<TextfieldConfig>;
-    checkbox?: Partial<any>;
-    switch?: Partial<any>;
-    slider?: Partial<any>;
-    card?: Partial<any>;
-    chip?: Partial<any>;
-    dialog?: Partial<any>;
+    checkbox?: Partial<CheckboxConfig>;
+    switch?: Partial<SwitchConfig>;
+    slider?: Partial<SliderConfig>;
+    card?: Partial<CardSchema>;
+    chip?: Partial<ChipConfig>;
+    dialog?: Partial<DialogConfig>;
 }
 /**
  * Sets global defaults for a specific component

package/dist/core/config.d.ts

@@ -47,7 +47,7 @@ export interface ThemeConfig {
     /**
      * Theme variants
      */
-    variants: Record<string, any>;
+    variants: Record<string, unknown>;
 }
 /**
  * Component configuration interface

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

@@ -6,11 +6,11 @@
  * 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
- * @returns {HTMLElement} The element for chaining
+ * @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: (element: HTMLElement, attributes?: Record<string, any>) => HTMLElement;
+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
@@ -25,13 +25,13 @@ export declare const removeAttributes: (element: HTMLElement, attributes?: strin
  * 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
+ * @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?: any;
+    value?: unknown;
 }>) => HTMLElement;
 /**
  * Check if element has attribute

package/dist/core/dom/attributes.js

@@ -1,18 +1,21 @@
+import { safeUrl, URL_ATTRIBUTES } from "../utils/url.js";
 export const setAttributes = (element, attributes = {}) => {
     if (!attributes)
         return element;
+    const values = attributes;
+    const attributeValue = (key, value) => URL_ATTRIBUTES.has(key.toLowerCase()) ? safeUrl(String(value)) : String(value);
     const keys = Object.keys(attributes);
     if (keys.length === 1) {
-        const value = attributes[keys[0]];
+        const value = values[keys[0]];
         if (value != null) {
-            element.setAttribute(keys[0], String(value));
+            element.setAttribute(keys[0], attributeValue(keys[0], value));
         }
         return element;
     }
     for (const key in attributes) {
-        const value = attributes[key];
+        const value = values[key];
         if (value != null) {
-            element.setAttribute(key, String(value));
+            element.setAttribute(key, attributeValue(key, value));
         }
     }
     return element;
@@ -27,7 +30,7 @@ export const batchAttributes = (element, operations) => {
     for (let i = 0; i < operations.length; i++) {
         const op = operations[i];
         if (op.action === "set" && op.value != null) {
-            element.setAttribute(op.key, String(op.value));
+            element.setAttribute(op.key, URL_ATTRIBUTES.has(op.key.toLowerCase()) ? safeUrl(String(op.value)) : String(op.value));
         }
         else if (op.action === "remove") {
             element.removeAttribute(op.key);