Add self.structuredClone()

[lucacasonato]

Spec: whatwg/html@1b5099f

[jeremyBanks]

Should we consider giving this a somewhat-precise type signature, instead of returning any?

I'm not sure whether this would be appropriate or not, but here's a take on a function signature that preserves most type information for supported types, while stripping out methods for custom types.

It might not be perfect, but we should be able to get something close enough that the type information comes in handy much more often than it gets in the way (by forcing a cast).

export const clone = <Value>(value: Value) =>
  deserialize(serialize(value)) as Cloned<Value>;

const serialize = (value: unknown) =>
  // deno-lint-ignore no-explicit-any
  (Deno as any).core.serialize(value) as Uint8Array;

const deserialize = (bytes: Uint8Array) =>
  // deno-lint-ignore no-explicit-any
  (Deno as any).core.deserialize(bytes) as unknown;

// deno-fmt-ignore
type Cloned<Value>
  // preserve supported value types as-is
  = Value extends CloneablePrimitives | CloneableValues
    ? Value
  : RW<Value> extends CloneablePrimitives | CloneableValues
    ? Value
  // deno-lint-ignore ban-types
  : Value extends Function
    ? never
  // recur over parameters of supported collection types
  : RW<Value> extends Map<infer K, infer V>
    ? Map<Cloned<K>, Cloned<V>>
  : RW<Value> extends Set<infer V>
    ? Set<Cloned<V>>
  : RW<Value> extends Array<unknown> | Record<string, unknown>
    ? { [Key in keyof Value]: Cloned<Value[Key]> }
  : never;

type Cloneable =
  | CloneablePrimitives
  | CloneableCollections
  | CloneableValues;

type CloneablePrimitives =
  | bigint
  | boolean
  | null
  | number
  | string
  | undefined;

type CloneableCollections =
  | Set<Cloneable>
  | Map<Cloneable, Cloneable>
  | Array<Cloneable>
  | { [key: string]: Cloneable };

type CloneableValues =
  | ArrayBuffer
  | ArrayBufferView
  | BigInt
  | Blob
  // deno-lint-ignore ban-types
  | Boolean
  | Date
  | Error
  | EvalError
  // deno-lint-ignore ban-types
  | Number
  | RangeError
  | ReferenceError
  | RegExp
  // deno-lint-ignore ban-types
  | String
  | SyntaxError
  | TypeError
  | URIError;

/**
 * Removes readonly modifiers within a type (making it [r]ead[w]rite).
 *
 * We use this to help match against types while ignoring readonly modifiers.
 */
type RW<T> = {
  -readonly [P in keyof T]: RW<T[P]>;
};