@latticexyz/utils 2.0.0-alpha.1.21 → 2.0.0-alpha.1.211

package/src/bytes.spec.ts

@@ -0,0 +1,77 @@
+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

@@ -0,0 +1,85 @@
+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

@@ -0,0 +1,62 @@
+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

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,109 @@
+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

@@ -0,0 +1,14 @@
+/**
+ * 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

@@ -0,0 +1,11 @@
+/**
+ * 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

@@ -0,0 +1,13 @@
+/**
+ * @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;
+}

package/src/eth.ts

@@ -0,0 +1,42 @@
+/**
+ * Pads start of a hex string with 0 to create a bit string of the given length
+ * @param input Hex string
+ * @param bits Number of bits in the output hex string
+ * @returns Hex string of specified length
+ */
+export function padToBitLength(input: string, bits: number) {
+  // Cut off 0x prefix
+  if (input.substring(0, 2) == "0x") input = input.substring(2);
+  // Pad start with 0 to get desired bit length
+  const length = bits / 4;
+  input = input.padStart(length, "0");
+  input = input.substring(input.length - length);
+  // Prefix with 0x
+  return `0x${input}`;
+}
+
+/**
+ * Pads start of a hex string with 0 to create a 160 bit hex string
+ * which can be used as an Ethereum address
+ * @param input Hex string
+ * @returns 160 bit hex string
+ */
+export function toEthAddress(input: string) {
+  return padToBitLength(input, 160);
+}
+
+/**
+ * Pads start of a hex string with 0 to create a 256bit hex string
+ * which can be used as an Ethereum address
+ * @param input Hex string
+ * @returns 256 bit hex string
+ */
+export function to256BitString(input: string) {
+  return padToBitLength(input, 256);
+}
+
+export function extractEncodedArguments(input: string) {
+  // Cutting off the first 4 bytes, which represent the function selector
+  if (input[0] !== "0" && input[1] !== "x") throw new Error("Invalid hex string");
+  return "0x" + input.substring(10);
+}

package/src/guards.ts

@@ -0,0 +1,10 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { Func } from "./types";
+
+export function isObject(c: unknown): c is Record<string, any> {
+  return typeof c === "object" && !Array.isArray(c) && c !== null;
+}
+
+export function isFunction(c: unknown): c is Func<any, any> {
+  return c instanceof Function;
+}

package/src/hash.ts

@@ -0,0 +1,20 @@
+import { BigNumber } from "ethers";
+import { keccak256 as keccak256Bytes, toUtf8Bytes } from "ethers/lib/utils.js";
+import { Coord } from "./types";
+
+import { defaultAbiCoder as abi } from "ethers/lib/utils.js";
+
+/**
+ * Compute keccak256 hash from given string and remove padding from the resulting hex string
+ * @param data String to be hashed
+ * @returns Hash of the given string as hex string without padding
+ */
+export function keccak256(data: string) {
+  return BigNumber.from(keccak256Bytes(toUtf8Bytes(data))).toHexString();
+}
+
+export function keccak256Coord(coord: Coord): string {
+  // TODO: make faster by implementing in wasm
+  const bytes = abi.encode(["int32", "int32"], [coord.x, coord.y]);
+  return keccak256Bytes(bytes);
+}

package/{dist/index.d.ts → src/index.ts}

@@ -24,4 +24,16 @@ export * from "./distance";
 export * from "./math";
 export * from "./bytes";
 export * from "./v2";
-export type { Cached, CachedValue, Func, AsyncFunc, PromiseValue, ValueOf, Area, Coord, VoxelCoord, Logger, } from "./types";
+
+export type {
+  Cached,
+  CachedValue,
+  Func,
+  AsyncFunc,
+  PromiseValue,
+  ValueOf,
+  Area,
+  Coord,
+  VoxelCoord,
+  Logger,
+} from "./types";

package/src/iterable.spec.ts

@@ -0,0 +1,56 @@
+import { arrayToIterator, mergeIterators } from "./iterable";
+
+describe("arrayToIterator", () => {
+  it("should return an iterable iterator with the same content as the array", () => {
+    const array = ["a", "b", "c", 1, 2, 3];
+    const iterator = arrayToIterator(array);
+    expect([...iterator]).toEqual(array);
+  });
+
+  it("should not return a next value if the array is empty", () => {
+    const array: string[] = [];
+    const iterator = arrayToIterator(array);
+    expect([...iterator]).toEqual(array);
+
+    const mock = jest.fn();
+    for (const item of iterator) {
+      mock(item);
+    }
+    expect(mock).not.toHaveBeenCalled();
+  });
+
+  it("should not be possible to iterate over an iterator multiple times", () => {
+    const array = ["a", "b", "c", 1, 2, 3];
+    const iterator = arrayToIterator(array);
+    expect([...iterator]).toEqual(array);
+    expect([...iterator]).toEqual([]);
+  });
+});
+
+describe("mergeIterators", () => {
+  it("should return a merged iterator", () => {
+    const a = arrayToIterator(["a", "b", "c"]);
+    const b = arrayToIterator([1, 2, 3]);
+    expect([...mergeIterators(a, b)]).toEqual([
+      ["a", 1],
+      ["b", 2],
+      ["c", 3],
+    ]);
+  });
+
+  it("should work with iterators of unequal length", () => {
+    const a = arrayToIterator(["a"]);
+    const b = arrayToIterator([1, 2, 3]);
+    expect([...mergeIterators(a, b)]).toEqual([
+      ["a", 1],
+      [null, 2],
+      [null, 3],
+    ]);
+  });
+
+  it("should return an empty iterator if both inputs are empty", () => {
+    const a = arrayToIterator([]);
+    const b = arrayToIterator([]);
+    expect([...mergeIterators(a, b)]).toEqual([]);
+  });
+});

package/src/iterable.ts

@@ -0,0 +1,59 @@
+export function makeIterable<T>(iterator: Iterator<T>): IterableIterator<T> {
+  const iterable: IterableIterator<T> = {
+    ...iterator,
+    [Symbol.iterator]() {
+      return this;
+    },
+  };
+
+  return iterable;
+}
+
+export function concatIterators<T>(first: Iterator<T>, second?: Iterator<T>): IterableIterator<T> {
+  if (!second) return makeIterable(first);
+  return makeIterable({
+    next() {
+      const next = first.next();
+      if (!next.done) return next;
+      return second.next();
+    },
+  });
+}
+
+export function mergeIterators<A, B>(iteratorA: Iterator<A>, iteratorB: Iterator<B>): IterableIterator<[A, B]> {
+  const iterator: Iterator<[A, B]> = {
+    next() {
+      const nextA = iteratorA.next();
+      const nextB = iteratorB.next();
+      if (nextA.done && nextB.done) return { done: true, value: null };
+      return { value: [nextA.value, nextB.value] };
+    },
+  };
+  return makeIterable(iterator);
+}
+
+export function transformIterator<A, B>(iterator: Iterator<A>, transform: (value: A) => B): IterableIterator<B> {
+  return makeIterable({
+    next() {
+      const { done, value } = iterator.next();
+      return { done, value: done ? value : transform(value) };
+    },
+  });
+}
+
+/**
+ * Turns an array into an iterator. NOTE: an iterator can only be iterated once.
+ * @param array Array to be turned into an iterator
+ * @returns Iterator to iterate through the array
+ */
+export function arrayToIterator<T>(array: T[]): IterableIterator<T> {
+  let i = 0;
+  const iterator: Iterator<T> = {
+    next() {
+      const done = i >= array.length;
+      if (done) return { done, value: null };
+      return { value: array[i++] };
+    },
+  };
+  return makeIterable(iterator);
+}

package/{dist/math.d.ts → src/math.ts}

@@ -5,4 +5,7 @@
  * @param x A numeric expression.
  * @returns Input rounded towards zero.
  */
-export declare function roundTowardsZero(x: number): number;
+export function roundTowardsZero(x: number) {
+  const sign = x < 0 ? -1 : 1;
+  return sign * Math.floor(Math.abs(x));
+}

package/src/mobx.ts

@@ -0,0 +1,26 @@
+import { IComputedValue, IObservableValue, reaction } from "mobx";
+import { deferred } from "./deferred";
+
+/**
+ * @param comp Computed/Observable value that is either defined or undefined
+ * @returns promise that resolves with the first truthy computed value
+ */
+export async function awaitValue<T>(comp: IComputedValue<T | undefined> | IObservableValue<T | undefined>): Promise<T> {
+  const [resolve, , promise] = deferred<T>();
+
+  const dispose = reaction(
+    () => comp.get(),
+    (value) => {
+      if (value) {
+        resolve(value);
+      }
+    },
+    { fireImmediately: true }
+  );
+
+  const value = await promise;
+  // Dispose the reaction once the promise is resolved
+  dispose();
+
+  return value;
+}

package/src/objects.ts

@@ -0,0 +1,16 @@
+/**
+ * Utility function to map a source object to an object with the same keys but mapped values
+ * @param source Source object to be mapped
+ * @param valueMap Mapping values of the source object to values of the target object
+ * @returns An object with the same keys as the source object but mapped values
+ */
+export function mapObject<S extends { [key: string]: unknown }, T extends { [key in keyof S]: unknown }>(
+  source: S,
+  valueMap: (value: S[keyof S], key: keyof S) => T[keyof S]
+): T {
+  const target: Partial<{ [key in keyof typeof source]: T[keyof S] }> = {};
+  for (const key in source) {
+    target[key] = valueMap(source[key], key);
+  }
+  return target as T;
+}