TypeScript で生やしてる便利メソッド

declare global {
  // eslint-disable-next-line unused-imports/no-unused-vars
  interface Array<T> {
    isEmpty(): boolean;
    indexById(): { [id: number]: T };
    compact(): Exclude<T, null | undefined>[];
    shuffle(): T[];
  }
}

Array.prototype.isEmpty = function () {
  return this.length === 0;
};

Array.prototype.indexById = function () {
  return this.reduce(function (map, obj) {
    map[obj.id] = obj;
    return map;
  }, {});
};

Array.prototype.compact = function <T>(this: (T | null | undefined)[]): T[] {
  return this.filter(
    (element): element is T => element !== null && element !== undefined
  );
};

Array.prototype.shuffle = function <T>(this: T[]): T[] {
  const array = this.slice();
  for (let i = array.length - 1; i > 0; i--) {
    const r = Math.floor(Math.random() * (i + 1));
    const tmp = array[i];
    array[i] = array[r];
    array[r] = tmp;
  }
  return array;
};

declare global {
  // eslint-disable-next-line unused-imports/no-unused-vars
  interface Object {
    then<T, R>(this: T, fn: (value: T) => R): R;
  }
}

Object.prototype.then = function <T, R>(this: T, fn: (value: T) => R): R {
  return fn(this);
};

Array.prototype.chunk = function <T>(this: T[], size: number): T[][] {
  return this.reduce(
    (chunks, _, index) =>
      index % size === 0
        ? [...chunks, this.slice(index, index + size)]
        : chunks,
    [] as T[][]
  );
}