Update js/adapter.js

js/adapter.js

@@ -1,228 +1,78 @@
-/**
- * ========================================
- * Adapter Interface - पुरुष लेयर: स्तर ४
- * नासदीय संदर्भ: (प्रकृति द्वार)
- * ========================================
- * कार्य: डोमेन मॉड्यूल्ससाठी मानक JSON स्कीमा
- * डेटा व्हेलिडेशन आणि रूपांतरण
- * ========================================
- */
-
 class Adapter {
     constructor() {
-        // मानक डेटा स्कीमा
         this.schema = {
             required: ['id', 'x', 'y', 'type'],
-            optional: ['label', 'layer', 'meta', 'color', 'radius'],
-            types: {
-                id: 'string',
-                x: 'number',
-                y: 'number',
-                type: 'string',
-                label: 'string',
-                layer: 'number',
-                meta: 'object',
-                color: 'string',
-                radius: 'number'
-            },
-            ranges: {
-                x: { min: 0, max: 100 },
-                y: { min: 0, max: 100 },
-                layer: { min: 0, max: 10 }
-            }
+            types: { id: 'string', x: 'number', y: 'number', type: 'string', label: 'string', layer: 'number' },
+            ranges: { x: { min: 0, max: 100 }, y: { min: 0, max: 100 } }
         };
-        
-        // व्हेलिडेशन फ्लॅग
+        this.scaleFactor = 0.1; // Dataset 0-1000 → Core 0-100
         this.strictMode = true;
     }
-    
-    /**
-     * डोमेन डेटा व्हेलिडेट करा
-     * @param {Object|Array} data - डोमेनकडून मिळालेला डेटा
-     * @returns {Object} { valid: boolean, errors: Array, sanitized: Array }
-     */
+
     validate(data) {
         const errors = [];
         const sanitized = [];
-        
-        // Array किंवा Object
         const items = Array.isArray(data) ? data : [data];
-                items.forEach((item, index) => {
+
+        items.forEach((item, index) => {
             const itemErrors = this._validateItem(item, index);
             errors.push(...itemErrors);
-            
-            // जर त्रुटी नसतील तर sanitized मध्ये ॲड करा
-            if (itemErrors.length === 0) {
-                sanitized.push(this._sanitize(item));
-            }
+            if (itemErrors.length === 0) sanitized.push(this._sanitize(item));
         });
-        
-        return {
-            valid: errors.length === 0,
-            errors,
-            sanitized,
-            total: items.length,
-            validCount: sanitized.length
-        };
+
+        return { valid: errors.length === 0, errors, sanitized, total: items.length, validCount: sanitized.length };
     }
-    
-    /**
-     * एकक डेटा व्हेलिडेट करा
-     * @param {Object} item 
-     * @param {number} index 
-     * @returns {Array} errors
-     * @private
-     */
+
     _validateItem(item, index) {
         const errors = [];
-        
-        // प्रकार तपासा
         if (typeof item !== 'object' || item === null) {
             errors.push(`[${index}] डेटा ऑब्जेक्ट असणे आवश्यक आहे`);
             return errors;
         }
-        
-        // आवश्यक फील्ड्स तपासा
         this.schema.required.forEach(field => {
-            if (!(field in item)) {
-                errors.push(`[${index}] आवश्यक फील्ड '${field}' गहाळ`);
-            }
+            if (!(field in item)) errors.push(`[${index}] आवश्यक फील्ड '${field}' गहाळ`);
         });
-        
-        // डेटा प्रकार तपासा
         Object.keys(item).forEach(key => {
-            if (this.schema.types[key]) {
-                const expectedType = this.schema.types[key];
-                const actualType = typeof item[key];
-                
-                if (actualType !== expectedType) {
-                    errors.push(                        `[${index}] '${key}' चा प्रकार '${expectedType}' अपेक्षित, '${actualType}' मिळाला`
-                    );
-                }
-            }
-        });
-        
-        // रेंज तपासा
-        Object.keys(this.schema.ranges).forEach(field => {
-            if (field in item) {
-                const range = this.schema.ranges[field];
-                if (item[field] < range.min || item[field] > range.max) {
-                    errors.push(
-                        `[${index}] '${field}' ${range.min}-${range.max} दरम्यान असणे आवश्यक आहे`
-                    );
-                }
+            if (this.schema.types[key] && typeof item[key] !== this.schema.types[key]) {
+                errors.push(`[${index}] '${key}' चा प्रकार '${this.schema.types[key]}' अपेक्षित`);
             }
         });
-        
         return errors;
     }
-    
-    /**
-     * डेटा स्वच्छ करा (सॅनिटाइझ)
-     * @param {Object} item 
-     * @returns {Object}
-     * @private
-     */
+
     _sanitize(item) {
-        const sanitized = {};
-        
-        // सर्व फील्ड्स कॉपी करा
-        Object.keys(item).forEach(key => {
-            if (this.schema.required.includes(key) || this.schema.optional.includes(key)) {
-                sanitized[key] = item[key];
-            }
-        });
-        
-        // डिफॉल्ट मूल्ये सेट करा
-        if (!sanitized.label) sanitized.label = null;
-        if (!sanitized.layer) sanitized.layer = 0;
-        if (!sanitized.meta) sanitized.meta = {};
-        if (!sanitized.color) sanitized.color = '#4a9eff';
-        if (!sanitized.radius) sanitized.radius = 5;
-        
-        return sanitized;
+        // Coordinate Normalization: 0-1000 → 0-100
+        const normalizedX = Number(item.x) * this.scaleFactor;
+        const normalizedY = Number(item.y) * this.scaleFactor;
+
+        return {
+            id: String(item.id || `auto_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`),
+            x: Math.max(0, Math.min(100, normalizedX)),
+            y: Math.max(0, Math.min(100, normalizedY)),
+            type: String(item.type || 'node'),
+            label: item.label ? String(item.label) : null,
+            layer: Number(item.layer || 0),
+            meta: { original: item, domain: 'vedic', timestamp: Date.now() },
+            color: item.color || '#4a9eff',
+            radius: item.radius || 5
+        };
     }
-    
-    /**
-     * डेटासेटचे रूपांतरण करा (Parquet → Standard Format)
-     * @param {Array} dataset - डेटासेटमधील raw डेटा     * @param {Object} mapping - फील्ड मॅपिंग
-     * @returns {Array}
-     */
+
     transform(dataset, mapping = {}) {
-        const defaultMapping = {
-            x: 'x',
-            y: 'y',
-            id: 'id',
-            type: 'type',
-            label: 'label'
-        };
-        
-        const fieldMap = { ...defaultMapping, ...mapping };
-        
+        const fieldMap = { x: 'x', y: 'y', id: 'id', type: 'type', label: 'label', ...mapping };
         return dataset.map(item => ({
-            id: String(item[fieldMap.id] || `auto_${Date.now()}_${Math.random()}`),
+            id: String(item[fieldMap.id]),
             x: Number(item[fieldMap.x]),
             y: Number(item[fieldMap.y]),
-            type: String(item[fieldMap.type] || 'node'),
+            type: String(item[fieldMap.type]),
             label: item[fieldMap.label] ? String(item[fieldMap.label]) : null,
-            meta: {
-                original: item,
-                domain: item.domain || 'vedic',
-                timestamp: Date.now()
-            }
+            layer: Number(item[fieldMap.layer] || 0),
+            meta: { original: item, domain: 'vedic', timestamp: Date.now() }
         }));
     }
-    
-    /**
-     * डोमेन-स्पेसिफिक ॲडाप्टर नोंदणी करा
-     * @param {string} domain - डोमेन नाव (उदा. 'jyotish', 'quantum', 'vastu')
-     * @param {Object} adapter - कस्टम ॲडाप्टर
-     */
-    registerDomainAdapter(domain, adapter) {
-        if (!this.domainAdapters) {
-            this.domainAdapters = {};
-        }
-        
-        this.domainAdapters[domain] = adapter;
-        console.log(`Domain adapter नोंदवला: ${domain}`);
-    }
-    
-    /**
-     * डोमेन ॲडाप्टर वापरा
-     * @param {string} domain 
-     * @param {any} data 
-     * @returns {Array}
-     */
-    adaptFromDomain(domain, data) {
-        if (this.domainAdapters && this.domainAdapters[domain]) {            return this.domainAdapters[domain].adapt(data);
-        }
-        
-        // डिफॉल्ट ॲडाप्टर
-        return this.transform(Array.isArray(data) ? data : [data]);
-    }
-    
-    /**
-     * Strict mode चालू/बंद करा
-     * @param {boolean} enabled 
-     */
-    setStrictMode(enabled) {
-        this.strictMode = enabled;
-        console.log(`Adapter strict mode: ${enabled ? 'चालू' : 'बंद'}`);
-    }
-    
-    /**
-     * स्कीमा मिळवा
-     * @returns {Object}
-     */
-    getSchema() {
-        return { ...this.schema };
-    }
-}
 
-// ग्लोबल इन्स्टन्स
-window.VedicAdapter = new Adapter();
+    setStrictMode(enabled) { this.strictMode = enabled; }
+    getSchema() { return { ...this.schema }; }
+}
 
-// एक्सपोर्ट
-if (typeof module !== 'undefined' && module.exports) {
-    module.exports = Adapter;
-}
+window.VedicAdapter = new Adapter();