@latticexyz/utils 0.10.0 → 0.11.1

package/CHANGELOG.md

@@ -3,6 +3,16 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [0.11.1](https://github.com/latticexyz/mud/compare/v0.11.0...v0.11.1) (2022-09-15)
+
+### Bug Fixes
+
+- do not run prepack multiple times when publishing ([4f6f4c3](https://github.com/latticexyz/mud/commit/4f6f4c35a53c105951b32a071e47a748b2502cda))
+
+# [0.11.0](https://github.com/latticexyz/mud/compare/v0.10.0...v0.11.0) (2022-09-15)
+
+**Note:** Version bump only for package @latticexyz/utils
+
 # [0.10.0](https://github.com/latticexyz/mud/compare/v0.9.0...v0.10.0) (2022-09-14)
 
 ### Features

package/dist/CoordMap.d.ts

@@ -0,0 +1,26 @@
+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/area.d.ts

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

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

@@ -3,17 +3,11 @@
  * @param array Any array to check for non-emptiness
  * @returns True if the empty is non-empty, else false. TypeScript accepts the array as non-empty after the assertion.
  */
-export function isNotEmpty<T>(array: T[]): array is [T, ...T[]] {
-  if (array.length === 0) return false;
-  return true;
-}
-
+export declare function isNotEmpty<T>(array: T[]): array is [T, ...T[]];
 /**
  * Filters undefined values from an array and lets TypeScript know the resulting array
  * does not have undefined values
  * @param array Array potentially including undefined values
  * @returns Array without undefined values
  */
-export function filterNullishValues<T>(array: (T | undefined)[]): T[] {
-  return array.filter((value) => value != null) as T[];
-}
+export declare function filterNullishValues<T>(array: (T | undefined)[]): T[];

package/dist/console.d.ts

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

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

@@ -0,0 +1,5 @@
+/**
+ * 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/{src/distance.ts → dist/distance.d.ts}

@@ -5,6 +5,4 @@
  * @param b
  * @returns Euclidian distance between a and b
  */
-export function euclidean(a: [number, number], b: [number, number]): number {
-  return Math.sqrt(Math.pow(a[0] - b[0], 2) + Math.pow(a[1] - b[1], 2));
-}
+export declare function euclidean(a: [number, number], b: [number, number]): number;

package/dist/enums.d.ts

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

package/dist/eth.d.ts

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

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

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

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

@@ -21,16 +21,4 @@ export * from "./cubic";
 export * from "./console";
 export * from "./distance";
 export * from "./math";
-
-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";