.clone() dummy implementation

export const globals = {};

declare global {
  interface Array<T> {
    clone<T>(this: T[], options?: CloneOptions<T>, ...args: any): T[];
  }
}

interface TransformerParams<T> {
  item: T;
  index: number;
  array: T[];
  original: T[];
  args: any[];
}

interface CloneOptions<T> {
  transformer: (params: TransformerParams<T>) => boolean;
}

Array.prototype.clone = function <T>(
  this: T[],
  options?: CloneOptions<T>,
  ...args: unknown[]
) {
  if (!options) {
    return this.slice();
  }

  const result: T[] = [];
  const { transformer }: CloneOptions<T> = options;
  let continueLoop = false;
  let i = 0;

  do {
    if (i >= this.length) {
      break;
    }

    continueLoop = transformer({
      array: result,
      index: i,
      item: this[i],
      original: this,
      args,
    });

    i++;
  } while (continueLoop);

  return result;
};

/**
 * Dummy reverse implementation
 */
function reverse<T>({ index, original, array }: TransformerParams<T>) {
  array.push(original[original.length - 1 - index]);
  return true;
}

/**
 * Dummy splice implementation
 */
function splice<T>({
  index,
  original,
  array,
  args: [start, deleteCount = Number.MAX_SAFE_INTEGER, ...items],
}: TransformerParams<T>): boolean {
  if (start < 0) {
    while (start < 0) {
      start += original.length;
    }
  } else if (start >= original.length) {
    return !array.push(...original, ...items);
  }

  if (index < start) {
    // Always return `true`
    return !!array.push(original[index]);
  }

  array.push(...items);
  index += deleteCount;

  for (; index < original.length; index++) {
    array.push(original[index]);
  }

  return false;
}

const original = ["Jan", "March", "April", "June"];
const clone1 = original.clone();
const multipliedBy2clone = original.clone({
  transformer: ({ item, array }) => !!array.push(item + "_"),
});
const reversedClone = original.clone({ transformer: reverse });
const splicedClone = original.clone({ transformer: splice }, 3, 0, "Feb");
const splicedClone1 = original.clone({ transformer: splice }, 1, 2, "hola");

original[1] = "99";
clone1[0] = "333";

console.log({
  original,
  clone1,
  multipliedBy2clone,
  reversedClone,
  splicedClone,
  splicedClone1,
});

/**
{
  original: [ "Jan", "99", "April", "June" ],
  clone1: [ "333", "March", "April", "June" ],
  multipliedBy2clone: [ "Jan_", "March_", "April_", "June_" ],
  reversedClone: [ "June", "April", "March", "Jan" ],
  splicedClone: [ "Jan", "March", "April", "Feb", "June" ],
  splicedClone1: [ "Jan", "hola", "June" ]
}
 */