npm install --save @golden-ants/clone

yarn add @golden-ants/clone

Object.create({})), }, { /** For JavaScript objects created without a parent prototype.*/ if: and(isObject, createdBy(undefined)), handler: retryFor(() => Object.create(null)), }, //{ // /**We repeat the parent signature of the predicate in case // * none of the conditions are met to throw an exception. Another way is for the // * other objects to copy the value by reference. */ // if: isObject, // handler: (value) => { // /**This is the default behavior, if no condition is met, // * an exception will be thrown. */ // //throw new SwitcherNotFoundException(value) // no need to write this // // or // //return value // }, //}, ], }, ] export const deepClone = new Clone(switchers)">

const switchers: Switcher[] = [
  {
    if: not(isObject), // all primitive types
    handler: (val) => val, // copying by value
  },
  {
    if: isObject,
    then: [
      {
        // copying functions, but not constructor functions
        if: createdBy(Function), // (val) => val.constructor === Function
        handler: (val) => val, // copying by reference
      },
      {
        if: createdBy(Date), // (val) => val.constructor === Date
        handler: (val) => new Date(val as Date),
      },
      {
        if: instanceOf(Array), // (val) => val instanceof Array
        /** Copy the (value) to a new empty array by
         *  calling the cloning method with the same
         *  switcher scheme.*/
        handler: retryFor(() => Array.of()),
      },
      {
        /** For JavaScript objects created using standard methods.
         * We do not use "instanceOf(Object)" because we are not
         * sure that there will be no more instances of specific
         * classes in the input stream.
         */
        if: createdBy(Object),
        handler: retryFor(() => Object.create({})),
      },
      {
        /** For JavaScript objects created without a parent prototype.*/
        if: and(isObject, createdBy(undefined)),
        handler: retryFor(() => Object.create(null)),
      },
      //{
      //  /**We repeat the parent signature of the predicate in case
      //   * none of the conditions are met to throw an exception. Another way is for the
      //   * other objects to copy the value by reference. */
      //  if: isObject,
      //  handler: (value) => {
      //    /**This is the default behavior, if no condition is met,
      //     * an exception will be thrown. */
      //    //throw new SwitcherNotFoundException(value) // no need to write this
      //    // or
      //    //return value
      //  },
      //},
    ],
  },
]

export const deepClone = new Clone(switchers)

import { deepClone } from ...

// object (array) of any nesting level
const foo = {
  nil: null,
  indefinite: undefined,
  foo() { return 'bar' },
  array: [
    { date: new Date(), storage: Object.create(null) },
    { date: new Date(), storage: Object.create(null) },
    { date: new Date(), storage: Object.create(null) },
  ],
}
const copied = deepClone.it({}, foo);

{
  if: [Predicate: (value) => boolean],
  handler: [Handler: (value, clone) => unknown)
}

{
  if: [Predicate: (value) => boolean],
  then: [Switchers]
}

const clone = new Clone(...)

const target = {}
const source = { foo: "bar" }

const copied = clone.it(target, source)

copied === target // true
copied === source // false

{
  if: isObject,
  handler: (value, clone) => clone.it({}, value),
  // handler: retryFor(() => ({}))
}

function createdBy(constructor) {}

function instanceOf(type) {}

// also: isObject, isRecord, isNull, isUndefined, isNumber, isString, isBoolean, isSymbol

function and(...fs: Predicates): Predicate {}

function or(...fs: Predicates): Predicate {}

function not(predicate: Predicate): Predicate {}

function xor(first: Predicate, second: Predicate): Predicate {}

function retryFor(producer: () => object): Handler {}