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

package/src/proxy.ts

@@ -1,101 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { IComputedValue, IObservableValue, reaction } from "mobx";
-import DeepProxy from "proxy-deep";
-import { deferred } from "./deferred";
-import { isFunction, isObject } from "./guards";
-import { Cached } from "./types";
-
-function deepAccess(target: Record<string, unknown>, path: string[]): any {
-  if (path.length === 0) return target;
-  if (path.length === 1) return target[path[0]];
-  const [next, ...rest] = path;
-  const nextTarget = target[next];
-  if (!isObject(nextTarget)) throw new Error("Path does not exist on the target");
-  return deepAccess(nextTarget, rest);
-}
-
-/**
- * Caches any function calls to the target until the target is ready.
- * @param target T extends Cachable
- * @returns Cached<T>
- */
-export function cacheUntilReady<T extends Record<string, any>>(
-  target: IObservableValue<T | undefined> | IComputedValue<T | undefined>,
-): Cached<T> {
-  // The call queue contains the path and arguments of calls to the
-  // proxiedTarget while the target was not available yet.
-  // It also contains resolve and reject methods to fulfil the promise
-  // returned when calling the proxiedTarget once the target becomes available.
-  const callQueue: {
-    path: string[];
-    args?: any[];
-    resolve: (result: any) => void;
-    reject: (e: Error) => void;
-  }[] = [];
-
-  // The proxiedTarget proxies all calls to the target.
-  // If a function is called on the proxiedTarget while the target is not
-  // available, a promise is returned and the call will be stored in the callQueue
-  // until the target becomes available and the promise is fulfilled.
-  const proxiedTarget = new DeepProxy(
-    {},
-    {
-      get(_t, prop) {
-        const targetReady = target.get();
-        if (targetReady) {
-          // If the target is ready, relay all calls directly to the target
-          // (Except for the "proxied" key, which indicates whether the object is currently proxied)
-          if (prop === "proxied") return false;
-          return Reflect.get(targetReady, prop);
-        } else {
-          // Note: if the target is not available, accessing a property returns another proxy,
-          // not a Promise. It is possible to check whether a value is currently proxied using the proxied key.
-          if (prop === "proxied") return true;
-          if (prop === "name") return "ProxiedTarget";
-          if (prop === "toJSON") return () => ({ proxied: true });
-          return this.nest(() => void 0);
-        }
-      },
-      apply(_, thisArg, args) {
-        const targetReady = target.get();
-        if (targetReady) {
-          // If the target is ready, relay all calls directly to the target
-          const targetFunc = deepAccess(targetReady, this.path);
-          if (!isFunction(targetFunc)) throw new Error("Target is not callable");
-          return Reflect.apply(targetFunc, thisArg, args);
-        } else {
-          // Otherwise store the call and relay it to the target later once it's ready.
-          // The return value of this call is a promise, that gets resolved once the target is ready.
-          const [resolve, reject, promise] = deferred();
-          callQueue.push({ path: this.path, args, resolve, reject });
-          return promise;
-        }
-      },
-    },
-  );
-
-  reaction(
-    () => target.get(),
-    (targetReady) => {
-      if (!targetReady) return;
-      // Move all entries from callQueue to queuedCalls
-      const queuedCalls = callQueue.splice(0);
-      for (const { path, args, resolve, reject } of queuedCalls) {
-        const target = deepAccess(targetReady, path);
-        if (args && isFunction(target)) {
-          (async () => {
-            try {
-              resolve(await target(...args));
-            } catch (e: any) {
-              reject(e);
-            }
-          })();
-        } else {
-          resolve(target);
-        }
-      }
-    },
-  );
-
-  return proxiedTarget as Cached<T>;
-}

package/src/random.ts

@@ -1,17 +0,0 @@
-/**
- *
- * @param to Upper bound (included)
- * @param from Lower bound (included). Default 0.
- * @returns A random integer between from and to.
- */
-export function random(to: number, from = 0): number {
-  return Math.floor(Math.random() * (to - from + 1)) + from;
-}
-
-/**
- * @param array Array to pick a random element from.
- * @returns Random element from the given array.
- */
-export function pickRandom<T>(array: [T, ...T[]]): T {
-  return array[random(array.length - 1)];
-}

package/src/rx.spec.ts

@@ -1,45 +0,0 @@
-import { Subject } from "rxjs";
-import { awaitStreamValue, streamToComputed } from "./rx";
-import { sleep } from "./sleep";
-
-describe("streamToComputed", () => {
-  it("should return a computed value that corresponds to the last stream value", () => {
-    const stream = new Subject<number>();
-    const comp = streamToComputed(stream);
-    expect(comp.get()).toBeUndefined();
-
-    stream.next(1);
-    expect(comp.get()).toBe(1);
-
-    stream.next(2);
-    expect(comp.get()).toBe(2);
-
-    stream.next(3);
-    stream.next(4);
-    expect(comp.get()).toBe(4);
-  });
-});
-
-describe("awaitStreamValue", () => {
-  it("should return a promise that resolves once the requested stream value is emitted", async () => {
-    const stream = new Subject<number>();
-    const promise = awaitStreamValue(stream, (v) => v === 1);
-
-    let isFulfilled = false;
-    (async () => {
-      await promise;
-      isFulfilled = true;
-    })();
-
-    await sleep(100);
-    expect(isFulfilled).toBe(false);
-
-    stream.next(2);
-    await sleep(100);
-    expect(isFulfilled).toBe(false);
-
-    stream.next(1);
-    await sleep(100);
-    expect(isFulfilled).toBe(true);
-  });
-});

package/src/rx.ts

@@ -1,124 +0,0 @@
-import {
-  concatMap,
-  delay,
-  filter,
-  first,
-  mergeMap,
-  Observable,
-  of,
-  OperatorFunction,
-  pipe,
-  ReplaySubject,
-  scan,
-  Timestamp,
-  timestamp,
-} from "rxjs";
-import { computed, IComputedValue, IObservableValue, observable, reaction, runInAction, toJS } from "mobx";
-import { deferred } from "./deferred";
-import { awaitValue } from "./mobx";
-
-export function filterNullish<T>(): OperatorFunction<T, NonNullable<T>> {
-  return pipe<Observable<T>, Observable<NonNullable<T>>>(
-    filter<T>((x: T) => x != null) as OperatorFunction<T, NonNullable<T>>,
-  );
-}
-
-export function awaitPromise<T extends Promise<unknown>>(): OperatorFunction<T, Awaited<T>> {
-  return pipe(concatMap((x: T) => x)) as OperatorFunction<T, Awaited<T>>;
-}
-
-/**
- * RxJS operator to stretch out an event stream by a given delay per event
- * @param spacingDelayMs Delay between each event in ms
- * @returns stream of events with at least spacingDelayMs spaceing between event
- */
-export function stretch<T>(spacingDelayMs: number) {
-  return pipe(
-    timestamp<T>(),
-    scan((acc: (Timestamp<T> & { delay: number }) | null, curr: Timestamp<T>) => {
-      // calculate delay needed to offset next emission
-      let delay = 0;
-      if (acc !== null) {
-        const timeDelta = curr.timestamp - acc.timestamp;
-        delay = timeDelta > spacingDelayMs ? 0 : spacingDelayMs - timeDelta;
-      }
-
-      return {
-        timestamp: curr.timestamp,
-        delay: delay,
-        value: curr.value,
-      };
-    }, null),
-    filterNullish(),
-    mergeMap((i) => of(i.value).pipe(delay(i.delay)), 1),
-  );
-}
-
-export function observableToComputed<T>(obs: IObservableValue<T>): IComputedValue<T> {
-  return computed(() => obs.get());
-}
-
-export function computedToStream<T>(comp: IComputedValue<T> | IObservableValue<T>): Observable<T> {
-  const stream = new ReplaySubject<T>(1);
-  reaction(
-    () => comp.get(),
-    (value) => {
-      if (value != null) stream.next(value);
-    },
-    { fireImmediately: true },
-  );
-  return stream;
-}
-
-export function observableToStream<T>(obs: T): Observable<T> {
-  const stream = new ReplaySubject<T>(1);
-  reaction(
-    () => toJS(obs),
-    (value) => {
-      if (value != null) stream.next(value);
-    },
-    { fireImmediately: true },
-  );
-  return stream;
-}
-
-export function streamToComputed<T>(stream$: Observable<T>): IComputedValue<T | undefined> {
-  const value = observable.box<T | undefined>();
-  stream$.subscribe((val) => runInAction(() => value.set(val)));
-  return computed(() => value.get());
-}
-
-export async function streamToDefinedComputed<T>(stream$: Observable<T>): Promise<IComputedValue<T>> {
-  const value = observable.box<T>();
-  stream$.subscribe((val) => runInAction(() => value.set(val)));
-  const computedValue = computed(() => value.get());
-  await awaitValue(computedValue);
-  return computedValue as IComputedValue<T>;
-}
-
-/**
- *
- * @param stream$ RxJS observable to check for the given value
- * @param predicate Predicate to check
- * @returns A promise that resolves with the requested value once the predicate is true
- */
-export async function awaitStreamValue<T>(
-  stream$: Observable<T>,
-  predicate: (value: T) => boolean = (value) => value != null,
-): Promise<T> {
-  const [resolve, , promise] = deferred<T>();
-  stream$.pipe(first(predicate)).subscribe(resolve);
-  return promise;
-}
-
-/**
- * Turns a stream into an updating object for easy access outside of rxjs
- * @param stream$ Stream to turn into a wrapped value
- * @returns Object with `current` key corresponding to last stream value
- */
-export async function streamToWrappedValue<T>(stream$: Observable<T>): Promise<{ current: T }> {
-  const value: { current?: T } = {};
-  stream$.subscribe((v) => (value.current = v));
-  value.current = await awaitStreamValue(stream$);
-  return value as { current: T };
-}

package/src/sleep.ts

@@ -1,3 +0,0 @@
-export function sleep<T>(timeout: number, returns?: T): Promise<T> {
-  return new Promise<T>((resolve) => setTimeout(() => resolve(returns as T), timeout));
-}

package/src/types.ts

@@ -1,48 +0,0 @@
-import { enableLogger } from "./console";
-
-/* eslint-disable @typescript-eslint/no-explicit-any */
-export type Func<A extends any[], R> = (...args: A) => R;
-export type AsyncFunc<A extends any[], R> = R extends Promise<unknown> ? (...args: A) => R : (...args: A) => Promise<R>;
-
-export type CachedValue<V, Proxied extends boolean> = Proxied extends true
-  ? V extends Func<infer A, infer B>
-    ? AsyncFunc<A, B>
-    : V extends Record<string, any>
-      ? Cached<V> & { proxied: true }
-      : { proxied: true }
-  : V extends Func<infer A, infer B>
-    ? Func<A, B>
-    : V extends Record<string, any>
-      ? V
-      : V & { proxied: false };
-
-export type Cached<C> =
-  | ({ proxied: false } & { [key in keyof C]: CachedValue<C[key], false> })
-  | ({ proxied: true } & { [key in keyof C]: CachedValue<C[key], true> });
-
-/**
- * @deprecated Use Awaited<T> instead
- */
-export type PromiseValue<T> = Awaited<T>;
-
-export type ValueOf<T extends object> = T[keyof T];
-
-export type Area = {
-  x: number;
-  y: number;
-  width: number;
-  height: number;
-};
-
-export type Coord = {
-  x: number;
-  y: number;
-};
-
-export type VoxelCoord = {
-  x: number;
-  y: number;
-  z: number;
-};
-
-export type Logger = ReturnType<typeof enableLogger>;

package/src/uuid.ts

@@ -1,70 +0,0 @@
-/**
- * UUID.core.js - UUID.js for Minimalists
- *
- * @file
- * @author  LiosK
- * @version v4.2.0
- * @license Apache License 2.0: Copyright (c) 2010-2018 LiosK
- * @url https://github.com/LiosK/UUID.js/blob/master/src/uuid.core.js
- */
-
-/**
- * @class
- * @classdesc {@link UUID} object.
- * @hideconstructor
- */
-
-// Core Component {{{
-
-/**
- * Generates a version 4 UUID as a hexadecimal string.
- * @returns {string} Hexadecimal UUID string.
- */
-export const uuid = function () {
-  const rand = _getRandomInt,
-    hex = _hexAligner;
-  return (
-    hex(rand(32), 8) + // time_low
-    "-" +
-    hex(rand(16), 4) + // time_mid
-    "-" +
-    hex(0x4000 | rand(12), 4) + // time_hi_and_version
-    "-" +
-    hex(0x8000 | rand(14), 4) + // clock_seq_hi_and_reserved clock_seq_low
-    "-" +
-    hex(rand(48), 12)
-  ); // node
-};
-
-/**
- * Returns an unsigned x-bit random integer.
- * @private
- * @param {number} x Unsigned integer ranging from 0 to 53, inclusive.
- * @returns {number} Unsigned x-bit random integer (0 <= f(x) < 2^x).
- */
-const _getRandomInt = function (x: number) {
-  if (x < 0 || x > 53) {
-    return NaN;
-  }
-  const n = 0 | (Math.random() * 0x40000000); // 1 << 30
-  return x > 30 ? n + (0 | (Math.random() * (1 << (x - 30)))) * 0x40000000 : n >>> (30 - x);
-};
-
-/**
- * Converts an integer to a zero-filled hexadecimal string.
- * @private
- * @param {number} num
- * @param {number} length
- * @returns {string}
- */
-const _hexAligner = function (num: number, length: number) {
-  let str = num.toString(16),
-    i = length - str.length,
-    z = "0";
-  for (; i > 0; i >>>= 1, z += z) {
-    if (i & 1) {
-      str = z + str;
-    }
-  }
-  return str;
-};

package/src/v2/arrayToHex.ts

@@ -1,3 +0,0 @@
-// TODO: migrate to viem's toHex()
-export const arrayToHex = (array: Uint8Array | ArrayBuffer): `0x${string}` =>
-  `0x${[...new Uint8Array(array)].map((x) => x.toString(16).padStart(2, "0")).join("")}`;

package/src/v2/bytesToString.ts

@@ -1 +0,0 @@
-export const bytesToString = (bytes: Uint8Array): string => [...bytes].map((x) => String.fromCharCode(x)).join("");

package/src/v2/hexToArray.ts

@@ -1,12 +0,0 @@
-import { isHex } from "./isHex";
-
-// TODO: migrate to viem's toBytes(hex)
-export const hexToArray = (hex: string): Uint8Array => {
-  if (!isHex(hex)) {
-    console.error("Invalid hex string", hex);
-    throw new Error("Invalid hex string");
-  }
-  const bytes = hex.match(/[\da-f]{2}/gi);
-  if (!bytes) return new Uint8Array([]);
-  return new Uint8Array(bytes.map((byte) => parseInt(byte, 16)));
-};

package/src/v2/index.ts

@@ -1,5 +0,0 @@
-export * from "./arrayToHex";
-export * from "./bytesToString";
-export * from "./hexToArray";
-export * from "./isHex";
-export * from "./stringToBytes";

package/src/v2/isHex.ts

@@ -1,6 +0,0 @@
-// TODO: migrate to viem's isHex()
-// Note that this assumes hex pairs, but viem does not. We'll need to be careful migrating.
-// Padding an odd-length hex sounds scary (based on how Solidity left/right aligns numbers vs bytes/strings).
-export function isHex(hex: string): boolean {
-  return /^(0x)?([\da-f]{2})*$/i.test(hex);
-}

package/src/v2/stringToBytes.ts

@@ -1,9 +0,0 @@
-export const stringToBytes16 = (str: string): Uint8Array => {
-  if (str.length > 16) throw new Error("string too long");
-  return new Uint8Array(16).map((v, i) => str.charCodeAt(i));
-};
-
-export const stringToBytes32 = (str: string): Uint8Array => {
-  if (str.length > 32) throw new Error("string too long");
-  return new Uint8Array(32).map((v, i) => str.charCodeAt(i));
-};

package/src/worker.ts

@@ -1,16 +0,0 @@
-import { fromEvent, map, Observable } from "rxjs";
-
-export interface DoWork<In, Out> {
-  work(input$: Observable<In>): Observable<Out>;
-}
-
-export function fromWorker<I, O>(worker: Worker, input$: Observable<I>): Observable<O> {
-  input$.subscribe((event) => worker.postMessage(event));
-  return fromEvent<MessageEvent<O>>(worker, "message").pipe(map((e) => e.data));
-}
-
-export function runWorker<I, O>(worker: DoWork<I, O>) {
-  const input$ = fromEvent<MessageEvent<I>>(self, "message");
-  const output$ = worker.work(input$.pipe(map((event) => event.data)));
-  output$.subscribe((event) => self.postMessage(event));
-}