@coherent.js/core 1.0.0-beta.2 → 1.0.0-beta.3

package/dist/components/component-system.js

@@ -85,8 +85,8 @@ class ComponentState {
             try {
                 listener(newState, oldState);
             }
-            catch (error) {
-                console.error('State listener error:', error);
+            catch (_error) {
+                console._error('State listener _error:', _error);
             }
         });
         this.isUpdating = false;
@@ -215,20 +215,20 @@ export class Component {
                 return this.hooks[hookName].call(this, ...args);
             }
         }
-        catch (error) {
-            this.handleError(error, `${hookName} hook`);
+        catch (_error) {
+            this.handleError(_error, `${hookName} hook`);
         }
     }
     /**
      * Handle component errors
      */
-    handleError(error) {
-        console.error(`Component Error in ${this.name}:`, error);
-        // Call error hook
-        this.callHook('errorCaptured', error);
+    handleError(_error) {
+        console._error(`Component Error in ${this.name}:`, _error);
+        // Call _error hook
+        this.callHook('errorCaptured', _error);
         // Propagate to parent
         if (this.parent && this.parent.handleError) {
-            this.parent.handleError(error, `${this.name} -> ${context}`);
+            this.parent.handleError(_error, `${this.name} -> ${context}`);
         }
     }
     /**
@@ -263,9 +263,9 @@ export class Component {
             }
             return this.rendered;
         }
-        catch (error) {
-            this.handleError(error);
-            return { div: { className: 'component-error', text: `Error in ${this.name}` } };
+        catch (_error) {
+            this.handleError(_error);
+            return { div: { className: 'component-_error', text: `Error in ${this.name}` } };
         }
     }
     /**
@@ -384,9 +384,9 @@ export function createComponent(definition) {
  * Create a component factory
  */
 export function defineComponent(definition) {
-    const componentFactory = (_props) => {
+    const componentFactory = (props) => {
         const component = new Component(definition);
-        return component.render(_props);
+        return component.render(props);
     };
     // Add static properties
     componentFactory.componentName = definition.name || 'Component';
@@ -425,8 +425,8 @@ export function createHOC(enhancer) {
     return (WrappedComponent) => {
         return defineComponent({
             name: `HOC(${WrappedComponent.componentName || 'Component'})`,
-            render(_props) {
-                return enhancer(WrappedComponent, _props);
+            render(props) {
+                return enhancer(WrappedComponent, props);
             }
         });
     };
@@ -472,8 +472,8 @@ export const compose = {
     combine: (...components) => {
         return defineComponent({
             name: 'ComposedComponent',
-            render(_props) {
-                return components.map(comp => typeof comp === 'function' ? comp(_props) : comp);
+            render(props) {
+                return components.map(comp => typeof comp === 'function' ? comp(props) : comp);
             }
         });
     },
@@ -483,16 +483,16 @@ export const compose = {
     conditional: (condition, trueComponent, falseComponent = null) => {
         return defineComponent({
             name: 'ConditionalComponent',
-            render(_props) {
+            render(props) {
                 const shouldRender = typeof condition === 'function' ?
-                    condition(_props) : condition;
+                    condition(props) : condition;
                 if (shouldRender) {
                     return typeof trueComponent === 'function' ?
-                        trueComponent(_props) : trueComponent;
+                        trueComponent(props) : trueComponent;
                 }
                 else if (falseComponent) {
                     return typeof falseComponent === 'function' ?
-                        falseComponent(_props) : falseComponent;
+                        falseComponent(props) : falseComponent;
                 }
                 return null;
             }
@@ -504,8 +504,8 @@ export const compose = {
     loop: (data, itemComponent, keyFn = (item, index) => index) => {
         return defineComponent({
             name: 'LoopComponent',
-            render(_props) {
-                const items = typeof data === 'function' ? data(_props) : data;
+            render(props) {
+                const items = typeof data === 'function' ? data(props) : data;
                 if (!Array.isArray(items)) {
                     console.warn('Loop component expects array data');
                     return null;
@@ -692,9 +692,9 @@ export function lazy(factory, options = {}) {
                 }
                 // Handle promises
                 if (result && typeof result.then === 'function') {
-                    return result.catch(error => {
+                    return result.catch(_error => {
                         if (onError)
-                            onError(error);
+                            onError(_error);
                         return fallback;
                     });
                 }
@@ -705,12 +705,12 @@ export function lazy(factory, options = {}) {
                 }
                 return result;
             }
-            catch (error) {
+            catch (_error) {
                 if (onError) {
-                    onError(error);
+                    onError(_error);
                 }
                 else {
-                    console.error('Lazy evaluation error:', error);
+                    console._error('Lazy evaluation _error:', _error);
                 }
                 return fallback;
             }
@@ -831,7 +831,7 @@ export function batchEvaluate(lazyValues, ...args) {
             const result = lazyValue.evaluate(...args);
             if (result && typeof result.then === 'function') {
                 promises.push(result.then(value => ({ key, value }))
-                    .catch(error => ({ key, error })));
+                    .catch(_error => ({ key, _error })));
             }
             else {
                 results[key] = result;
@@ -845,9 +845,9 @@ export function batchEvaluate(lazyValues, ...args) {
         return results;
     }
     return Promise.all(promises).then(asyncResults => {
-        asyncResults.forEach(({ key, value, error }) => {
-            if (error) {
-                console.error(`Batch evaluation error for ${key}:`, error);
+        asyncResults.forEach(({ key, value, _error }) => {
+            if (_error) {
+                console._error(`Batch evaluation _error for ${key}:`, _error);
                 results[key] = null;
             }
             else {
@@ -884,9 +884,9 @@ function evaluateWithTimeout(factory, timeout, args, fallback) {
                     clearTimeout(timer);
                     resolve(value);
                 })
-                    .catch(error => {
+                    .catch(_error => {
                     clearTimeout(timer);
-                    reject(error);
+                    reject(_error);
                 });
             }
             else {
@@ -894,9 +894,9 @@ function evaluateWithTimeout(factory, timeout, args, fallback) {
                 resolve(result);
             }
         }
-        catch (error) {
+        catch (_error) {
             clearTimeout(timer);
-            reject(error);
+            reject(_error);
         }
     }).catch(() => fallback);
 }
@@ -1091,16 +1091,16 @@ export function memoComponent(component, options = {}) {
     const { propsEqual = shallowEqual, stateEqual = shallowEqual, name = component.name || 'AnonymousComponent' } = options;
     return memo((props = {}, state = {}, context = {}) => {
         return typeof component === 'function' ?
-            component(props, state, _context) :
+            component(props, state, context) :
             component;
     }, {
         keyFn: (props, state) => {
             // Create key based on props and state
-            return `${name}:${JSON.stringify(_props)}:${JSON.stringify(state)}`;
+            return `${name}:${JSON.stringify(props)}:${JSON.stringify(state)}`;
         },
         compareFn: (a, b) => {
             // Custom comparison for component args
-            return propsEqual(a.props, b._props) &&
+            return propsEqual(a.props, b.props) &&
                 stateEqual(a.state, b.state);
         },
         ...options
@@ -1120,10 +1120,10 @@ export function memoAsync(asyncFn, options = {}) {
             return promiseCache.get(key);
         }
         // Start new async operation
-        const promise = asyncFn(...args).catch(error => {
+        const promise = asyncFn(...args).catch(_error => {
             // Remove failed promise from cache
             promiseCache.delete(key);
-            throw error;
+            throw _error;
         });
         promiseCache.set(key, promise);
         // Clean up resolved promise
@@ -1200,7 +1200,7 @@ class TTLCache {
     }
     get(key) {
         if (this.cache.has(key)) {
-            const _entry = this.cache.get(key);
+            const entry = this.cache.get(key);
             if (Date.now() < entry.expires) {
                 return entry.value;
             }
@@ -1226,7 +1226,7 @@ class TTLCache {
     }
     has(key) {
         if (this.cache.has(key)) {
-            const _entry = this.cache.get(key);
+            const entry = this.cache.get(key);
             return Date.now() < entry.expires;
         }
         return false;
@@ -1234,7 +1234,7 @@ class TTLCache {
     delete(key) {
         const had = this.cache.has(key);
         if (had) {
-            const _entry = this.cache.get(key);
+            const entry = this.cache.get(key);
             this.cache.delete(key);
             if (this.timers.has(key)) {
                 clearTimeout(this.timers.get(key));
@@ -1367,7 +1367,7 @@ export function withProps(propsTransform, options = {}) {
     memoOptions = {}, // Memoization options
     // Error handling
     onError = null, // Error handler for transformation
-    fallbackProps = {}, // Fallback props on error
+    fallbackProps = {}, // Fallback props on _error
     // Development
     displayName = null, // Component name for debugging
     debug = false, // Debug logging
@@ -1382,7 +1382,7 @@ export function withProps(propsTransform, options = {}) {
                 // Transform props
                 let transformedProps;
                 if (typeof propsTransform === 'function') {
-                    transformedProps = propsTransform(originalProps, state, _context);
+                    transformedProps = propsTransform(originalProps, state, context);
                 }
                 else if (typeof propsTransform === 'object') {
                     transformedProps = propsTransform;
@@ -1393,26 +1393,26 @@ export function withProps(propsTransform, options = {}) {
                 // Handle async transformations
                 if (transformedProps && typeof transformedProps.then === 'function') {
                     return transformedProps.then(resolved => {
-                        return processProps(resolved, originalProps, WrappedComponent, state, _context);
-                    }).catch(error => {
+                        return processProps(resolved, originalProps, WrappedComponent, state, context);
+                    }).catch(_error => {
                         if (onError)
-                            onError(error, originalProps);
-                        return processProps(fallbackProps, originalProps, WrappedComponent, state, _context);
+                            onError(_error, originalProps);
+                        return processProps(fallbackProps, originalProps, WrappedComponent, state, context);
                     });
                 }
-                return processProps(transformedProps, originalProps, WrappedComponent, state, _context);
+                return processProps(transformedProps, originalProps, WrappedComponent, state, context);
             }
-            catch (error) {
+            catch (_error) {
                 if (debug)
-                    console.error('withProps error:', error);
+                    console._error('withProps _error:', _error);
                 if (onError)
-                    onError(error, originalProps);
+                    onError(_error, originalProps);
                 // Use fallback props
-                return processProps(fallbackProps, originalProps, WrappedComponent, state, _context);
+                return processProps(fallbackProps, originalProps, WrappedComponent, state, context);
             }
         }
         // Process and merge props
-        function processProps(transformed, original, component, state, _context) {
+        function processProps(transformed, original, component, state, context) {
             let finalProps;
             if (merge) {
                 if (override) {
@@ -1449,7 +1449,7 @@ export function withProps(propsTransform, options = {}) {
             }
             // Render wrapped component
             return typeof component === 'function' ?
-                component(finalProps, state, _context) :
+                component(finalProps, state, context) :
                 component;
         }
         // Set display name for debugging
@@ -1480,16 +1480,16 @@ export const withPropsUtils = {
     /**
      * Transform props based on conditions
      */
-    conditional: (condition, trueProps, falseProps = {}) => withProps((props, state, _context) => {
+    conditional: (condition, trueProps, falseProps = {}) => withProps((props, state, context) => {
         const shouldApply = typeof condition === 'function' ?
-            condition(props, state, _context) :
+            condition(props, state, context) :
             condition;
         return shouldApply ? trueProps : falseProps;
     }),
     /**
      * Map specific props to new names/values
      */
-    map: (mapping) => withProps((_props) => {
+    map: (mapping) => withProps((props) => {
         const result = {};
         Object.entries(mapping).forEach(([newKey, mapper]) => {
             if (typeof mapper === 'string') {
@@ -1498,7 +1498,7 @@ export const withPropsUtils = {
             }
             else if (typeof mapper === 'function') {
                 // Transform function
-                result[newKey] = mapper(_props);
+                result[newKey] = mapper(props);
             }
             else {
                 // Static value
@@ -1510,7 +1510,7 @@ export const withPropsUtils = {
     /**
      * Pick only specific props
      */
-    pick: (keys) => withProps((_props) => {
+    pick: (keys) => withProps((props) => {
         const result = {};
         keys.forEach(key => {
             if (props.hasOwnProperty(key)) {
@@ -1522,7 +1522,7 @@ export const withPropsUtils = {
     /**
      * Omit specific props
      */
-    omit: (keys) => withProps((_props) => {
+    omit: (keys) => withProps((props) => {
         const result = { ...props };
         keys.forEach(key => delete result[key]);
         return result;
@@ -1530,7 +1530,7 @@ export const withPropsUtils = {
     /**
      * Default values for missing props
      */
-    defaults: (defaultProps) => withProps((_props) => ({
+    defaults: (defaultProps) => withProps((props) => ({
         ...defaultProps,
         ...props
     }), { merge: false }),
@@ -1539,17 +1539,17 @@ export const withPropsUtils = {
      */
     validated: (transform, validator) => withProps(transform, {
         validate: validator,
-        onError: (error) => console.warn('Prop validation failed:', error)
+        onError: (_error) => console.warn('Prop validation failed:', _error)
     }),
     /**
      * Async prop transformation
      */
-    async: (asyncTransform, loadingProps = {}) => withProps(async (props, state, _context) => {
+    async: (asyncTransform, loadingProps = {}) => withProps(async (props, state, context) => {
         try {
-            return await asyncTransform(props, state, _context);
+            return await asyncTransform(props, state, context);
         }
-        catch (error) {
-            console.error('Async prop transform failed:', error);
+        catch (_error) {
+            console._error('Async prop transform failed:', _error);
             return loadingProps;
         }
     }, {
@@ -1558,11 +1558,11 @@ export const withPropsUtils = {
     /**
      * Computed props based on other props
      */
-    computed: (computedProps) => withProps((_props) => {
+    computed: (computedProps) => withProps((props) => {
         const computed = {};
         Object.entries(computedProps).forEach(([key, compute]) => {
             computed[key] = typeof compute === 'function' ?
-                compute(_props) :
+                compute(props) :
                 compute;
         });
         return computed;
@@ -1570,7 +1570,7 @@ export const withPropsUtils = {
     /**
      * Props with context injection
      */
-    withContext: (contextKeys) => withProps((props, state, _context) => {
+    withContext: (contextKeys) => withProps((props, state, context) => {
         const contextProps = {};
         contextKeys.forEach(key => {
             if (context && context[key] !== undefined) {
@@ -1584,7 +1584,7 @@ export const withPropsUtils = {
      */
     withState: (stateMapping) => withProps((props, state) => {
         if (typeof stateMapping === 'function') {
-            return stateMapping(state, _props);
+            return stateMapping(state, props);
         }
         const stateProps = {};
         Object.entries(stateMapping).forEach(([propKey, stateKey]) => {
@@ -1605,9 +1605,9 @@ export const withPropsUtils = {
     /**
      * Props with performance measurement
      */
-    timed: (transform, name = 'PropTransform') => withProps((props, state, _context) => {
+    timed: (transform, name = 'PropTransform') => withProps((props, state, context) => {
         const start = performance.now();
-        const result = transform(props, state, _context);
+        const result = transform(props, state, context);
         const end = performance.now();
         if (end - start > 1) { // Log if > 1ms
             console.log(`${name} took ${(end - start).toFixed(2)}ms`);
@@ -1617,13 +1617,13 @@ export const withPropsUtils = {
     /**
      * Chain multiple prop transformations
      */
-    chain: (...transforms) => withProps((props, state, _context) => {
+    chain: (...transforms) => withProps((props, state, context) => {
         return transforms.reduce((acc, transform) => {
             if (typeof transform === 'function') {
-                return { ...acc, ...transform(acc, state, _context) };
+                return { ...acc, ...transform(acc, state, context) };
             }
             return { ...acc, ...transform };
-        }, _props);
+        }, props);
     })
 };
 /**
@@ -1631,12 +1631,12 @@ export const withPropsUtils = {
  */
 export function createPropTransformer(config) {
     const { transforms = [], validators = [], defaults = {}, options = {} } = config;
-    return withProps((props, state, _context) => {
+    return withProps((props, state, context) => {
         let result = { ...defaults, ...props };
         // Apply transforms in sequence
         for (const transform of transforms) {
             if (typeof transform === 'function') {
-                result = { ...result, ...transform(result, state, _context) };
+                result = { ...result, ...transform(result, state, context) };
             }
             else {
                 result = { ...result, ...transform };
@@ -1656,12 +1656,12 @@ export function createPropTransformer(config) {
  */
 export function withPropsDebug(component, debugOptions = {}) {
     const { logProps = true, logChanges = true, breakOnError = false } = debugOptions;
-    return withProps((props, state, _context) => {
+    return withProps((props, state, context) => {
         if (logProps) {
             console.group(`Props Debug: ${component.name || 'Component'}`);
-            console.log('Props:', _props);
+            console.log('Props:', props);
             console.log('State:', state);
-            console.log('Context:', _context);
+            console.log('Context:', context);
             console.groupEnd();
         }
         return props;
@@ -1738,7 +1738,7 @@ export function withState(initialState = {}, options = {}) {
             if (!stateContainer.initialized) {
                 stateContainer.initialize();
                 if (onMount) {
-                    onMount(stateContainer.getState(), props, _context);
+                    onMount(stateContainer.getState(), props, context);
                 }
             }
             // Get current state
@@ -1746,7 +1746,7 @@ export function withState(initialState = {}, options = {}) {
             // Transform state if needed
             let transformedState = currentState;
             if (stateTransform) {
-                transformedState = stateTransform(currentState, props, _context);
+                transformedState = stateTransform(currentState, props, context);
             }
             // Create actions bound to this state container
             const boundActions = createBoundActions(actions, stateContainer, {
@@ -1818,7 +1818,7 @@ export function withState(initialState = {}, options = {}) {
             }
             // Render wrapped component
             return typeof WrappedComponent === 'function' ?
-                WrappedComponent(enhancedProps, globalState, _context) :
+                WrappedComponent(enhancedProps, globalState, context) :
                 WrappedComponent;
         }
         // Set display name
@@ -1861,9 +1861,9 @@ function createStateContainer(initialState, options) {
                         state = { ...state, ...parsed };
                     }
                 }
-                catch (error) {
+                catch (_error) {
                     if (debug)
-                        console.warn('Failed to load persisted state:', error);
+                        console.warn('Failed to load persisted state:', _error);
                 }
             }
             container.initialized = true;
@@ -1896,9 +1896,9 @@ function createStateContainer(initialState, options) {
                 try {
                     storage.setItem(storageKey, JSON.stringify(state));
                 }
-                catch (error) {
+                catch (_error) {
                     if (debug)
-                        console.warn('Failed to persist state:', error);
+                        console.warn('Failed to persist state:', _error);
                 }
             }
             // Notify listeners
@@ -1907,9 +1907,9 @@ function createStateContainer(initialState, options) {
                     try {
                         listener(state, prevState);
                     }
-                    catch (error) {
+                    catch (_error) {
                         if (debug)
-                            console.error('State listener error:', error);
+                            console._error('State listener _error:', _error);
                     }
                 });
                 if (onStateChange) {
@@ -1943,9 +1943,9 @@ function createStateContainer(initialState, options) {
                 try {
                     storage.removeItem(storageKey);
                 }
-                catch (error) {
+                catch (_error) {
                     if (debug)
-                        console.warn('Failed to remove persisted state:', error);
+                        console.warn('Failed to remove persisted state:', _error);
                 }
             }
         }
@@ -1964,18 +1964,18 @@ function createBoundActions(actions, stateContainer, options) {
                 const result = actionCreator(stateContainer.getState(), stateContainer.setState.bind(stateContainer), { props, context, args });
                 // Handle async actions
                 if (supportAsync && result && typeof result.then === 'function') {
-                    return result.catch(error => {
+                    return result.catch(_error => {
                         if (debug)
-                            console.error(`Async action ${actionName} failed:`, error);
-                        throw error;
+                            console._error(`Async action ${actionName} failed:`, _error);
+                        throw _error;
                     });
                 }
                 return result;
             }
-            catch (error) {
+            catch (_error) {
                 if (debug)
-                    console.error(`Action ${actionName} failed:`, error);
-                throw error;
+                    console._error(`Action ${actionName} failed:`, _error);
+                throw _error;
             }
         };
     });
@@ -2027,7 +2027,7 @@ export const withStateUtils = {
         }
         return (WrappedComponent) => {
             const sharedContainer = sharedStates.get(sharedKey);
-            function SharedStateComponent(props, globalState, _context) {
+            function SharedStateComponent(props, globalState, context) {
                 const currentState = sharedContainer.getState();
                 const enhancedProps = {
                     ...props,
@@ -2036,7 +2036,7 @@ export const withStateUtils = {
                     subscribe: sharedContainer.subscribe.bind(sharedContainer)
                 };
                 return typeof WrappedComponent === 'function' ?
-                    WrappedComponent(enhancedProps, globalState, _context) :
+                    WrappedComponent(enhancedProps, globalState, context) :
                     WrappedComponent;
             }
             SharedStateComponent.displayName = `withSharedState(${getComponentName(WrappedComponent)})`;
@@ -2065,7 +2065,7 @@ export const withStateUtils = {
         }
     }),
     /**
-     * State with loading/error handling
+     * State with loading/_error handling
      */
     withLoading: async (initialState) => withState({
         ...initialState,
@@ -2077,8 +2077,8 @@ export const withStateUtils = {
             setLoading: (state, setState, { args: [loading] }) => {
                 setState({ _loading: loading });
             },
-            setError: (state, setState, { args: [error] }) => {
-                setState({ _error: error, _loading: false });
+            setError: (state, setState, { args: [_error] }) => {
+                setState({ _error: _error, _loading: false });
             },
             clearError: (state, setState) => {
                 setState({ _error: null });
@@ -2090,9 +2090,9 @@ export const withStateUtils = {
                     setState({ _loading: false });
                     return result;
                 }
-                catch (error) {
-                    setState({ _loading: false, _error: error });
-                    throw error;
+                catch (_error) {
+                    setState({ _loading: false, _error: _error });
+                    throw _error;
                 }
             }
         }

package/dist/core/html-utils.js

@@ -44,9 +44,9 @@ export function isVoidElement(tagName) {
     ]);
     return voidElements.has(tagName.toLowerCase());
 }
-export function formatAttributes(_props) {
+export function formatAttributes(props) {
     let formatted = '';
-    for (const key in _props) {
+    for (const key in props) {
         if (props.hasOwnProperty(key)) {
             let value = props[key];
             // Convert className to class for HTML output
@@ -109,10 +109,10 @@ export function formatAttributes(_props) {
                     try {
                         value = value();
                     }
-                    catch (error) {
+                    catch (_error) {
                         console.warn(`Error executing function for attribute '${key}':`, {
-                            error: error.message,
-                            stack: error.stack,
+                            _error: _error.message,
+                            stack: _error.stack,
                             attributeKey: key,
                         });
                         // Consider different fallback strategies based on attribute type