@latticexyz/utils 2.0.12-account-kit-10002da0 → 2.0.12-account-kit-9160f5e1a

package/src/CoordMap.spec.ts

@@ -1,57 +0,0 @@
-import { coordToKey, keyToCoord } from "./CoordMap";
-
-describe("CoordMap", () => {
-  describe("coordToKey", () => {
-    it("should be the inverse of keyToCoord", () => {
-      const MAX = 2 ** 15 - 1;
-      const coords = [
-        { x: 1, y: 2 },
-        { x: -1, y: 2 },
-        { x: 1, y: -2 },
-        { x: 0, y: 0 },
-        { x: -1, y: -2 },
-        { x: MAX, y: MAX },
-        { x: -1 * MAX, y: MAX },
-        { x: MAX, y: -1 * MAX },
-        { x: -1 * MAX, y: -1 * MAX },
-      ];
-
-      for (const coord of coords) {
-        const key = coordToKey(coord);
-        expect(keyToCoord(key)).toEqual(coord);
-      }
-    });
-  });
-
-  describe("keyToCoord", () => {
-    it("should be the inverse of coordToKey", () => {
-      const keys = [
-        "11111111111111110000000000000000",
-        "11011101110111011000101001001000",
-        "01101101101110110001010101111001",
-        "11010101111011010010010010001001",
-        "00111111111111110111000001001100",
-        "01101110001111010110010010001001",
-        "10101110011011010010010001010101",
-        "01011011101011010101100100101000",
-        "11011110111101111000010000100011",
-        "10110111011011010101101010001001",
-        "00110111011101110001000100010000",
-        "10110101101101010001001010001001",
-        "01100011010101111010010100110010",
-        "11111111111111111111111111111111",
-        "00000000000000000000000000000000",
-      ];
-
-      for (const key of keys) {
-        const numKey = parseInt(key, 2) >> 0;
-        const coord = keyToCoord(numKey);
-        expect(coordToKey(coord)).toEqual(numKey);
-      }
-    });
-
-    it("should work with {x: 0, y: 0}", () => {
-      expect(keyToCoord(0)).toEqual({ x: 0, y: 0 });
-    });
-  });
-});

package/src/CoordMap.ts

@@ -1,106 +0,0 @@
-import { Coord } from "./types";
-import { transformIterator } from "./iterable";
-
-const LOWER_HALF_MASK = 2 ** 16 - 1;
-const MAX_SUPPORTED = 2 ** 15 - 1;
-
-export function subtract(from: CoordMap<boolean>, subtract: CoordMap<boolean>): CoordMap<boolean> {
-  const result = new CoordMap<boolean>();
-
-  for (const coord of from.coords()) {
-    if (subtract.get(coord)) continue;
-    result.set(coord, true);
-  }
-
-  return result;
-}
-
-export function coordToKey(coord: Coord) {
-  const key = (coord.x << 16) | (coord.y & LOWER_HALF_MASK);
-  return key;
-
-  // Old version using strings:
-  // return `${coord.x}/${coord.y}`;
-}
-
-export function keyToCoord(key: number): Coord {
-  const x = key >> 16;
-  const y = (key << 16) >> 16;
-  return { x, y };
-
-  // Old version using strings:
-  // const fragments = key.split("/");
-  // return { x: Number(fragments[0]), y: Number(fragments[1]) };
-}
-
-export class CoordMap<T> {
-  map: Map<number, T>;
-  defaultValue?: T;
-
-  constructor(props?: { defaultValue?: T }) {
-    this.map = new Map<number, T>();
-    this.defaultValue = props?.defaultValue;
-  }
-
-  static from<T>(coordMapLike: { map: Map<number, T>; defaultValue?: T }): CoordMap<T> {
-    const coordMap = new CoordMap<T>();
-    coordMap.map = coordMapLike.map;
-    coordMap.defaultValue = coordMapLike.defaultValue;
-    return coordMap;
-  }
-
-  set(coord: Coord, value: T) {
-    if (
-      coord.x > MAX_SUPPORTED ||
-      coord.x < -1 * MAX_SUPPORTED ||
-      coord.y > MAX_SUPPORTED ||
-      coord.y < -1 * MAX_SUPPORTED
-    ) {
-      throw new Error(`CoordMap only supports coords up to ${MAX_SUPPORTED}`);
-    }
-    return this.map.set(coordToKey(coord), value);
-  }
-
-  get(coord: Coord) {
-    return this.map.get(coordToKey(coord)) ?? this.defaultValue;
-  }
-
-  keys() {
-    return this.map.keys();
-  }
-
-  coords(): IterableIterator<Coord> {
-    return transformIterator(this.map.keys(), (key) => keyToCoord(key));
-  }
-
-  entries() {
-    return this.map.entries();
-  }
-
-  toArray(): [Coord, T][] {
-    const entries = Array.from(this.map.entries());
-    return entries.map(([key, value]) => [keyToCoord(key), value]);
-  }
-
-  values() {
-    return this.map.values();
-  }
-
-  delete(coord: Coord) {
-    return this.map.delete(coordToKey(coord));
-  }
-
-  has(coord: Coord): boolean {
-    return this.map.has(coordToKey(coord));
-  }
-
-  clear() {
-    for (const key of this.map.keys()) {
-      this.map.delete(key);
-    }
-  }
-
-  get size(): number {
-    return this.map.size;
-  }
-}

package/src/VoxelCoordMap.ts

@@ -1,76 +0,0 @@
-import { VoxelCoord } from "./types";
-import { transformIterator } from "./iterable";
-
-function coordToKey(coord: VoxelCoord) {
-  // TODO: find a more memory efficient way to store these keys
-  return `${coord.x}/${coord.y}/${coord.z}`;
-}
-
-function keyToCoord(key: string): VoxelCoord {
-  const fragments = key.split("/");
-  return { x: Number(fragments[0]), y: Number(fragments[1]), z: Number(fragments[2]) };
-}
-
-export class VoxelCoordMap<T> {
-  map: Map<string, T>;
-  defaultValue?: T;
-
-  constructor(props?: { defaultValue?: T }) {
-    this.map = new Map<string, T>();
-    this.defaultValue = props?.defaultValue;
-  }
-
-  static from<T>(coordMapLike: { map: Map<string, T>; defaultValue?: T }): VoxelCoordMap<T> {
-    const coordMap = new VoxelCoordMap<T>();
-    coordMap.map = coordMapLike.map;
-    coordMap.defaultValue = coordMapLike.defaultValue;
-    return coordMap;
-  }
-
-  set(coord: VoxelCoord, value: T) {
-    return this.map.set(coordToKey(coord), value);
-  }
-
-  get(coord: VoxelCoord) {
-    return this.map.get(coordToKey(coord)) ?? this.defaultValue;
-  }
-
-  keys() {
-    return this.map.keys();
-  }
-
-  coords(): IterableIterator<VoxelCoord> {
-    return transformIterator(this.map.keys(), (key) => keyToCoord(key));
-  }
-
-  entries() {
-    return this.map.entries();
-  }
-
-  toArray(): [VoxelCoord, T][] {
-    const entries = Array.from(this.map.entries());
-    return entries.map(([key, value]) => [keyToCoord(key), value]);
-  }
-
-  values() {
-    return this.map.values();
-  }
-
-  delete(coord: VoxelCoord) {
-    return this.map.delete(coordToKey(coord));
-  }
-
-  has(coord: VoxelCoord): boolean {
-    return this.map.has(coordToKey(coord));
-  }
-
-  clear() {
-    for (const key of this.map.keys()) {
-      this.map.delete(key);
-    }
-  }
-
-  get size(): number {
-    return this.map.size;
-  }
-}

package/src/area.ts

@@ -1,15 +0,0 @@
-import { Area, Coord } from "./types";
-
-export function areaContains(area: Area, coord: Coord) {
-  return coord.x >= area.x && coord.y >= area.y && coord.x < area.x + area.width && coord.y < area.y + area.height;
-}
-
-export function coordsOf(area: Area) {
-  const coords: Coord[] = [];
-  for (let dx = 0; dx < area.width; dx++) {
-    for (let dy = 0; dy < area.height; dy++) {
-      coords.push({ x: area.x + dx, y: area.y + dy });
-    }
-  }
-  return coords;
-}

package/src/arrays.ts

@@ -1,19 +0,0 @@
-/**
- * TypeScript type guard to assert the type of a non-empty array
- * @param array Any array to check for non-emptiness
- * @returns True if the empty is non-empty, else false. TypeScript accepts the array as non-empty after the assertion.
- */
-export function isNotEmpty<T>(array: T[]): array is [T, ...T[]] {
-  if (array.length === 0) return false;
-  return true;
-}
-
-/**
- * Filters undefined values from an array and lets TypeScript know the resulting array
- * does not have undefined values
- * @param array Array potentially including undefined values
- * @returns Array without undefined values
- */
-export function filterNullishValues<T>(array: (T | undefined)[]): T[] {
-  return array.filter((value) => value != null) as T[];
-}

package/src/bytes.spec.ts

@@ -1,77 +0,0 @@
-import {
-  formatHex,
-  hexStringToUint8Array,
-  Uint8ArrayToHexString,
-  concatUint8Arrays,
-  splitUint8Arrays,
-  Int32ArrayToUint8Array,
-  Uint8ArrayToInt32Array,
-  ethAddressToUint8Array,
-} from "./bytes";
-import { random } from "./random";
-
-const NUM_TESTS = 1000;
-
-describe("bytes", () => {
-  describe("Uint8ArrayToHexString", () => {
-    it("should be the inverse of hexStringToUint8Array", () => {
-      for (let i = 0; i < NUM_TESTS; i++) {
-        const hex = formatHex(random(Number.MAX_SAFE_INTEGER).toString(16));
-        expect(Uint8ArrayToHexString(hexStringToUint8Array(hex))).toBe(hex);
-      }
-    });
-  });
-
-  describe("hexStringToUint8Array", () => {
-    it("should be the inverse of Uint8ArrayToHexString", () => {
-      for (let i = 0; i < NUM_TESTS; i++) {
-        const uint8arr = hexStringToUint8Array(formatHex(random(Number.MAX_SAFE_INTEGER).toString(16)));
-        expect(hexStringToUint8Array(Uint8ArrayToHexString(uint8arr))).toEqual(uint8arr);
-      }
-    });
-  });
-
-  describe("concatUint8Arrays", () => {
-    it("should concat Uint8Arrays", () => {
-      const arr1 = [123, 456, -134];
-      const arr2 = [763, 99887, 0, 0];
-      const result = [...arr1, ...arr2];
-      expect(concatUint8Arrays(Uint8Array.from(arr1), Uint8Array.from(arr2))).toEqual(Uint8Array.from(result));
-    });
-  });
-
-  describe("splitUint8Arrays", () => {
-    it("should split Uint8Arrays", () => {
-      const arr1 = [123, 456, -134];
-      const arr2 = [763, 99887, 0, 0];
-      const result = [...arr1, ...arr2];
-      expect(splitUint8Arrays(Uint8Array.from(result), [3, 4])).toEqual([Uint8Array.from(arr1), Uint8Array.from(arr2)]);
-      expect(splitUint8Arrays(Uint8Array.from(result), [4, 3])).toEqual([
-        Uint8Array.from([123, 456, -134, 763]),
-        Uint8Array.from([99887, 0, 0]),
-      ]);
-    });
-  });
-
-  describe("Uint8ArrayToInt32Array", () => {
-    it("should be the inverse of Int32ArrayToUint8Array", () => {
-      const input = [123, -456, 0, 2 ** 31 - 1, -1 * 2 ** 31];
-      const bytes = Int32ArrayToUint8Array(input);
-      expect(Uint8ArrayToInt32Array(bytes)).toEqual(input);
-    });
-  });
-
-  describe("Int32ArrayToUint8Array", () => {
-    it("should be the inverse of Uint8ArrayToInt32Array", () => {
-      const input = [123, -456, 0, 2 ** 31 - 1, -1 * 2 ** 31];
-      const bytes = Int32ArrayToUint8Array(input);
-      expect(Int32ArrayToUint8Array(Uint8ArrayToInt32Array(bytes))).toEqual(bytes);
-    });
-  });
-
-  describe("ethAddressToUint8Array", () => {
-    it("should produce a 160bit Uint8Array", () => {
-      expect(ethAddressToUint8Array("0x00").length).toBe(20);
-    });
-  });
-});

package/src/bytes.ts

@@ -1,85 +0,0 @@
-import { toEthAddress } from "./eth";
-import { hexToArray } from "./v2";
-
-export function formatHex(hex: string): string {
-  if (hex.substring(0, 2) == "0x") hex = hex.substring(2);
-  const prefix = hex.length % 2 !== 0 ? "0x0" : "0x";
-  return prefix + hex;
-}
-
-export function hexStringToUint8Array(hexString: string): Uint8Array {
-  return hexToArray(hexString);
-}
-
-export function Uint8ArrayToHexString(data: Uint8Array): string {
-  if (data.length === 0) return "0x00";
-  return formatHex(data.reduce((str, byte) => str + byte.toString(16).padStart(2, "0"), ""));
-}
-
-export function concatUint8Arrays(...arrays: Uint8Array[]): Uint8Array {
-  return Uint8Array.from(
-    arrays.reduce<number[]>((acc, curr) => {
-      return [...acc, ...curr];
-    }, []),
-  );
-}
-
-export function splitUint8Arrays(data: Uint8Array, byteLengths: number[]): Uint8Array[] {
-  const arrays: Uint8Array[] = [];
-  let i = 0;
-  for (const length of byteLengths) {
-    const array = new Uint8Array(length);
-    arrays.push(array);
-    for (let j = 0; j < length; j++) {
-      array[j] = data[i];
-      i++;
-    }
-  }
-  return arrays;
-}
-
-export function Int32ArrayToUint8Array(input: number[]): Uint8Array {
-  const buffer = new ArrayBuffer(input.length * 4);
-  const int32arr = new Int32Array(buffer);
-  for (let i = 0; i < input.length; i++) {
-    int32arr[i] = input[i];
-  }
-  return new Uint8Array(buffer);
-}
-
-export function Uint8ArrayToInt32Array(input: Uint8Array): number[] {
-  return [...new Int32Array(input.buffer)];
-}
-
-export function ethAddressToUint8Array(address: string): Uint8Array {
-  return hexStringToUint8Array(toEthAddress(address));
-}
-
-// https://stackoverflow.com/a/55330424
-export function createToInt(size: number) {
-  if (size < 2) {
-    throw new Error("Minimum size is 2");
-  } else if (size > 64) {
-    throw new Error("Maximum size is 64");
-  }
-
-  // Determine value range
-  const maxValue = 2 ** (size - 1) - 1;
-  const minValue = -maxValue - 1;
-
-  return (value: number) => {
-    value = value << 0;
-    if (value > maxValue || value < minValue) {
-      console.log("value", value, maxValue, minValue, value > maxValue, value < minValue);
-      throw new Error(`Int${size} overflow`);
-    }
-
-    if (value < 0) {
-      return 2 ** size + value;
-    } else {
-      return value;
-    }
-  };
-}
-
-export const toInt32 = createToInt(32);

package/src/console.ts

@@ -1,62 +0,0 @@
-const TOPICS_KEY = "mud-logger-topics";
-
-export function enableLogger() {
-  const windowConsole = window.console;
-  let filtersActive = Boolean(localStorage.getItem(TOPICS_KEY));
-
-  const topicsString = localStorage.getItem(TOPICS_KEY);
-  let topics: string[] = topicsString ? JSON.parse(topicsString) : [];
-
-  function log(...logs: string[]) {
-    if (filtersActive) return;
-    windowConsole.log(...logs);
-  }
-
-  function logWithTopic(topic: string, ...logs: string[]) {
-    if (!filtersActive || topics.includes(topic)) {
-      windowConsole.log(`--- BETTER CONSOLE / TOPIC ${topic} ---`);
-      windowConsole.log(...logs);
-    }
-  }
-
-  function enableFilters() {
-    localStorage.setItem(TOPICS_KEY, JSON.stringify([]));
-    filtersActive = true;
-  }
-
-  function disableFilters() {
-    localStorage.removeItem(TOPICS_KEY);
-    filtersActive = false;
-  }
-
-  function addTopic(topic: string) {
-    topics.push(topic);
-    localStorage.setItem(TOPICS_KEY, JSON.stringify(topics));
-  }
-
-  function removeTopic(topic: string) {
-    topics = topics.filter((t) => t !== topic);
-    localStorage.setItem(TOPICS_KEY, JSON.stringify(topics));
-  }
-
-  function resetTopics() {
-    topics = [];
-    localStorage.setItem(TOPICS_KEY, JSON.stringify(topics));
-  }
-
-  const logger = {
-    ...windowConsole,
-    log,
-    logWithTopic,
-    enableFilters,
-    disableFilters,
-    addTopic,
-    removeTopic,
-    resetTopics,
-  };
-
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  (window as any).logger = logger;
-  window.console = logger;
-  return logger;
-}

package/src/cubic.spec.ts

@@ -1,14 +0,0 @@
-import { cubicNoiseSample2, cubicNoiseConfig } from "./cubic";
-
-describe("Cubic", () => {
-  it("computes noise", () => {
-    const coords: [number, number][] = [];
-    for (let i = 0; i < 100; i++) {
-      coords.push([Math.floor((Math.random() - 0.5) * 1000), Math.floor((Math.random() - 0.5) * 1000)]);
-    }
-
-    const noises = coords.map((c) => cubicNoiseSample2(cubicNoiseConfig(1000, 64, 16, 256, 256), c[0], c[1]));
-    console.log("coords", JSON.stringify(coords));
-    console.log("noises", JSON.stringify(noises));
-  });
-});

package/src/cubic.ts

@@ -1,109 +0,0 @@
-const RND_A = 134775813;
-const RND_B = 1103515245;
-const ACCURACY = 1000;
-
-export function randomize(seed: number, x: number, y: number) {
-  return (((((x ^ y) * RND_A) ^ (seed + x)) * (((RND_B * x) << 16) ^ (RND_B * y - RND_A))) >>> 0) / 4294967295;
-}
-
-export function tile(coordinate: number, period: number) {
-  if (coordinate < 0) while (coordinate < 0) coordinate += period;
-  return coordinate % period;
-}
-
-export function interpolate(a: number, b: number, c: number, d: number, x: number, s: number, scale: number) {
-  const p = d - c - (a - b);
-  return (b * Math.pow(s, 3) + x * (c * Math.pow(s, 2) + a * s * (-s + x) + x * (-(b + p) * s + p * x))) * scale;
-
-  // return (x) * ((x ) * ((x ) * p + (a - b - p)) + (c - a)) + b;
-}
-
-/**
- * Config a cubic noise.
- * @param {Number} seed A seed in the range [0, 1].
- * @param {Number} [periodX] The number of units after which the x coordinate repeats.
- * @param {Number} [periodY] The number of units after which the y coordinate repeats.
- * @returns {Object} A configuration object used by noise functions.
- */
-export function cubicNoiseConfig(
-  seed: number,
-  octave: number,
-  scale: number,
-  periodX = Number.MAX_SAFE_INTEGER,
-  periodY = Number.MAX_SAFE_INTEGER,
-) {
-  return {
-    seed: Math.floor(seed * Number.MAX_SAFE_INTEGER),
-    periodX: periodX,
-    periodY: periodY,
-    octave,
-    scale,
-  };
-}
-
-/**
- * Sample 1D cubic noise.
- * @param {Object} config A valid noise configuration.
- * @param {Number} x The X position to sample at.
- * @returns {Number} A noise value in the range [0, 1].
- */
-export function cubicNoiseSample1(config: ReturnType<typeof cubicNoiseConfig>, x: number) {
-  const xi = Math.floor(x);
-  const lerp = x - xi;
-
-  return (
-    interpolate(
-      randomize(config.seed, tile(xi - 1, config.periodX), 0),
-      randomize(config.seed, tile(xi, config.periodX), 0),
-      randomize(config.seed, tile(xi + 1, config.periodX), 0),
-      randomize(config.seed, tile(xi + 2, config.periodX), 0),
-      lerp,
-      1,
-      1,
-    ) *
-      0.666666 +
-    0.166666
-  );
-}
-
-/**
- * Sample 2D cubic noise.
- * @param {Object} config A valid noise configuration.
- * @param {Number} x The X position to sample at.
- * @param {Number} y The Y position to sample at.
- * @returns {Number} A noise value in the range [0, 1].
- */
-export function cubicNoiseSample2(
-  { octave, periodX, periodY, seed, scale }: ReturnType<typeof cubicNoiseConfig>,
-  x: number,
-  y: number,
-) {
-  const xi = Math.floor(x / octave);
-  const lerpX = Math.floor((x * ACCURACY) / octave) - xi * ACCURACY;
-  const yi = Math.floor(y / octave);
-  const lerpY = Math.floor((y * ACCURACY) / octave) - yi * ACCURACY;
-  const x0 = tile(xi - 1, periodX);
-  const x1 = tile(xi, periodX);
-  const x2 = tile(xi + 1, periodX);
-  const x3 = tile(xi + 2, periodX);
-
-  const xSamples = new Array(4);
-
-  for (let i = 0; i < 4; ++i) {
-    const y = tile(yi - 1 + i, periodY);
-
-    xSamples[i] = interpolate(
-      randomize(seed, x0, y),
-      randomize(seed, x1, y),
-      randomize(seed, x2, y),
-      randomize(seed, x3, y),
-      lerpX,
-      ACCURACY,
-      1,
-    );
-  }
-
-  return Math.floor(
-    interpolate(xSamples[0], xSamples[1], xSamples[2], xSamples[3], lerpY, ACCURACY, scale) / Math.pow(ACCURACY, 6),
-  );
-}

package/src/deferred.ts

@@ -1,14 +0,0 @@
-/**
- * A convenient way to create a promise with resolve and reject functions.
- * @returns Tuple with resolve function, reject function and promise.
- */
-export function deferred<T>(): [(t: T) => void, (t: Error) => void, Promise<T>] {
-  let resolve: ((t: T) => void) | null = null;
-  let reject: ((t: Error) => void) | null = null;
-  const promise = new Promise<T>((r, rj) => {
-    resolve = (t: T) => r(t);
-    reject = (e: Error) => rj(e);
-  });
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  return [resolve as any, reject as any, promise];
-}

package/src/distance.ts

@@ -1,11 +0,0 @@
-/**
- * Compute the Euclidean distance between two points
- * https://en.wikipedia.org/wiki/Euclidean_distance
- * @param a
- * @param b
- * @returns Euclidian distance between a and b
- */
-export function euclidean(a: number[], b: number[]): number {
-  if (a.length !== b.length) throw new Error("points must have same dimension");
-  return Math.sqrt(a.reduce((acc, _, i) => acc + Math.pow(a[i] - b[i], 2), 0));
-}

package/src/enums.ts

@@ -1,13 +0,0 @@
-/**
- * @param enm Numeric enum
- * @returns Number array containing the enum values
- */
-export function numValues(enm: object): number[] {
-  const nums: number[] = [];
-  for (const val of Object.values(enm)) {
-    if (!isNaN(Number(val))) {
-      nums.push(Number(val));
-    }
-  }
-  return nums;
-}