WeakMap in Production — Preventing DOM Node Memory Leaks

const privateData = new WeakMap();

class Person {
    constructor(name, age) {
        // Store private data keyed by this instance
        privateData.set(this, { age, secretCode: Math.random() });
        this.name = name;  // public
    }

    getAge() {
        return privateData.get(this).age;  // private data not on the object
    }

    greet() {
        return `Hi, I'm ${this.name}, age ${this.getAge()}`;
    }
}

const alice = new Person('Alice', 30);
console.log(alice.greet());      // Hi, I'm Alice, age 30
console.log(alice.age);          // undefined — not a public property
console.log(alice.secretCode);   // undefined — truly private

// When alice goes out of scope and is GC'd, privateData entry is also collected

// Problem: regular Map prevents garbage collection of DOM nodes
const cache = new Map();

function processElement(el) {
    if (cache.has(el)) return cache.get(el);
    const result = expensiveComputation(el);
    cache.set(el, result);
    return result;
}
// If el is removed from the DOM, cache still holds a reference → memory leak

// Solution: WeakMap — entry removed when el is GC'd
const weakCache = new WeakMap();

function processElementSafe(el) {
    if (weakCache.has(el)) return weakCache.get(el);
    const result = { processed: true, timestamp: Date.now() };
    weakCache.set(el, result);
    return result;
}

// Keys must be objects — not primitives
const obj = {};
weakCache.set(obj, 'data');   // OK
// weakCache.set('string', 'data');  // TypeError: Invalid value used as weak map key

function expensiveComputation(el) { return { computed: true }; }

const visited = new WeakSet();

function processNode(node) {
    if (visited.has(node)) {
        console.log('Already processed, skipping');
        return;
    }
    visited.add(node);
    console.log('Processing node:', node.id);
    // process...
}

const nodeA = { id: 'a', data: 'hello' };
const nodeB = { id: 'b', data: 'world' };

processNode(nodeA);  // Processing node: a
processNode(nodeA);  // Already processed, skipping
processNode(nodeB);  // Processing node: b

// WeakSet only has: add(), has(), delete()
// No size, no iteration — by design (GC timing is unpredictable)