@latticexyz/utils 2.0.12-account-kit-27d878b7 → 2.0.12-account-kit-72f3555a8

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/index.ts

@@ -1,38 +0,0 @@
-export * from "./arrays";
-export * from "./deferred";
-export * from "./mobx";
-export * from "./guards";
-export * from "./proxy";
-export * from "./enums";
-export * from "./objects";
-export * from "./random";
-export * from "./rx";
-export * from "./uuid";
-export * from "./promise";
-export * from "./sleep";
-export * from "./iterable";
-export * from "./area";
-export * from "./worker";
-export * from "./pack";
-export * from "./CoordMap";
-export * from "./VoxelCoordMap";
-export * from "./eth";
-export * from "./cubic";
-export * from "./console";
-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";

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/math.ts

@@ -1,11 +0,0 @@
-/**
- * For positive inputs: returns the greatest integer less than or equal to its numeric argument.
- * For negative inputs: returns the smallest integer greater than or equal to its numeric argument.
- *
- * @param x A numeric expression.
- * @returns Input rounded towards zero.
- */
-export function roundTowardsZero(x: number) {
-  const sign = x < 0 ? -1 : 1;
-  return sign * Math.floor(Math.abs(x));
-}

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,46 +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.info("[CallWithRetry Failed] attempt number=" + i, fn);
-          console.error(e);
-          await sleep(Math.min(retryInterval * 2 ** i + Math.random() * 100, 15000));
-        } else {
-          reject(e as unknown as Error);
-        }
-      }
-    }
-  };
-  process();
-  return promise;
-};

package/src/proxy.spec.ts

@@ -1,186 +0,0 @@
-import { runInAction } from "mobx";
-import { computed, observable } from "mobx";
-import { deferred } from "./deferred";
-import { cacheUntilReady } from "./proxy";
-
-describe("cacheUntilReady", () => {
-  describe("property access", () => {
-    it("should immediately relay simple property access to the computed target if it is ready", () => {
-      const target = computed(() => ({ a: 1 }));
-      const proxy = cacheUntilReady(target);
-      expect(proxy.a).toBe(1);
-      expect(proxy.proxied).toBe(false);
-    });
-
-    it("should immediately relay simple property access to the observable target if it is ready", () => {
-      const target = observable.box({ a: 1 });
-      const proxy = cacheUntilReady(target);
-      expect(proxy.a).toBe(1);
-      expect(proxy.proxied).toBe(false);
-    });
-
-    it("should immediately relay deep property access to the computed target if it is ready", () => {
-      const target = computed(() => ({ a: { b: { c: 2 } } }));
-      const proxy = cacheUntilReady(target);
-      expect(proxy.a.b.c).toBe(2);
-      expect(proxy.proxied).toBe(false);
-    });
-
-    it("should immediately relay deep property access to the observable target if it is ready", () => {
-      const target = observable.box({ a: { b: 2 } });
-      const proxy = cacheUntilReady(target);
-      expect(proxy.a.b).toBe(2);
-      expect(proxy.proxied).toBe(false);
-    });
-
-    it("should return undefined for property access if the target is not ready", () => {
-      const target = observable.box<{ a: { b: number } } | undefined>(undefined);
-      const proxy = cacheUntilReady(target);
-      const result1 = proxy.a;
-      const result2 = proxy.a.b;
-
-      expect(JSON.stringify(result1)).toBe(JSON.stringify({ proxied: true }));
-      expect(JSON.stringify(result2)).toBe(JSON.stringify({ proxied: true }));
-      expect(proxy.proxied).toBe(true);
-    });
-  });
-
-  describe("function calls", () => {
-    it("should immediately relay top level function calls to the computed target it if it ready", () => {
-      const target = computed(() => ({
-        a: () => 1,
-      }));
-
-      const proxy = cacheUntilReady(target);
-
-      expect(proxy.a()).toBe(1);
-    });
-
-    it("should immediately relay top level function calls to the observable target it if it ready", () => {
-      const target = observable.box({
-        a: () => 1,
-      });
-
-      const proxy = cacheUntilReady(target);
-
-      expect(proxy.a()).toBe(1);
-    });
-
-    it("should immediately relay deep nested function calls to the computed target it if it ready", () => {
-      const target = computed(() => ({
-        a: { b: () => 1 },
-      }));
-
-      const proxy = cacheUntilReady(target);
-
-      expect(proxy.a.b()).toBe(1);
-    });
-
-    it("should immediately relay deep nested function calls to the observable target it if it ready", () => {
-      const target = observable.box({
-        a: { b: () => 1 },
-      });
-
-      const proxy = cacheUntilReady(target);
-
-      expect(proxy.a.b()).toBe(1);
-    });
-
-    it("should chache top level function calls to the target until it is ready", async () => {
-      const target = observable.box<{ a: (n: number) => number } | undefined>(undefined);
-
-      const proxy = cacheUntilReady(target);
-
-      // Target is not ready yet, but function is called already
-      const result1 = proxy.a(1);
-      const result2 = proxy.a(2);
-
-      // Now target is ready
-      runInAction(() => target.set({ a: (n) => n }));
-
-      // Cached function calls are applied,
-      expect(await result1).toEqual(1);
-      expect(await result2).toEqual(2);
-    });
-
-    it("should chache nested function calls to the target until it is ready", async () => {
-      const target = observable.box<{ a: { b: (n: number) => number } } | undefined>(undefined);
-
-      const proxy = cacheUntilReady(target);
-
-      // Target is not ready yet, but function is called already
-      const result1 = proxy.a.b(1);
-      const result2 = proxy.a.b(2);
-
-      const getResult3 = async () => proxy.a.b((await result1) + (await result2));
-      const result3 = getResult3();
-
-      // Now target is ready
-      runInAction(() => target.set({ a: { b: (n) => n + 1 } }));
-
-      // Cached function calls are applied,
-      expect(await result1).toEqual(2);
-      expect(await result2).toEqual(3);
-      expect(await result3).toEqual(6);
-    });
-
-    it("should chache nested function calls without parameters to the target until it is ready", async () => {
-      const target = observable.box<{ a: { b: () => number } } | undefined>(undefined);
-
-      const proxy = cacheUntilReady(target);
-
-      // Target is not ready yet, but function is called already
-      const result1 = proxy.a.b();
-      const result2 = proxy.proxied && proxy.a.b();
-
-      // Now target is ready
-      runInAction(() => target.set({ a: { b: () => 1 } }));
-
-      // Cached function calls are applied,
-      expect(await result1).toEqual(1);
-      expect(await result2).toEqual(1);
-    });
-
-    it("should chache nested function calls with variable parameters to the target until it is ready", async () => {
-      const target = observable.box<{ a: { b: (...args: number[]) => number } } | undefined>(undefined);
-
-      const proxy = cacheUntilReady(target);
-
-      // Target is not ready yet, but function is called already
-      const result1 = proxy.a.b();
-      const result2 = proxy.a.b(1);
-      const result3 = proxy.a.b(1, 2);
-      const result4 = proxy.a.b(1, 2, 3);
-
-      // Now target is ready
-      runInAction(() => target.set({ a: { b: (...args) => args.reduce((acc, curr) => acc + curr, 0) } }));
-
-      // Cached function calls are applied,
-      expect(await result1).toEqual(0);
-      expect(await result2).toEqual(1);
-      expect(await result3).toEqual(3);
-      expect(await result4).toEqual(6);
-    });
-
-    it("should return a non-nested proxy if the called target function returns a proxy", async () => {
-      const target = observable.box<{ a: { b: () => Promise<number> } } | undefined>(undefined);
-
-      const proxy = cacheUntilReady(target);
-
-      // Target is not ready yet, but function is called already
-      const result1 = proxy.a.b();
-      const result2 = proxy.a.b();
-
-      const [resolve, , promise] = deferred<number>();
-      // Now target is ready
-      runInAction(() => target.set({ a: { b: () => promise } }));
-
-      // Now resolve the promise returned by the target function
-      resolve(1);
-
-      // Cached function calls are applied,
-      expect(await result1).toEqual(1);
-      expect(await result2).toEqual(1);
-    });
-  });
-});