Deep clone without JSON.parse

type Cloneable =
  | null
  | undefined
  | boolean
  | number
  | string
  | Date
  | RegExp
  | Map<Cloneable, Cloneable>
  | Set<Cloneable>
  | Cloneable[]
  | { [key: string]: Cloneable };

function deepCloneManual<T extends Cloneable>(
  source: T,
  visited: WeakMap<object, unknown> = new WeakMap()
): T {
  if (source === null || typeof source !== 'object') {
    return source;
  }

  if (visited.has(source as object)) {
    return visited.get(source as object) as T;
  }

  if (source instanceof Date) {
    return new Date(source.getTime()) as T;
  }

  if (source instanceof RegExp) {
    return new RegExp(source.source, source.flags) as T;
  }

  if (source instanceof Map) {
    const clonedMap = new Map();
    visited.set(source as object, clonedMap);
    source.forEach((value, key) => {
      clonedMap.set(
        deepCloneManual(key as Cloneable, visited),
        deepCloneManual(value as Cloneable, visited)
      );
    });
    return clonedMap as T;
  }

  if (source instanceof Set) {
    const clonedSet = new Set();
    visited.set(source as object, clonedSet);
    source.forEach((value) => {
      clonedSet.add(deepCloneManual(value as Cloneable, visited));
    });
    return clonedSet as T;
  }

  if (Array.isArray(source)) {
    const clonedArray: Cloneable[] = [];
    visited.set(source as object, clonedArray);
    for (const item of source) {
      clonedArray.push(deepCloneManual(item, visited));
    }
    return clonedArray as T;
  }

  const clonedObject: Record<string, Cloneable> = {};
  visited.set(source as object, clonedObject);

  for (const key of Object.keys(source)) {
    clonedObject[key] = deepCloneManual(
      (source as Record<string, Cloneable>)[key],
      visited
    );
  }

  return clonedObject as T;
}

function deepClone<T extends Cloneable>(source: T): T {
  if (typeof structuredClone === 'function') {
    try {
      return structuredClone(source);
    } catch {
      return deepCloneManual(source);
    }
  }
  return deepCloneManual(source);
}

const original = {
  name: 'Test',
  date: new Date('2024-01-15'),
  nested: { level: 1 },
  items: new Set([1, 2, 3]),
  metadata: new Map([['key', 'value']]),
  pattern: /test/gi,
};

const circularObj: Record<string, unknown> = { a: 1 };
circularObj.self = circularObj;

const cloned = deepClone(original);
const clonedCircular = deepClone(circularObj as Cloneable);

console.log('Original:', original);
console.log('Cloned:', cloned);
console.log('Are different objects:', original !== cloned);
console.log('Date cloned correctly:', cloned.date instanceof Date);
console.log('Set cloned correctly:', cloned.items instanceof Set);
console.log('Map cloned correctly:', cloned.metadata instanceof Map);
console.log('Circular handled:', (clonedCircular as Record<string, unknown>).self === clonedCircular);