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

package/src/uuid.ts

@@ -0,0 +1,70 @@
+/**
+ * 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/TableId.ts

@@ -0,0 +1,49 @@
+import { arrayToHex } from "./arrayToHex";
+import { bytesToString } from "./bytesToString";
+import { hexToArray } from "./hexToArray";
+import { stringToBytes16 } from "./stringToBytes";
+
+export class TableId {
+  namespace: string;
+  name: string;
+
+  constructor(namespace: string, name: string) {
+    this.namespace = namespace;
+    this.name = name;
+  }
+
+  toString() {
+    return `TableId<${this.namespace || "[empty]"}:${this.name || "[empty]"}>`;
+  }
+
+  toHexString() {
+    return TableId.toHexString(this.namespace, this.name);
+  }
+
+  static toHexString(namespace: string, name: string) {
+    const tableId = new Uint8Array(32);
+    tableId.set(stringToBytes16(namespace), 0);
+    tableId.set(stringToBytes16(name), 16);
+    return arrayToHex(tableId);
+  }
+
+  static fromHexString(tableId: string) {
+    return TableId.fromBytes32(hexToArray(tableId));
+  }
+
+  static fromBytes32(tableId: Uint8Array) {
+    const tableIdBytes = new Uint8Array(32);
+    tableIdBytes.set(tableId);
+    const namespace = bytesToString(tableIdBytes.slice(0, 16)).replace(/\0+$/, "");
+    const name = bytesToString(tableIdBytes.slice(16, 32)).replace(/\0+$/, "");
+    return new TableId(namespace, name);
+  }
+
+  /** @deprecated Don't use this! This is a temporary hack for v2<>v1 compatibility until we can write v2 client libraries. This is here so it stays close to the formatting of `toString()` above. */
+  static parse(tableIdString: string) {
+    const match = tableIdString.match(/^TableId<(.+?):(.+?)>$/);
+    if (!match) return null;
+    const [, namespace, name] = match;
+    return new TableId(namespace === "[empty]" ? "" : namespace, name === "[empty]" ? "" : name);
+  }
+}

package/src/v2/arrayToHex.ts

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

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

package/src/v2/getTableIds.ts

@@ -0,0 +1,10 @@
+import { TableId } from "./TableId";
+
+const STORE_SELECTOR_MAX_LENGTH = 16;
+
+export function getTableIds(config: { namespace: string; tables: { [key: string]: unknown } }) {
+  return Object.keys(config.tables).map(
+    (table) =>
+      new TableId(config.namespace.slice(0, STORE_SELECTOR_MAX_LENGTH), table.slice(0, STORE_SELECTOR_MAX_LENGTH))
+  );
+}

package/src/v2/hexToArray.ts

@@ -0,0 +1,12 @@
+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/{dist/v2/index.d.ts → src/v2/index.ts}

@@ -2,6 +2,8 @@ export * from "./arrayToHex";
 export * from "./bytesToString";
 export * from "./hexToArray";
 export * from "./isDefined";
+export * from "./isNotNull";
 export * from "./isHex";
-export * from "./stringToBytes16";
+export * from "./stringToBytes";
 export * from "./TableId";
+export * from "./getTableIds";

package/src/v2/isDefined.ts

@@ -0,0 +1,3 @@
+export function isDefined<T>(argument: T | undefined): argument is T {
+  return argument !== undefined;
+}

package/src/v2/isHex.ts

@@ -0,0 +1,6 @@
+// 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/isNotNull.ts

@@ -0,0 +1,3 @@
+export function isNotNull<T>(argument: T | null): argument is T {
+  return argument !== null;
+}

package/src/v2/stringToBytes.ts

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

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

package/dist/CoordMap.d.ts

@@ -1,26 +0,0 @@
-import { Coord } from "./types";
-export declare function subtract(from: CoordMap<boolean>, subtract: CoordMap<boolean>): CoordMap<boolean>;
-export declare function coordToKey(coord: Coord): number;
-export declare function keyToCoord(key: number): Coord;
-export declare class CoordMap<T> {
-    map: Map<number, T>;
-    defaultValue?: T;
-    constructor(props?: {
-        defaultValue?: T;
-    });
-    static from<T>(coordMapLike: {
-        map: Map<number, T>;
-        defaultValue?: T;
-    }): CoordMap<T>;
-    set(coord: Coord, value: T): Map<number, T>;
-    get(coord: Coord): T | undefined;
-    keys(): IterableIterator<number>;
-    coords(): IterableIterator<Coord>;
-    entries(): IterableIterator<[number, T]>;
-    toArray(): [Coord, T][];
-    values(): IterableIterator<T>;
-    delete(coord: Coord): boolean;
-    has(coord: Coord): boolean;
-    clear(): void;
-    get size(): number;
-}

package/dist/VoxelCoordMap.d.ts

@@ -1,23 +0,0 @@
-import { VoxelCoord } from "./types";
-export declare class VoxelCoordMap<T> {
-    map: Map<string, T>;
-    defaultValue?: T;
-    constructor(props?: {
-        defaultValue?: T;
-    });
-    static from<T>(coordMapLike: {
-        map: Map<string, T>;
-        defaultValue?: T;
-    }): VoxelCoordMap<T>;
-    set(coord: VoxelCoord, value: T): Map<string, T>;
-    get(coord: VoxelCoord): T | undefined;
-    keys(): IterableIterator<string>;
-    coords(): IterableIterator<VoxelCoord>;
-    entries(): IterableIterator<[string, T]>;
-    toArray(): [VoxelCoord, T][];
-    values(): IterableIterator<T>;
-    delete(coord: VoxelCoord): boolean;
-    has(coord: VoxelCoord): boolean;
-    clear(): void;
-    get size(): number;
-}

package/dist/area.d.ts

@@ -1,3 +0,0 @@
-import { Area, Coord } from "./types";
-export declare function areaContains(area: Area, coord: Coord): boolean;
-export declare function coordsOf(area: Area): Coord[];

package/dist/bytes.d.ts

@@ -1,10 +0,0 @@
-export declare function formatHex(hex: string): string;
-export declare function hexStringToUint8Array(hexString: string): Uint8Array;
-export declare function Uint8ArrayToHexString(data: Uint8Array): string;
-export declare function concatUint8Arrays(...arrays: Uint8Array[]): Uint8Array;
-export declare function splitUint8Arrays(data: Uint8Array, byteLengths: number[]): Uint8Array[];
-export declare function Int32ArrayToUint8Array(input: number[]): Uint8Array;
-export declare function Uint8ArrayToInt32Array(input: Uint8Array): number[];
-export declare function ethAddressToUint8Array(address: string): Uint8Array;
-export declare function createToInt(size: number): (value: number) => number;
-export declare const toInt32: (value: number) => number;

package/dist/console.d.ts

@@ -1,52 +0,0 @@
-/// <reference types="node" />
-/// <reference types="node" />
-export declare function enableLogger(): {
-    log: (...logs: string[]) => void;
-    logWithTopic: (topic: string, ...logs: string[]) => void;
-    enableFilters: () => void;
-    disableFilters: () => void;
-    addTopic: (topic: string) => void;
-    removeTopic: (topic: string) => void;
-    resetTopics: () => void;
-    assert(condition?: boolean | undefined, ...data: any[]): void;
-    assert(value: any, message?: string | undefined, ...optionalParams: any[]): void;
-    clear(): void;
-    clear(): void;
-    count(label?: string | undefined): void;
-    count(label?: string | undefined): void;
-    countReset(label?: string | undefined): void;
-    countReset(label?: string | undefined): void;
-    debug(...data: any[]): void;
-    debug(message?: any, ...optionalParams: any[]): void;
-    dir(item?: any, options?: any): void;
-    dir(obj: any, options?: import("util").InspectOptions | undefined): void;
-    dirxml(...data: any[]): void;
-    dirxml(...data: any[]): void;
-    error(...data: any[]): void;
-    error(message?: any, ...optionalParams: any[]): void;
-    group(...data: any[]): void;
-    group(...label: any[]): void;
-    groupCollapsed(...data: any[]): void;
-    groupCollapsed(...label: any[]): void;
-    groupEnd(): void;
-    groupEnd(): void;
-    info(...data: any[]): void;
-    info(message?: any, ...optionalParams: any[]): void;
-    table(tabularData?: any, properties?: string[] | undefined): void;
-    table(tabularData: any, properties?: readonly string[] | undefined): void;
-    time(label?: string | undefined): void;
-    time(label?: string | undefined): void;
-    timeEnd(label?: string | undefined): void;
-    timeEnd(label?: string | undefined): void;
-    timeLog(label?: string | undefined, ...data: any[]): void;
-    timeLog(label?: string | undefined, ...data: any[]): void;
-    timeStamp(label?: string | undefined): void;
-    timeStamp(label?: string | undefined): void;
-    trace(...data: any[]): void;
-    trace(message?: any, ...optionalParams: any[]): void;
-    warn(...data: any[]): void;
-    warn(message?: any, ...optionalParams: any[]): void;
-    Console: console.ConsoleConstructor;
-    profile(label?: string | undefined): void;
-    profileEnd(label?: string | undefined): void;
-};

package/dist/cubic.d.ts

@@ -1,32 +0,0 @@
-export declare function randomize(seed: number, x: number, y: number): number;
-export declare function tile(coordinate: number, period: number): number;
-export declare function interpolate(a: number, b: number, c: number, d: number, x: number, s: number, scale: number): number;
-/**
- * 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 declare function cubicNoiseConfig(seed: number, octave: number, scale: number, periodX?: number, periodY?: number): {
-    seed: number;
-    periodX: number;
-    periodY: number;
-    octave: number;
-    scale: number;
-};
-/**
- * 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 declare function cubicNoiseSample1(config: ReturnType<typeof cubicNoiseConfig>, x: number): number;
-/**
- * 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 declare function cubicNoiseSample2({ octave, periodX, periodY, seed, scale }: ReturnType<typeof cubicNoiseConfig>, x: number, y: number): number;

package/dist/deferred.d.ts

@@ -1,5 +0,0 @@
-/**
- * A convenient way to create a promise with resolve and reject functions.
- * @returns Tuple with resolve function, reject function and promise.
- */
-export declare function deferred<T>(): [(t: T) => void, (t: Error) => void, Promise<T>];

package/dist/distance.d.ts

@@ -1,8 +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 declare function euclidean(a: number[], b: number[]): number;

package/dist/enums.d.ts

@@ -1,5 +0,0 @@
-/**
- * @param enm Numeric enum
- * @returns Number array containing the enum values
- */
-export declare function numValues(enm: object): number[];

package/dist/eth.d.ts

@@ -1,22 +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 declare function padToBitLength(input: string, bits: number): string;
-/**
- * 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 declare function toEthAddress(input: string): string;
-/**
- * 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 declare function to256BitString(input: string): string;
-export declare function extractEncodedArguments(input: string): string;

package/dist/guards.d.ts

@@ -1,3 +0,0 @@
-import { Func } from "./types";
-export declare function isObject(c: unknown): c is Record<string, any>;
-export declare function isFunction(c: unknown): c is Func<any, any>;

package/dist/hash.d.ts

@@ -1,8 +0,0 @@
-import { Coord } from "./types";
-/**
- * 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 declare function keccak256(data: string): string;
-export declare function keccak256Coord(coord: Coord): string;

package/dist/iterable.d.ts

@@ -1,10 +0,0 @@
-export declare function makeIterable<T>(iterator: Iterator<T>): IterableIterator<T>;
-export declare function concatIterators<T>(first: Iterator<T>, second?: Iterator<T>): IterableIterator<T>;
-export declare function mergeIterators<A, B>(iteratorA: Iterator<A>, iteratorB: Iterator<B>): IterableIterator<[A, B]>;
-export declare function transformIterator<A, B>(iterator: Iterator<A>, transform: (value: A) => B): IterableIterator<B>;
-/**
- * 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 declare function arrayToIterator<T>(array: T[]): IterableIterator<T>;

package/dist/mobx.d.ts

@@ -1,6 +0,0 @@
-import { IComputedValue, IObservableValue } from "mobx";
-/**
- * @param comp Computed/Observable value that is either defined or undefined
- * @returns promise that resolves with the first truthy computed value
- */
-export declare function awaitValue<T>(comp: IComputedValue<T | undefined> | IObservableValue<T | undefined>): Promise<T>;

package/dist/objects.d.ts

@@ -1,11 +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 declare 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;

package/dist/pack.d.ts

@@ -1,16 +0,0 @@
-/**
- * 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 declare function pack(numbers: number[], bitsPerNumber: number[]): number;
-/**
- * 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 declare function unpack(packed: number, bitsPerNumber: number[]): number[];
-export declare function packTuple(numbers: [number, number]): number;
-export declare function unpackTuple(packed: number): [number, number];

package/dist/promise.d.ts

@@ -1,4 +0,0 @@
-export declare const range: (total?: number, step?: number, from?: number) => Generator<number, void, unknown>;
-export declare function rejectAfter<T>(ms: number, msg: string): Promise<T>;
-export declare const timeoutAfter: <T>(promise: Promise<T>, ms: number, timeoutMsg: string) => Promise<T>;
-export declare const callWithRetry: <T>(fn: (...args: any[]) => Promise<T>, args?: any[], maxRetries?: number, retryInterval?: number) => Promise<T>;

package/dist/proxy.d.ts

@@ -1,8 +0,0 @@
-import { IComputedValue, IObservableValue } from "mobx";
-import { Cached } from "./types";
-/**
- * Caches any function calls to the target until the target is ready.
- * @param target T extends Cachable
- * @returns Cached<T>
- */
-export declare function cacheUntilReady<T extends Record<string, any>>(target: IObservableValue<T | undefined> | IComputedValue<T | undefined>): Cached<T>;

package/dist/rx.d.ts

@@ -1,30 +0,0 @@
-import { Observable, OperatorFunction } from "rxjs";
-import { IComputedValue, IObservableValue } from "mobx";
-export declare function filterNullish<T>(): OperatorFunction<T, NonNullable<T>>;
-export declare function awaitPromise<T extends Promise<unknown>>(): 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 declare function stretch<T>(spacingDelayMs: number): import("rxjs").UnaryFunction<Observable<T>, Observable<T>>;
-export declare function observableToComputed<T>(obs: IObservableValue<T>): IComputedValue<T>;
-export declare function computedToStream<T>(comp: IComputedValue<T> | IObservableValue<T>): Observable<T>;
-export declare function observableToStream<T>(obs: T): Observable<T>;
-export declare function streamToComputed<T>(stream$: Observable<T>): IComputedValue<T | undefined>;
-export declare function streamToDefinedComputed<T>(stream$: Observable<T>): Promise<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 declare function awaitStreamValue<T>(stream$: Observable<T>, predicate?: (value: T) => boolean): Promise<T>;
-/**
- * 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 declare function streamToWrappedValue<T>(stream$: Observable<T>): Promise<{
-    current: T;
-}>;

package/dist/sleep.d.ts

@@ -1 +0,0 @@
-export declare function sleep<T>(timeout: number, returns?: T): Promise<T>;

package/dist/types.d.ts

@@ -1,40 +0,0 @@
-import { enableLogger } from "./console";
-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/dist/uuid.d.ts

@@ -1,19 +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
- */
-/**
- * Generates a version 4 UUID as a hexadecimal string.
- * @returns {string} Hexadecimal UUID string.
- */
-export declare const uuid: () => string;

package/dist/v2/TableId.d.ts

@@ -1,10 +0,0 @@
-export declare class TableId {
-    namespace: string;
-    name: string;
-    constructor(namespace: string, name: string);
-    toString(): string;
-    toHexString(): `0x${string}`;
-    static toHexString(namespace: string, name: string): `0x${string}`;
-    static fromHexString(tableId: string): TableId;
-    static fromBytes32(tableId: Uint8Array): TableId;
-}

package/dist/v2/arrayToHex.d.ts

@@ -1 +0,0 @@
-export declare const arrayToHex: (array: Uint8Array | ArrayBuffer) => `0x${string}`;

package/dist/v2/bytesToString.d.ts

@@ -1 +0,0 @@
-export declare const bytesToString: (bytes: Uint8Array) => string;

package/dist/v2/hexToArray.d.ts

@@ -1 +0,0 @@
-export declare const hexToArray: (hex: string) => Uint8Array;

package/dist/v2/isDefined.d.ts

@@ -1 +0,0 @@
-export declare function isDefined<T>(argument: T | undefined): argument is T;

package/dist/v2/isHex.d.ts

@@ -1 +0,0 @@
-export declare function isHex(hex: string): boolean;

package/dist/v2/stringToBytes16.d.ts

@@ -1 +0,0 @@
-export declare const stringToBytes16: (str: string) => Uint8Array;

package/dist/worker.d.ts

@@ -1,6 +0,0 @@
-import { Observable } from "rxjs";
-export interface DoWork<In, Out> {
-    work(input$: Observable<In>): Observable<Out>;
-}
-export declare function fromWorker<I, O>(worker: Worker, input$: Observable<I>): Observable<O>;
-export declare function runWorker<I, O>(worker: DoWork<I, O>): void;