Dustin Boston

/**
 * Creates an array that can have negative indexes using a JavaScript Proxy.
 *
 * @example
 * 	```ts
 * 	  const array = new NegativeArray(1, 2, 3, 4, 5);
 * 	  console.log(array[-1]); // Output: 5
 * 	  array[-2] = 42;
 * 	  console.log(array[3]); // Output: 42
 * 	  console.log(array[10]); // Output: undefined
 * 	  ```;
 *
 * @param arrayToProxy - The array to be proxied.
 * @returns A proxied array allowing negative indexing.
 * @see A. Balane, "JavaScript array negative index using proxies," Medium,
 *   https://medium.com/uncaught-exception/javascript-array-negative-index-using-proxies-ed096dc84416
 */
export class NegativeArray<T> extends Array<T> {
  constructor(...items: T[]) {
    super(...items);

    // eslint-disable-next-line no-constructor-return
    return new Proxy(this, {
      get(
        target: T[],
        property: string | symbol,
        receiver: any,
      ): T | undefined {
        if (typeof property === "string" && !Number.isNaN(Number(property))) {
          let propertyValue = Number.parseInt(property, 10);
          if (propertyValue < 0) propertyValue += target.length;
          return target[propertyValue];
        }

        // Safe casting of the Reflect.get return value to expected type
        return Reflect.get(target, property, receiver) as T | undefined;
      },
      set(
        target: T[],
        property: string | symbol,
        value: T,
        receiver: any,
      ): boolean {
        if (typeof property === "string" && !Number.isNaN(Number(property))) {
          let propertyValue = Number.parseInt(property, 10);
          if (propertyValue < 0) propertyValue += target.length;
          target[propertyValue] = value; // Safe assignment of typed value
          return true;
        }

        return Reflect.set(target, property, value, receiver);
      },
    });
  }
}

import {NegativeArray} from "../../../../data/algorithms/src/util/negative_array.ts";
import {assertEquals} from "$assert";

test(function testNegativeIndices() {
  const narr = new NegativeArray<number>(1, 2, 3, 4);
  assertEquals(narr[-1], 4);
  assertEquals(narr[-2], 3);
  assertEquals(narr[-3], 2);
  assertEquals(narr[-4], 1);
});

test(function testNegativeOutOfRange() {
  const narr = new NegativeArray<number>(1, 2, 3, 4);
  assertEquals(narr[-5], undefined);
  assertEquals(narr[-6], undefined);
});

test(function testSetNegative() {
  const narr = new NegativeArray<number>(1, 2, 3, 4);

  narr[-1] = 9;
  assertEquals(narr[3], 9);

  narr[-4] = 0;
  assertEquals(narr[0], 0);
});

test(function testNominalArray() {
  const narr = new NegativeArray<number>(1, 2, 3, 4);

  assertEquals(narr[0], 1);
  assertEquals(narr[1], 2);
  assertEquals(narr[2], 3);
  assertEquals(narr[3], 4);

  narr[0] = 9;
  assertEquals(narr[0], 9);
  narr[3] = 8;
  assertEquals(narr[3], 8);
});