@latticexyz/utils 0.10.0 → 0.12.0

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/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;
-}

package/src/eth.ts

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

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

@@ -1,11 +0,0 @@
-import { BigNumber } from "ethers";
-import { keccak256 as keccak256Bytes, toUtf8Bytes } from "ethers/lib/utils";
-
-/**
- * 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();
-}

package/src/iterable.spec.ts

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

@@ -1,59 +0,0 @@
-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/src/mobx.ts

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

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

package/src/pack.spec.ts

@@ -1,37 +0,0 @@
-import { pack, unpack } from "./pack";
-
-describe("pack", () => {
-  it("should pack multiple numbers into one 32 bit integer", () => {
-    const packed = pack([1, 2], [8, 24]);
-    expect(packed).toBe(parseInt("1000000000000000000000010", 2));
-  });
-
-  it("should be the inverse of unpack", () => {
-    const bits = [8, 24];
-    const numbers = [16777218, 2072396467, -1];
-
-    for (const nums of numbers) {
-      expect(pack(unpack(nums, bits), bits)).toEqual(nums);
-    }
-  });
-});
-
-describe("unpack", () => {
-  it("should unpack a packed 32 bit integer into multiple numbers", () => {
-    const unpacked = unpack(parseInt("1000000000000000000000010", 2), [8, 24]);
-    expect(unpacked).toEqual([1, 2]);
-  });
-
-  it("should be the inverse of pack", () => {
-    const bits = [8, 24];
-    const numbers = [
-      [1, 2],
-      [123, 8798899],
-      [2 ** 8 - 1, 2 ** 24 - 1],
-    ];
-
-    for (const nums of numbers) {
-      expect(unpack(pack(nums, bits), bits)).toEqual(nums);
-    }
-  });
-});

package/src/pack.ts

@@ -1,61 +0,0 @@
-function rightMask(input: number, keep: number): number {
-  return input & (2 ** keep - 1);
-}
-
-/**
- * Packs two unsigned integers in one 32 bit unsigned integer
- * @param numbers Unsigned integers to be packed in 32 bit integer
- * @param bitsPerNumber Bits for each number
- * @returns Packed 32 bit unsigned integer
- */
-export function pack(numbers: number[], bitsPerNumber: number[]): number {
-  // Total number of bits must be 32
-  if (bitsPerNumber.reduce((acc, curr) => acc + curr, 0) > 32) {
-    throw new Error("JS pretends integers are 32 bit when bitshifts are involved");
-  }
-
-  // Array lengths must match
-  if (numbers.length !== bitsPerNumber.length) throw new Error("Arrays' lengths must match");
-
-  // Numbers must fit in number of bits and must be unsigned
-  for (let i = 0; i < numbers.length; i++) {
-    if (numbers[i] < 0) {
-      throw new Error("Underflow: can only pack unsigned integer");
-    }
-    if (numbers[i] > 2 ** bitsPerNumber[i] - 1) {
-      const error = `Overflow: ${numbers[i]} does not fit in ${bitsPerNumber[i]} bits`;
-      throw new Error(error);
-    }
-  }
-
-  // Pack number
-  let packed = 0;
-  for (let i = 0; i < numbers.length; i++) {
-    packed = (packed << bitsPerNumber[i]) | numbers[i];
-  }
-  return packed;
-}
-
-/**
- * Unpacks a packed 32 bit unsigned integer into the original unsigned integers
- * @param packed Packed 32 bit unsigned integer
- * @param bitsPerNumber Bits for each unsigned integer
- * @returns Array of unpacked unsignd integers
- */
-export function unpack(packed: number, bitsPerNumber: number[]): number[] {
-  const numbers: number[] = [];
-  let shiftedPacked = packed;
-  for (let i = bitsPerNumber.length - 1; i >= 0; i--) {
-    numbers.unshift(rightMask(shiftedPacked, bitsPerNumber[i]));
-    shiftedPacked = shiftedPacked >>> bitsPerNumber[i];
-  }
-  return numbers;
-}
-
-export function packTuple(numbers: [number, number]): number {
-  return pack(numbers, [8, 24]);
-}
-
-export function unpackTuple(packed: number): [number, number] {
-  return unpack(packed, [8, 24]) as [number, number];
-}

package/src/promise.ts

@@ -1,45 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { deferred } from "./deferred";
-import { sleep } from "./sleep";
-
-export const range = function* (total = 0, step = 1, from = 0) {
-  // eslint-disable-next-line no-empty
-  for (let i = 0; i < total; yield from + i++ * step) {}
-};
-
-export async function rejectAfter<T>(ms: number, msg: string): Promise<T> {
-  await sleep(ms);
-  throw new Error(msg);
-}
-
-export const timeoutAfter = async <T>(promise: Promise<T>, ms: number, timeoutMsg: string) => {
-  return Promise.race([promise, rejectAfter<T>(ms, timeoutMsg)]);
-};
-
-export const callWithRetry = <T>(
-  fn: (...args: any[]) => Promise<T>,
-  args: any[] = [],
-  maxRetries = 10,
-  retryInterval = 1000
-): Promise<T> => {
-  const [resolve, reject, promise] = deferred<T>();
-  const process = async () => {
-    let res: T;
-    for (let i = 0; i < maxRetries; i++) {
-      try {
-        res = await fn(...args);
-        resolve(res);
-        break;
-      } catch (e) {
-        if (i < maxRetries - 1) {
-          console.log("going to sleep", i);
-          await sleep(Math.min(retryInterval * 2 ** i + Math.random() * 100, 15000));
-        } else {
-          reject(e as unknown as Error);
-        }
-      }
-    }
-  };
-  process();
-  return promise;
-};