mtrl 0.8.0 → 0.9.0

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

@@ -6,7 +6,7 @@ export { normalizeClasses } from "./classes.js";
  * @param attributes - Element attributes
  * @returns Created element
  */
-export declare const createElement: <T extends HTMLElement>(tag: string, attributes?: Record<string, any>) => T;
+export declare const createElement: <T extends HTMLElement>(tag: string, attributes?: Record<string, unknown>) => T;
 /**
  * Sets inline styles on an element
  *

package/dist/core/state/emitter.d.ts

@@ -4,7 +4,7 @@
 /**
  * Type definition for event callback functions
  */
-export type EventCallback = (...args: any[]) => void;
+export type EventCallback = (...args: never[]) => void;
 /**
  * Interface for the event emitter
  */
@@ -27,7 +27,7 @@ export interface Emitter {
      * @param event - Event name
      * @param args - Event arguments
      */
-    emit(event: string, ...args: any[]): void;
+    emit(event: string, ...args: unknown[]): void;
     /**
      * Clear all event listeners
      */

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

@@ -8,14 +8,14 @@ export interface EventManagerState {
      * @param handler - Event handler
      * @returns EventManagerState instance for chaining
      */
-    on: (event: string, handler: (...args: any[]) => void) => EventManagerState;
+    on: (event: string, handler: (...args: never[]) => void) => EventManagerState;
     /**
      * Removes an event listener
      * @param event - Event name
      * @param handler - Event handler
      * @returns EventManagerState instance for chaining
      */
-    off: (event: string, handler: (...args: any[]) => void) => EventManagerState;
+    off: (event: string, handler: (...args: never[]) => void) => EventManagerState;
     /**
      * Removes all event listeners and cleans up
      */
@@ -24,7 +24,7 @@ export interface EventManagerState {
      * Gets all active handlers
      * @returns Map of event names to handlers
      */
-    getHandlers: () => Map<(...args: any[]) => void, string>;
+    getHandlers: () => Map<(...args: never[]) => void, string>;
 }
 /**
  * Creates an event manager for a component

package/dist/core/state/lifecycle.d.ts

@@ -11,7 +11,6 @@ export interface LifecycleManagers {
     icon?: {
         getElement: () => HTMLElement | null;
     };
-    [key: string]: any;
 }
 /**
  * Lifecycle manager interface

package/dist/core/state/store.d.ts

@@ -64,7 +64,7 @@ export interface Store<T> {
  * @param options - Store options
  * @returns State store interface
  */
-export declare const createStore: <T extends Record<string, any>>(initialState?: T, options?: StoreOptions<T>) => Store<T>;
+export declare const createStore: <T extends object>(initialState?: T, options?: StoreOptions<T>) => Store<T>;
 /**
  * Example middleware that logs state changes
  *
@@ -72,11 +72,11 @@ export declare const createStore: <T extends Record<string, any>>(initialState?:
  * @param oldState - Previous state before change
  * @returns Processed state (unchanged in this middleware)
  */
-export declare const loggingMiddleware: <T extends Record<string, any>>(newState: T, oldState: T) => T;
+export declare const loggingMiddleware: <T extends object>(newState: T, oldState: T) => T;
 /**
  * Creates a derived state selector for filtering objects
  *
  * @param predicate - Filter predicate function
  * @returns Computation function for derived state
  */
-export declare const deriveFiltered: <T>(predicate: (value: any, key: string) => boolean) => (state: Record<string, T>) => Record<string, T>;
+export declare const deriveFiltered: <T>(predicate: (value: T, key: string) => boolean) => (state: Record<string, T>) => Record<string, T>;

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

@@ -3,11 +3,11 @@
  * @param value - The value to check
  * @returns true if the value is a plain object
  */
-export declare const isObject: (value: unknown) => value is Record<string, any>;
+export declare const isObject: (value: unknown) => value is Record<string, unknown>;
 /**
  * Accesses a nested property of an object using a string path
  * @param obj - The object to traverse
  * @param path - The property path (e.g. 'user.address.street')
  * @returns The value at the specified path or undefined if not found
  */
-export declare const byString: <T extends Record<string, any>, R = any>(obj: T, path: string) => R | undefined;
+export declare const byString: <T extends object, R = unknown>(obj: T, path: string) => R | undefined;

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

@@ -27,7 +27,7 @@ export type Cancellable<F> = F & {
  *
  * window.addEventListener('scroll', throttledScroll);
  */
-export declare const throttle: <T extends (...args: any[]) => any>(fn: T, wait: number, options?: {
+export declare const throttle: <T extends (...args: never[]) => unknown>(fn: T, wait: number, options?: {
     leading?: boolean;
     trailing?: boolean;
 }) => Cancellable<(...args: Parameters<T>) => void>;
@@ -56,7 +56,7 @@ export declare const throttle: <T extends (...args: any[]) => any>(fn: T, wait:
  *   debouncedSearch(e.target.value);
  * });
  */
-export declare const debounce: <T extends (...args: any[]) => any>(fn: T, wait: number, options?: {
+export declare const debounce: <T extends (...args: never[]) => unknown>(fn: T, wait: number, options?: {
     leading?: boolean;
     maxWait?: number;
 }) => Cancellable<(...args: Parameters<T>) => void>;
@@ -79,4 +79,4 @@ export declare const debounce: <T extends (...args: any[]) => any>(fn: T, wait:
  * button1.addEventListener('click', initApp);
  * button2.addEventListener('click', initApp);
  */
-export declare const once: <T extends (...args: any[]) => any>(fn: T) => ((...args: Parameters<T>) => ReturnType<T>);
+export declare const once: <T extends (...args: never[]) => unknown>(fn: T) => ((...args: Parameters<T>) => ReturnType<T>);

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

@@ -25,7 +25,7 @@ export interface ValidationRule {
     /**
      * Allowed values (enum)
      */
-    enum?: any[];
+    enum?: unknown[];
     /**
      * Minimum string length
      */
@@ -37,11 +37,11 @@ export interface ValidationRule {
     /**
      * Default value
      */
-    default?: any;
+    default?: unknown;
     /**
      * Custom validator function
      */
-    validator?: (value: any) => boolean | string;
+    validator?(value: unknown): boolean | string;
 }
 /**
  * Validation schema type
@@ -54,7 +54,7 @@ export type ValidationSchema = Record<string, ValidationRule>;
  * @param schema - Validation schema
  * @throws Error if validation fails
  */
-export declare const validateConfig: (config: Record<string, any>, schema: ValidationSchema) => void;
+export declare const validateConfig: (config: object, schema: ValidationSchema) => void;
 /**
  * Validates a single value against a rule
  *
@@ -62,7 +62,7 @@ export declare const validateConfig: (config: Record<string, any>, schema: Valid
  * @param rule - Validation rule
  * @returns Validation result (true if valid, error message if invalid)
  */
-export declare const validateValue: (value: any, rule: ValidationRule) => true | string;
+export declare const validateValue: (value: unknown, rule: ValidationRule) => true | string;
 /**
  * Applies default values from schema to config
  *
@@ -70,4 +70,4 @@ export declare const validateValue: (value: any, rule: ValidationRule) => true |
  * @param schema - Validation schema with defaults
  * @returns Configuration with defaults applied
  */
-export declare const applyDefaults: <T extends Record<string, any>>(config: T, schema: ValidationSchema) => T;
+export declare const applyDefaults: <T extends object>(config: T, schema: ValidationSchema) => T;

package/dist/core/utils/validate.js

@@ -1,47 +1,48 @@
 export const validateConfig = (config, schema) => {
     const errors = [];
+    const values = config;
     Object.entries(schema).forEach(([key, rule]) => {
-        if (rule.required && config[key] === undefined) {
+        if (rule.required && values[key] === undefined) {
             errors.push(`Missing required field: ${key}`);
         }
-        if (config[key] !== undefined) {
+        if (values[key] !== undefined) {
             if (rule.type) {
-                const actualType = typeof config[key];
+                const actualType = typeof values[key];
                 if (actualType !== rule.type) {
                     errors.push(`Invalid type for ${key}: expected ${rule.type}, got ${actualType}`);
                 }
             }
-            if (typeof config[key] === 'number') {
-                if (rule.minimum !== undefined && config[key] < rule.minimum) {
+            if (typeof values[key] === 'number') {
+                if (rule.minimum !== undefined && values[key] < rule.minimum) {
                     errors.push(`Value for ${key} is too small: minimum is ${rule.minimum}`);
                 }
-                if (rule.maximum !== undefined && config[key] > rule.maximum) {
+                if (rule.maximum !== undefined && values[key] > rule.maximum) {
                     errors.push(`Value for ${key} is too large: maximum is ${rule.maximum}`);
                 }
             }
-            if (typeof config[key] === 'string') {
-                if (rule.minLength !== undefined && config[key].length < rule.minLength) {
+            if (typeof values[key] === 'string') {
+                if (rule.minLength !== undefined && values[key].length < rule.minLength) {
                     errors.push(`String for ${key} is too short: minimum length is ${rule.minLength}`);
                 }
-                if (rule.maxLength !== undefined && config[key].length > rule.maxLength) {
+                if (rule.maxLength !== undefined && values[key].length > rule.maxLength) {
                     errors.push(`String for ${key} is too long: maximum length is ${rule.maxLength}`);
                 }
                 if (rule.pattern) {
                     const pattern = rule.pattern instanceof RegExp
                         ? rule.pattern
                         : new RegExp(rule.pattern);
-                    if (!pattern.test(config[key])) {
+                    if (!pattern.test(values[key])) {
                         errors.push(`Invalid format for ${key}: must match pattern ${pattern}`);
                     }
                 }
             }
             if (rule.enum) {
-                if (!rule.enum.includes(config[key])) {
+                if (!rule.enum.includes(values[key])) {
                     errors.push(`Invalid value for ${key}. Must be one of: ${rule.enum.join(', ')}`);
                 }
             }
             if (rule.validator) {
-                const result = rule.validator(config[key]);
+                const result = rule.validator(values[key]);
                 if (result === false) {
                     errors.push(`Invalid value for ${key}`);
                 }