deepClone()

class User {
  constructor(name, email) {
    this.name = name;
    this.email = email;
    this.createdAt = new Date();
  }

  getDisplayName() {
    return `${this.name} <${this.email}>`;
  }
}

const originalUser = new User("John Doe", "john@example.com");
originalUser.preferences = { theme: "dark", lang: "en" };

const clonedUser = deepClone(originalUser);

// Properties are cloned
console.log(clonedUser.name); // "John Doe"
console.log(clonedUser.preferences.theme); // "dark"
console.log(clonedUser.createdAt instanceof Date); // true

// Note: Methods are not preserved in cloned objects
console.log(typeof clonedUser.getDisplayName); // "undefined"
console.log(clonedUser instanceof User); // false

// For class instances, consider custom cloning:
class UserWithClone extends User {
  clone() {
    const cloned = new UserWithClone(this.name, this.email);
    cloned.createdAt = new Date(this.createdAt);
    cloned.preferences = deepClone(this.preferences);
    return cloned;
  }
}

const objectWithFunctions = {
  data: { count: 0 },
  increment: function() { this.data.count++; },
  decrement: () => { this.data.count--; },
  computed: {
    get doubled() { return this.data.count * 2; }
  }
};

const cloned = deepClone(objectWithFunctions);

// Functions are preserved as-is (not cloned)
console.log(typeof cloned.increment); // "function"
console.log(cloned.increment === objectWithFunctions.increment); // true

// Data is properly cloned
cloned.data.count = 5;
console.log(objectWithFunctions.data.count); // 0 (unchanged)
console.log(cloned.data.count); // 5

// For objects with methods, consider a factory pattern:
function createCounter(initialValue = 0) {
  const state = { count: initialValue };
  
  return {
    data: deepClone(state),
    increment() { this.data.count++; },
    decrement() { this.data.count--; },
    clone() { return createCounter(this.data.count); }
  };
}

// Custom objects with special properties
const customObject = {
  buffer: new ArrayBuffer(16),
  view: new DataView(new ArrayBuffer(16)),
  typedArray: new Uint8Array([1, 2, 3, 4]),
  error: new Error("Custom error"),
  promise: Promise.resolve("value"),
  symbol: Symbol("unique"),
  weakMap: new WeakMap(),
  weakSet: new WeakSet()
};

const cloned = deepClone(customObject);

// ArrayBuffer and TypedArrays are cloned
console.log(cloned.buffer instanceof ArrayBuffer); // true
console.log(cloned.buffer === customObject.buffer); // false
console.log(cloned.typedArray instanceof Uint8Array); // true
console.log(Array.from(cloned.typedArray)); // [1, 2, 3, 4]

// Error objects are cloned
console.log(cloned.error instanceof Error); // true
console.log(cloned.error.message); // "Custom error"
console.log(cloned.error === customObject.error); // false

// Symbols are preserved
console.log(cloned.symbol === customObject.symbol); // true

// WeakMap and WeakSet are cloned as empty
console.log(cloned.weakMap instanceof WeakMap); // true
console.log(cloned.weakSet instanceof WeakSet); // true

// ❌ Avoid: Cloning very large objects repeatedly
const largeObject = {
  data: new Array(1000000).fill(0).map((_, i) => ({ id: i, value: Math.random() }))
};

// This creates a new 1M element array each time
function processData(obj) {
  const cloned = deepClone(obj); // Memory intensive!
  // ... process cloned data
  return cloned;
}

// ✅ Better: Clone only what you need
function processDataEfficiently(obj) {
  const workingCopy = {
    ...obj,
    data: obj.data.slice(0, 100) // Only clone subset
  };
  // ... process working copy
  return workingCopy;
}

// ✅ Or use shallow clone for simple modifications
function processDataShallow(obj) {
  const shallowCopy = { ...obj };
  shallowCopy.metadata = { ...obj.metadata }; // Clone only nested objects that change
  return shallowCopy;
}

class Vehicle {
  constructor(type) {
    this.type = type;
  }
  
  start() {
    return `${this.type} started`;
  }
}

class Car extends Vehicle {
  constructor(brand, model) {
    super("car");
    this.brand = brand;
    this.model = model;
  }
  
  getInfo() {
    return `${this.brand} ${this.model}`;
  }
}

const myCar = new Car("Toyota", "Camry");
const clonedCar = deepClone(myCar);

// ❌ Prototype methods are lost
console.log(typeof clonedCar.start); // "undefined"
console.log(typeof clonedCar.getInfo); // "undefined"
console.log(clonedCar instanceof Car); // false

// ✅ Solution: Custom clone method or factory
class CarWithClone extends Car {
  clone() {
    const cloned = new CarWithClone(this.brand, this.model);
    // Copy any additional properties
    Object.keys(this).forEach(key => {
      if (key !== 'brand' && key !== 'model' && key !== 'type') {
        cloned[key] = deepClone(this[key]);
      }
    });
    return cloned;
  }
}

// ✅ Good use cases:
// 1. Immutable data operations
function updateUserPreferences(user, newPrefs) {
  const updatedUser = deepClone(user);
  updatedUser.preferences = { ...updatedUser.preferences, ...newPrefs };
  return updatedUser;
}

// 2. State management
class StateManager {
  constructor(initialState) {
    this.state = deepClone(initialState);
    this.history = [deepClone(initialState)];
  }
  
  setState(newState) {
    this.state = deepClone(newState);
    this.history.push(deepClone(newState));
  }
  
  undo() {
    if (this.history.length > 1) {
      this.history.pop();
      this.state = deepClone(this.history[this.history.length - 1]);
    }
  }
}

// 3. API response caching
class ApiCache {
  constructor() {
    this.cache = new Map();
  }
  
  set(key, data) {
    this.cache.set(key, deepClone(data)); // Prevent external mutations
  }
  
  get(key) {
    const cached = this.cache.get(key);
    return cached ? deepClone(cached) : null; // Return safe copy
  }
}

// ❌ Avoid deep cloning for:
// - Simple primitive values
// - Objects that don't need mutation protection
// - Performance-critical code paths
// - Objects with complex prototype chains

// ✅ Optimize cloning performance
class OptimizedCloner {
  constructor() {
    this.cache = new WeakMap();
  }
  
  // Selective cloning based on object type
  smartClone(obj) {
    if (obj === null || typeof obj !== 'object') {
      return obj;
    }
    
    // Check cache first
    if (this.cache.has(obj)) {
      return this.cache.get(obj);
    }
    
    // Handle different object types efficiently
    if (Array.isArray(obj)) {
      return this.cloneArray(obj);
    }
    
    if (obj instanceof Date) {
      return new Date(obj);
    }
    
    if (obj instanceof RegExp) {
      return new RegExp(obj);
    }
    
    // For plain objects, use deepClone
    return deepClone(obj);
  }
  
  cloneArray(arr) {
    // For arrays with primitives, use slice
    if (arr.every(item => typeof item !== 'object' || item === null)) {
      return arr.slice();
    }
    
    // For complex arrays, use deepClone
    return deepClone(arr);
  }
  
  // Batch cloning with shared cache
  cloneBatch(objects) {
    return objects.map(obj => this.smartClone(obj));
  }
}

// Usage
const cloner = new OptimizedCloner();
const cloned = cloner.smartClone(complexObject);

const testObject = {
  date: new Date(),
  regex: /test/g,
  func: () => "hello",
  undefined: undefined,
  symbol: Symbol("test"),
  circular: null
};
testObject.circular = testObject;

// JSON method limitations
try {
  const jsonCloned = JSON.parse(JSON.stringify(testObject));
  console.log(jsonCloned.date instanceof Date); // false (becomes string)
  console.log(jsonCloned.regex instanceof RegExp); // false (becomes {})
  console.log(typeof jsonCloned.func); // "undefined" (lost)
  console.log('undefined' in jsonCloned); // false (lost)
  console.log('symbol' in jsonCloned); // false (lost)
  // Circular reference would throw error
} catch (error) {
  console.log("JSON method failed:", error.message);
}

// deepClone handles all cases
const deepCloned = deepClone(testObject);
console.log(deepCloned.date instanceof Date); // true
console.log(deepCloned.regex instanceof RegExp); // true
console.log(typeof deepCloned.func); // "function"
console.log(deepCloned.circular === deepCloned); // true (circular preserved)

// Performance comparison
const largeObject = { data: new Array(10000).fill({ value: Math.random() }) };

console.time('JSON method');
for (let i = 0; i < 1000; i++) {
  JSON.parse(JSON.stringify(largeObject));
}
console.timeEnd('JSON method');

console.time('deepClone');
for (let i = 0; i < 1000; i++) {
  deepClone(largeObject);
}
console.timeEnd('deepClone');

// Comparison with popular libraries
const _ = require('lodash'); // If available

const complexObject = {
  map: new Map([['key', { nested: 'value' }]]),
  set: new Set([{ item: 1 }, { item: 2 }]),
  buffer: new ArrayBuffer(8),
  date: new Date(),
  circular: null
};
complexObject.circular = complexObject;

// Lodash cloneDeep
const lodashCloned = _.cloneDeep(complexObject);
console.log(lodashCloned.map instanceof Map); // true
console.log(lodashCloned.set instanceof Set); // true
console.log(lodashCloned.circular === lodashCloned); // true

// Lopos deepClone
const loposCloned = deepClone(complexObject);
console.log(loposCloned.map instanceof Map); // true
console.log(loposCloned.set instanceof Set); // true
console.log(loposCloned.circular === loposCloned); // true

// Both handle most cases similarly, but deepClone:
// - Has no external dependencies
// - Smaller bundle size
// - Handles some edge cases differently

// Choose based on your needs:
// - Use deepClone for lightweight, dependency-free projects
// - Use Lodash if you're already using it for other utilities
// - Use JSON method for simple objects without special types