JavaScript Avancé
ES6+ Mastery

class User {
    // Propriétés privées
    #privateKey = 'secret';
    
    constructor(name, email) {
        this.name = name;
        this.email = email;
    }
    
    // Méthode getter
    get displayName() {
        return `User: ${this.name}`;
    }
    
    // Méthode setter
    set email(value) {
        if (value.includes('@')) {
            this._email = value;
        }
    }
    
    // Méthode statique
    static isValid(user) {
        return user.name && user.email;
    }
    
    // Méthode privée
    #validateKey() {
        return this.#privateKey === 'secret';
    }
}

// Héritage
class Admin extends User {
    constructor(name, email, permissions) {
        super(name, email);
        this.permissions = permissions;
    }
    
    hasPermission(action) {
        return this.permissions.includes(action);
    }
}

// Array methods
const users = [
    { name: 'Alice', age: 25, active: true },
    { name: 'Bob', age: 30, active: false },
    { name: 'Carol', age: 35, active: true }
];

// find/findIndex
const activeUser = users.find(u => u.active);
const index = users.findIndex(u => u.name === 'Bob');

// includes
const hasAlice = users.some(u => u.name === 'Alice');

// Object methods
const entries = Object.entries(users[0]);
const keys = Object.keys(users[0]);
const values = Object.values(users[0]);

// Object.assign
const merged = Object.assign({}, defaults, options);

// Optional chaining (ES2020)
const userName = user?.profile?.name ?? 'Anonymous';

// Nullish coalescing
const theme = settings.theme ?? 'default';

class DataManager {
    constructor() {
        this.cache = new Map();
        this.loading = new Set();
        this.subscribers = new Map();
    }
    
    async getData(key, fetcher, ttl = 300000) {
        // Si en cours de chargement, attendre
        if (this.loading.has(key)) {
            return this.waitForData(key);
        }
        
        // Vérifier le cache
        const cached = this.cache.get(key);
        if (cached && Date.now() - cached.timestamp < ttl) {
            return cached.data;
        }
        
        // Charger les données
        this.loading.add(key);
        
        try {
            const data = await fetcher();
            this.cache.set(key, {
                data,
                timestamp: Date.now()
            });
            
            this.notifySubscribers(key, data);
            return data;
        } finally {
            this.loading.delete(key);
        }
    }
    
    subscribe(key, callback) {
        if (!this.subscribers.has(key)) {
            this.subscribers.set(key, new Set());
        }
        this.subscribers.get(key).add(callback);
        
        return () => {
            const subs = this.subscribers.get(key);
            if (subs) {
                subs.delete(callback);
            }
        };
    }
    
    notifySubscribers(key, data) {
        const subscribers = this.subscribers.get(key);
        if (subscribers) {
            subscribers.forEach(callback => callback(data));
        }
    }
    
    invalidateCache(pattern) {
        if (typeof pattern === 'string') {
            this.cache.delete(pattern);
        } else if (pattern instanceof RegExp) {
            for (const [key] of this.cache) {
                if (pattern.test(key)) {
                    this.cache.delete(key);
                }
            }
        }
    }
}

class RealtimeManager {
    constructor(url) {
        this.url = url;
        this.ws = null;
        this.listeners = new Map();
        this.reconnectAttempts = 0;
        this.maxReconnectAttempts = 5;
    }
    
    connect() {
        this.ws = new WebSocket(this.url);
        
        this.ws.onopen = () => {
            console.log('WebSocket connected');
            this.reconnectAttempts = 0;
        };
        
        this.ws.onmessage = (event) => {
            try {
                const data = JSON.parse(event.data);
                this.handleMessage(data);
            } catch (error) {
                console.error('Invalid message format:', error);
            }
        };
        
        this.ws.onclose = () => {
            console.log('WebSocket disconnected');
            this.attemptReconnect();
        };
        
        this.ws.onerror = (error) => {
            console.error('WebSocket error:', error);
        };
    }
    
    subscribe(event, callback) {
        if (!this.listeners.has(event)) {
            this.listeners.set(event, new Set());
        }
        this.listeners.get(event).add(callback);
        
        return () => {
            const eventListeners = this.listeners.get(event);
            if (eventListeners) {
                eventListeners.delete(callback);
            }
        };
    }
    
    emit(event, data) {
        if (this.ws && this.ws.readyState === WebSocket.OPEN) {
            this.ws.send(JSON.stringify({ event, data }));
        }
    }
    
    handleMessage({ event, data }) {
        const listeners = this.listeners.get(event);
        if (listeners) {
            listeners.forEach(callback => callback(data));
        }
    }
    
    attemptReconnect() {
        if (this.reconnectAttempts < this.maxReconnectAttempts) {
            this.reconnectAttempts++;
            const delay = Math.pow(2, this.reconnectAttempts) * 1000;
            
            setTimeout(() => {
                console.log(`Reconnecting... (${this.reconnectAttempts}/${this.maxReconnectAttempts})`);
                this.connect();
            }, delay);
        }
    }
    
    disconnect() {
        if (this.ws) {
            this.ws.close();
        }
    }
}

// Curry & Partial Application
const curry = (fn) => {
    return function curried(...args) {
        if (args.length >= fn.length) {
            return fn.apply(this, args);
        }
        
        return function(...nextArgs) {
            return curried.apply(this, [...args, ...nextArgs]);
        };
    };
};

const add = curry((a, b, c) => a + b + c);
const addTen = add(10);
const addTenAndFive = addTen(5);
console.log(addTenAndFive(3)); // 18

// Composition de fonctions
const compose = (...fns) => (value) => 
    fns.reduceRight((acc, fn) => fn(acc), value);

const pipe = (...fns) => (value) => 
    fns.reduce((acc, fn) => fn(acc), value);

// Example d'utilisation
const users = [
    { name: 'Alice', age: 25, active: true },
    { name: 'Bob', age: 30, active: false },
    { name: 'Carol', age: 35, active: true }
];

const processUsers = pipe(
    users => users.filter(user => user.active),
    users => users.map(user => ({ ...user, ageGroup: user.age < 30 ? 'young' : 'adult' })),
    users => users.sort((a, b) => a.name.localeCompare(b.name))
);

const result = processUsers(users);

// Immutable updates
const updateUser = (user, updates) => ({
    ...user,
    ...updates,
    updatedAt: new Date()
});

// Lens pattern pour deep updates
const lens = (path) => {
    const getter = (obj) => path.reduce((current, key) => current?.[key], obj);
    const setter = (obj, value) => {
        const clone = structuredClone(obj);
        let current = clone;
        
        for (let i = 0; i < path.length - 1; i++) {
            current = current[path[i]];
        }
        
        current[path[path.length - 1]] = value;
        return clone;
    };
    
    return { get: getter, set: setter };
};

// Validation avec Proxy
function createValidatedObject(schema) {
    return new Proxy({}, {
        set(target, property, value) {
            const validator = schema[property];
            
            if (validator && !validator(value)) {
                throw new Error(`Invalid value for ${property}: ${value}`);
            }
            
            return Reflect.set(target, property, value);
        },
        
        get(target, property) {
            if (property in target) {
                return Reflect.get(target, property);
            }
            
            throw new Error(`Property ${property} does not exist`);
        }
    });
}

// Utilisation
const userSchema = {
    name: value => typeof value === 'string' && value.length > 0,
    age: value => typeof value === 'number' && value >= 0,
    email: value => typeof value === 'string' && value.includes('@')
};

const user = createValidatedObject(userSchema);

// Observable avec Proxy
function createObservable(target, onChange) {
    return new Proxy(target, {
        set(obj, property, value) {
            const oldValue = obj[property];
            const result = Reflect.set(obj, property, value);
            
            if (oldValue !== value) {
                onChange(property, value, oldValue);
            }
            
            return result;
        }
    });
}

const state = createObservable({}, (property, newValue, oldValue) => {
    console.log(`${property} changed from ${oldValue} to ${newValue}`);
});

// API fluide avec Proxy
function createFluentAPI() {
    const operations = [];
    
    return new Proxy({}, {
        get(target, property) {
            if (property === 'execute') {
                return () => operations.reduce((result, op) => op(result), null);
            }
            
            return (...args) => {
                operations.push(data => ({
                    ...data,
                    [property]: args.length === 1 ? args[0] : args
                }));
                return target;
            };
        }
    });
}

// Utilisation
const query = createFluentAPI();
const result = query
    .select('name', 'email')
    .where('age', '>', 18)
    .limit(10)
    .execute();