@coherent.js/core 1.0.0-beta.6 → 1.0.0-beta.7

package/dist/dev/dev-tools.js

@@ -107,9 +107,9 @@ export class DevTools {
                 this.postRenderAnalysis(component, result, renderTime, renderId);
                 return result;
             }
-            catch (_error) {
-                this.handleRenderError(_error, component, context, renderId);
-                throw _error;
+            catch (error) {
+                this.handleRenderError(error, component, context, renderId);
+                throw error;
             }
         };
     }
@@ -187,10 +187,10 @@ export class DevTools {
         try {
             validateComponent(component);
         }
-        catch (_error) {
+        catch (error) {
             return {
                 isValid: false,
-                message: `Invalid component at ${path}: ${_error.message}`
+                message: `Invalid component at ${path}: ${error.message}`
             };
         }
         // Recursive validation for objects and arrays
@@ -247,7 +247,7 @@ export class DevTools {
      */
     analyzeContext(context, renderId) {
         // Large context warning
-        const contextSize = JSON.stringify(context).length;
+        const contextSize = JSON.stringify(_context).length;
         if (contextSize > 10000) {
             this.warnings.push({
                 type: 'context',
@@ -258,10 +258,10 @@ export class DevTools {
         }
         // Circular reference check
         try {
-            JSON.stringify(context);
+            JSON.stringify(_context);
         }
-        catch (_error) {
-            if (_error.message.includes('circular')) {
+        catch (error) {
+            if (error.message.includes('circular')) {
                 this.warnings.push({
                     type: 'context',
                     message: 'Circular reference detected in context',
@@ -383,12 +383,12 @@ export class DevTools {
         return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
     }
     /**
-     * Setup _error handling
+     * Setup error handling
      */
     setupErrorHandling() {
-        // Global _error handler
-        const originalConsoleError = console._error;
-        console._error = (...args) => {
+        // Global error handler
+        const originalConsoleError = console.error;
+        console.error = (...args) => {
             // Log to dev tools
             this.errors.push({
                 type: 'console',
@@ -410,11 +410,11 @@ export class DevTools {
                 });
             });
         }
-        // Browser _error handler
+        // Browser error handler
         if (typeof window !== 'undefined') {
-            window.addEventListener('_error', (event) => {
+            window.addEventListener('error', (event) => {
                 this.errors.push({
-                    type: 'browser-_error',
+                    type: 'browser-error',
                     message: event.message,
                     filename: event.filename,
                     lineno: event.lineno,
@@ -427,18 +427,18 @@ export class DevTools {
     /**
      * Handle render errors specifically
      */
-    handleRenderError(_error, component, context, renderId) {
+    handleRenderError(error, component, context, renderId) {
         this.errors.push({
-            type: 'render-_error',
-            message: _error.message,
-            stack: _error.stack,
+            type: 'render-error',
+            message: error.message,
+            stack: error.stack,
             component: this.serializeComponent(component),
-            context: Object.keys(context),
+            context: Object.keys(_context),
             renderId,
             timestamp: Date.now()
         });
-        console._error(`🚨 Render Error in ${renderId}:`, _error.message);
-        console._error('Component:', this.serializeComponent(component));
+        console.error(`🚨 Render Error in ${renderId}:`, error.message);
+        console.error('Component:', this.serializeComponent(component));
     }
     /**
      * Setup hot reload capability
@@ -736,8 +736,8 @@ export class DevTools {
             }
             return component;
         }
-        catch (_error) {
-            return `[Serialization Error: ${_error.message}]`;
+        catch (error) {
+            return `[Serialization Error: ${error.message}]`;
         }
     }
     clearDevData() {
@@ -812,7 +812,7 @@ export const devUtils = {
             for (const tag of tags) {
                 const props = component[tag];
                 if (props && typeof props === 'object') {
-                    console.log(`${tag} props:`, Object.keys(props));
+                    console.log(`${tag} props:`, Object.keys(_props));
                 }
             }
         }
@@ -826,8 +826,8 @@ export const devUtils = {
             console.log('✅ Component is valid');
             return true;
         }
-        catch (_error) {
-            console._error('❌ Component validation failed:', _error.message);
+        catch (error) {
+            console.error('❌ Component validation failed:', error.message);
             return false;
         }
     },

package/dist/forms/validation.d.ts

@@ -0,0 +1,271 @@
+/**
+ * Create form validator
+ */
+export function createForm(schema: any, options?: {}): FormValidator;
+export namespace validationRules {
+    function required(value: any, params?: boolean): true | "This field is required";
+    function min(value: any, minValue: any): string | true;
+    function max(value: any, maxValue: any): string | true;
+    function minLength(value: any, minLen: any): string | true;
+    function maxLength(value: any, maxLen: any): string | true;
+    function pattern(value: any, regex: any, message?: string): any;
+    function email(value: any): true | "Please enter a valid email address";
+    function url(value: any): true | "Please enter a valid URL";
+    function numeric(value: any): true | "Must be a valid number";
+    function integer(value: any): true | "Must be a whole number";
+    function alpha(value: any): true | "Must contain only letters";
+    function alphanumeric(value: any): true | "Must contain only letters and numbers";
+    function equals(value: any, otherValue: any, fieldName?: string): string | true;
+    function oneOf(value: any, options: any, message?: string): any;
+    function custom(value: any, validator: any, ...args: any[]): any;
+}
+/**
+ * Form validation and binding system
+ */
+export class FormValidator {
+    constructor(schema?: {}, options?: {});
+    schema: {};
+    options: {
+        validateOnSubmit: boolean;
+        validateOnChange: boolean;
+        stopOnFirstError: boolean;
+    };
+    data: ReactiveState;
+    validators: Map<any, any>;
+    isSubmitting: import("../state/reactive-state.js").Observable;
+    submitCount: import("../state/reactive-state.js").Observable;
+    isValid: {
+        _getter: any;
+        _cached: boolean;
+        _dirty: boolean;
+        get value(): any;
+        set value(newValue: any);
+        _compute(): void;
+        _value: any;
+        _invalidate(): void;
+        _observers: Set<any>;
+        _computedDependents: Set<any>;
+        _options: {
+            deep: boolean;
+            immediate: boolean;
+        };
+        watch(callback: any, options?: {}): () => void;
+        unwatch(observer: any): void;
+        unwatchAll(): void;
+    };
+    isPending: {
+        _getter: any;
+        _cached: boolean;
+        _dirty: boolean;
+        get value(): any;
+        set value(newValue: any);
+        _compute(): void;
+        _value: any;
+        _invalidate(): void;
+        _observers: Set<any>;
+        _computedDependents: Set<any>;
+        _options: {
+            deep: boolean;
+            immediate: boolean;
+        };
+        watch(callback: any, options?: {}): () => void;
+        unwatch(observer: any): void;
+        unwatchAll(): void;
+    };
+    isTouched: {
+        _getter: any;
+        _cached: boolean;
+        _dirty: boolean;
+        get value(): any;
+        set value(newValue: any);
+        _compute(): void;
+        _value: any;
+        _invalidate(): void;
+        _observers: Set<any>;
+        _computedDependents: Set<any>;
+        _options: {
+            deep: boolean;
+            immediate: boolean;
+        };
+        watch(callback: any, options?: {}): () => void;
+        unwatch(observer: any): void;
+        unwatchAll(): void;
+    };
+    isDirty: {
+        _getter: any;
+        _cached: boolean;
+        _dirty: boolean;
+        get value(): any;
+        set value(newValue: any);
+        _compute(): void;
+        _value: any;
+        _invalidate(): void;
+        _observers: Set<any>;
+        _computedDependents: Set<any>;
+        _options: {
+            deep: boolean;
+            immediate: boolean;
+        };
+        watch(callback: any, options?: {}): () => void;
+        unwatch(observer: any): void;
+        unwatchAll(): void;
+    };
+    errors: {
+        _getter: any;
+        _cached: boolean;
+        _dirty: boolean;
+        get value(): any;
+        set value(newValue: any);
+        _compute(): void;
+        _value: any;
+        _invalidate(): void;
+        _observers: Set<any>;
+        _computedDependents: Set<any>;
+        _options: {
+            deep: boolean;
+            immediate: boolean;
+        };
+        watch(callback: any, options?: {}): () => void;
+        unwatch(observer: any): void;
+        unwatchAll(): void;
+    };
+    /**
+     * Initialize field validators from schema
+     */
+    initializeValidators(): void;
+    /**
+     * Set field value
+     */
+    setField(name: any, value: any): void;
+    /**
+     * Get field value
+     */
+    getField(name: any): any;
+    /**
+     * Set multiple fields
+     */
+    setFields(fields: any): void;
+    /**
+     * Get all form data
+     */
+    getData(): {};
+    /**
+     * Validate specific field
+     */
+    validateField(name: any): Promise<any>;
+    /**
+     * Validate all fields
+     */
+    validateAll(): Promise<boolean>;
+    /**
+     * Handle field blur event
+     */
+    handleBlur(name: any): void;
+    /**
+     * Handle form submission
+     */
+    handleSubmit(submitHandler: any): Promise<boolean>;
+    /**
+     * Reset form to initial state
+     */
+    reset(): void;
+    /**
+     * Add custom validator
+     */
+    addValidator(name: any, rules: any, options?: {}): void;
+    /**
+     * Remove validator
+     */
+    removeValidator(name: any): void;
+    /**
+     * Get field validator
+     */
+    getValidator(name: any): any;
+    /**
+     * Get form state summary
+     */
+    getState(): {
+        isValid: any;
+        isPending: any;
+        isTouched: any;
+        isDirty: any;
+        isSubmitting: any;
+        submitCount: any;
+        errors: any;
+        data: {};
+    };
+    /**
+     * Watch form state changes
+     */
+    watch(callback: any, options?: {}): () => void;
+    /**
+     * Cleanup form
+     */
+    destroy(): void;
+}
+export namespace binding {
+    /**
+     * Two-way data binding for input elements
+     */
+    function model(form: any, fieldName: any, options?: {}): {
+        value: any;
+        oninput: (event: any) => void;
+        onblur: () => void;
+    };
+    /**
+     * Checkbox binding
+     */
+    function checkbox(form: any, fieldName: any): {
+        checked: boolean;
+        onchange: (event: any) => void;
+        onblur: () => void;
+    };
+    /**
+     * Select dropdown binding
+     */
+    function select(form: any, fieldName: any, options?: {}): {
+        value: any;
+        onchange: (event: any) => void;
+        onblur: () => void;
+    };
+    /**
+     * Radio button binding
+     */
+    function radio(form: any, fieldName: any, value: any): {
+        checked: boolean;
+        value: any;
+        onchange: (event: any) => void;
+    };
+}
+export namespace formComponents {
+    /**
+     * Validation error display
+     */
+    function ValidationError({ form, field, className }: {
+        form: any;
+        field: any;
+        className?: string | undefined;
+    }): {
+        div: {
+            className: string;
+            children: any;
+        };
+    } | null;
+    /**
+     * Form field wrapper with validation
+     */
+    function FormField({ form, field, label, children, showErrors }: {
+        form: any;
+        field: any;
+        label: any;
+        children: any;
+        showErrors?: boolean | undefined;
+    }): {
+        div: {
+            className: string;
+            children: any[];
+        };
+    };
+}
+import { ReactiveState } from '../state/reactive-state.js';
+//# sourceMappingURL=validation.d.ts.map

package/dist/forms/validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../../../src/forms/validation.js"],"names":[],"mappings":"AAygBA;;GAEG;AACH,qEAEC;;IAlgBa,iFAKT;IAEI,uDAIJ;IAEI,uDAIJ;IAEU,2DAIV;IAEU,2DAIV;IAEQ,gEAIR;IAEM,wEAIN;IAEI,4DAQJ;IAEQ,8DAGR;IAEQ,8DAIR;IAEM,+DAGN;IAEa,kFAGb;IAEO,gFAEP;IAEM,gEAGN;IAEO,iEAKP;;AAqIL;;GAEG;AACH;IACI,uCA2CC;IA1CG,WAAoB;IACpB;;;;MAKC;IAED,oBAA+B;IAC/B,0BAA2B;IAC3B,8DAAqC;IACrC,6DAAgC;IAMhC;;;;;;;;;;;;;;;;;;MAEE;IAEF;;;;;;;;;;;;;;;;;;MAEE;IAEF;;;;;;;;;;;;;;;;;;MAEE;IAEF;;;;;;;;;;;;;;;;;;MAEE;IAEF;;;;;;;;;;;;;;;;;;MAQE;IAGN;;OAEG;IACH,6BAsBC;IAED;;OAEG;IACH,sCAOC;IAED;;OAEG;IACH,yBAEC;IAED;;OAEG;IACH,6BAEC;IAED;;OAEG;IACH,cAEC;IAED;;OAEG;IACH,uCASC;IAED;;OAEG;IACH,gCAUC;IAED;;OAEG;IACH,4BAUC;IAED;;OAEG;IACH,mDAyCC;IAED;;OAEG;IACH,cAYC;IAED;;OAEG;IACH,wDAKC;IAED;;OAEG;IACH,iCAEC;IAED;;OAEG;IACH,6BAEC;IAED;;OAEG;IACH;;;;;;;;;MAWC;IAED;;OAEG;IACH,+CAkBC;IAED;;OAEG;IACH,gBAGC;CACJ;;IAaG;;OAEG;IACH;;;;MAWC;IAED;;OAEG;IACH;;;;MAUC;IAED;;OAEG;IACH;;;;MAaC;IAED;;OAEG;IACH;;;;MAUC;;;IAOD;;OAEG;IACH;;;;;;;;;aAcC;IAED;;OAEG;IACH;;;;;;;;;;;MAeC;;8BAznB+C,4BAA4B"}