@metamask/utils 1.0.0

package/CHANGELOG.md

@@ -0,0 +1,14 @@
+# Changelog
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [1.0.0]
+### Added
+- Initial release
+
+[Unreleased]: https://github.com/MetaMask/utils/compare/v1.0.0...HEAD
+[1.0.0]: https://github.com/MetaMask/utils/releases/tag/v1.0.0

package/LICENSE

@@ -0,0 +1,15 @@
+ISC License
+
+Copyright (c) 2022 MetaMask
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

package/README.md

@@ -0,0 +1,73 @@
+# MetaMask Utils
+
+Various JavaScript/TypeScript utilities of wide relevance to the MetaMask codebase.
+
+## Installation
+
+`yarn add @metamask/utils`
+
+or
+
+`npm install @metamask/utils`
+
+## API
+
+The full API documentation for the latest published version of this library is [available here](https://metamask.github.io/eth-sig-util/index.html).
+
+## Contributing
+
+### Setup
+
+- Install [Node.js](https://nodejs.org) version 12
+  - If you are using [nvm](https://github.com/creationix/nvm#installation) (recommended) running `nvm use` will automatically choose the right node version for you.
+- Install [Yarn v1](https://yarnpkg.com/en/docs/install)
+- Run `yarn setup` to install dependencies and run any requried post-install scripts
+  - **Warning:** Do not use the `yarn` / `yarn install` command directly. Use `yarn setup` instead. The normal install command will skip required post-install scripts, leaving your development environment in an invalid state.
+
+### Testing and Linting
+
+Run `yarn test` to run the tests once. To run tests on file changes, run `yarn test:watch`.
+
+Run `yarn lint` to run the linter, or run `yarn lint:fix` to run the linter and fix any automatically fixable issues.
+
+### Documentation
+
+The API documentation can be generated with the command `yarn docs`, which saves it in the `./docs` directory. Open the `./docs/index.html` file to browse the documentation.
+
+### Release & Publishing
+
+The project follows the same release process as the other libraries in the MetaMask organization. The GitHub Actions [`action-create-release-pr`](https://github.com/MetaMask/action-create-release-pr) and [`action-publish-release`](https://github.com/MetaMask/action-publish-release) are used to automate the release process; see those repositories for more information about how they work.
+
+1. Choose a release version.
+
+   - The release version should be chosen according to SemVer. Analyze the changes to see whether they include any breaking changes, new features, or deprecations, then choose the appropriate SemVer version. See [the SemVer specification](https://semver.org/) for more information.
+
+2. If this release is backporting changes onto a previous release, then ensure there is a major version branch for that version (e.g. `1.x` for a `v1` backport release).
+
+   - The major version branch should be set to the most recent release with that major version. For example, when backporting a `v1.0.2` release, you'd want to ensure there was a `1.x` branch that was set to the `v1.0.1` tag.
+
+3. Trigger the [`workflow_dispatch`](https://docs.github.com/en/actions/reference/events-that-trigger-workflows#workflow_dispatch) event [manually](https://docs.github.com/en/actions/managing-workflow-runs/manually-running-a-workflow) for the `Create Release Pull Request` action to create the release PR.
+
+   - For a backport release, the base branch should be the major version branch that you ensured existed in step 2. For a normal release, the base branch should be the main branch for that repository (which should be the default value).
+   - This should trigger the [`action-create-release-pr`](https://github.com/MetaMask/action-create-release-pr) workflow to create the release PR.
+
+4. Update the changelog to move each change entry into the appropriate change category ([See here](https://keepachangelog.com/en/1.0.0/#types) for the full list of change categories, and the correct ordering), and edit them to be more easily understood by users of the package.
+
+   - Generally any changes that don't affect consumers of the package (e.g. lockfile changes or development environment changes) are omitted. Exceptions may be made for changes that might be of interest despite not having an effect upon the published package (e.g. major test improvements, security improvements, improved documentation, etc.).
+   - Try to explain each change in terms that users of the package would understand (e.g. avoid referencing internal variables/concepts).
+   - Consolidate related changes into one change entry if it makes it easier to explain.
+   - Run `yarn auto-changelog validate --rc` to check that the changelog is correctly formatted.
+
+5. Review and QA the release.
+
+   - If changes are made to the base branch, the release branch will need to be updated with these changes and review/QA will need to restart again. As such, it's probably best to avoid merging other PRs into the base branch while review is underway.
+
+6. Squash & Merge the release.
+
+   - This should trigger the [`action-publish-release`](https://github.com/MetaMask/action-publish-release) workflow to tag the final release commit and publish the release on GitHub.
+
+7. Publish the release on npm.
+
+   - Be very careful to use a clean local environment to publish the release, and follow exactly the same steps used during CI.
+   - Use `npm publish --dry-run` to examine the release contents to ensure the correct files are included. Compare to previous releases if necessary (e.g. using `https://unpkg.com/browse/[package name]@[package version]/`).
+   - Once you are confident the release contents are correct, publish the release using `npm publish`.

package/dist/collections.d.ts

@@ -0,0 +1,38 @@
+/**
+ * A {@link ReadonlyMap} that cannot be modified after instantiation.
+ * The implementation uses an inner map hidden via a private field, and the
+ * immutability guarantee relies on it being impossible to get a reference
+ * to this map.
+ */
+declare class FrozenMap<Key, Value> implements ReadonlyMap<Key, Value> {
+    #private;
+    get size(): number;
+    [Symbol.iterator](): IterableIterator<[Key, Value]>;
+    constructor(entries?: readonly (readonly [Key, Value])[] | null);
+    entries(): IterableIterator<[Key, Value]>;
+    forEach(callbackfn: (value: Value, key: Key, map: this) => void, thisArg?: any): void;
+    get(key: Key): Value | undefined;
+    has(key: Key): boolean;
+    keys(): IterableIterator<Key>;
+    values(): IterableIterator<Value>;
+    toString(): string;
+}
+/**
+ * A {@link ReadonlySet} that cannot be modified after instantiation.
+ * The implementation uses an inner set hidden via a private field, and the
+ * immutability guarantee relies on it being impossible to get a reference
+ * to this set.
+ */
+declare class FrozenSet<Value> implements ReadonlySet<Value> {
+    #private;
+    get size(): number;
+    [Symbol.iterator](): IterableIterator<Value>;
+    constructor(values?: readonly Value[] | null);
+    entries(): IterableIterator<[Value, Value]>;
+    forEach(callbackfn: (value: Value, value2: Value, set: this) => void, thisArg?: any): void;
+    has(value: Value): boolean;
+    keys(): IterableIterator<Value>;
+    values(): IterableIterator<Value>;
+    toString(): string;
+}
+export { FrozenMap, FrozenSet };

package/dist/collections.js

@@ -0,0 +1,111 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, privateMap, value) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to set private field on non-instance");
+    }
+    privateMap.set(receiver, value);
+    return value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, privateMap) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to get private field on non-instance");
+    }
+    return privateMap.get(receiver);
+};
+var _map_1, _set_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FrozenSet = exports.FrozenMap = void 0;
+/**
+ * A {@link ReadonlyMap} that cannot be modified after instantiation.
+ * The implementation uses an inner map hidden via a private field, and the
+ * immutability guarantee relies on it being impossible to get a reference
+ * to this map.
+ */
+class FrozenMap {
+    constructor(entries) {
+        _map_1.set(this, void 0);
+        __classPrivateFieldSet(this, _map_1, new Map(entries));
+        Object.freeze(this);
+    }
+    get size() {
+        return __classPrivateFieldGet(this, _map_1).size;
+    }
+    [(_map_1 = new WeakMap(), Symbol.iterator)]() {
+        return __classPrivateFieldGet(this, _map_1)[Symbol.iterator]();
+    }
+    entries() {
+        return __classPrivateFieldGet(this, _map_1).entries();
+    }
+    forEach(callbackfn, thisArg) {
+        // We have to wrap the specified callback in order to prevent it from
+        // receiving a reference to the inner map.
+        return __classPrivateFieldGet(this, _map_1).forEach((value, key, _map) => callbackfn.call(thisArg, value, key, this));
+    }
+    get(key) {
+        return __classPrivateFieldGet(this, _map_1).get(key);
+    }
+    has(key) {
+        return __classPrivateFieldGet(this, _map_1).has(key);
+    }
+    keys() {
+        return __classPrivateFieldGet(this, _map_1).keys();
+    }
+    values() {
+        return __classPrivateFieldGet(this, _map_1).values();
+    }
+    toString() {
+        return `FrozenMap(${this.size}) {${this.size > 0
+            ? ` ${[...this.entries()]
+                .map(([key, value]) => `${String(key)} => ${String(value)}`)
+                .join(', ')} `
+            : ''}}`;
+    }
+}
+exports.FrozenMap = FrozenMap;
+/**
+ * A {@link ReadonlySet} that cannot be modified after instantiation.
+ * The implementation uses an inner set hidden via a private field, and the
+ * immutability guarantee relies on it being impossible to get a reference
+ * to this set.
+ */
+class FrozenSet {
+    constructor(values) {
+        _set_1.set(this, void 0);
+        __classPrivateFieldSet(this, _set_1, new Set(values));
+        Object.freeze(this);
+    }
+    get size() {
+        return __classPrivateFieldGet(this, _set_1).size;
+    }
+    [(_set_1 = new WeakMap(), Symbol.iterator)]() {
+        return __classPrivateFieldGet(this, _set_1)[Symbol.iterator]();
+    }
+    entries() {
+        return __classPrivateFieldGet(this, _set_1).entries();
+    }
+    forEach(callbackfn, thisArg) {
+        // We have to wrap the specified callback in order to prevent it from
+        // receiving a reference to the inner set.
+        return __classPrivateFieldGet(this, _set_1).forEach((value, value2, _set) => callbackfn.call(thisArg, value, value2, this));
+    }
+    has(value) {
+        return __classPrivateFieldGet(this, _set_1).has(value);
+    }
+    keys() {
+        return __classPrivateFieldGet(this, _set_1).keys();
+    }
+    values() {
+        return __classPrivateFieldGet(this, _set_1).values();
+    }
+    toString() {
+        return `FrozenSet(${this.size}) {${this.size > 0
+            ? ` ${[...this.values()].map((member) => String(member)).join(', ')} `
+            : ''}}`;
+    }
+}
+exports.FrozenSet = FrozenSet;
+Object.freeze(FrozenMap);
+Object.freeze(FrozenMap.prototype);
+Object.freeze(FrozenSet);
+Object.freeze(FrozenSet.prototype);
+//# sourceMappingURL=collections.js.map

package/dist/collections.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"collections.js","sourceRoot":"","sources":["../src/collections.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * A {@link ReadonlyMap} that cannot be modified after instantiation.\n * The implementation uses an inner map hidden via a private field, and the\n * immutability guarantee relies on it being impossible to get a reference\n * to this map.\n */\nclass FrozenMap<Key, Value> implements ReadonlyMap<Key, Value> {\n  readonly #map: Map<Key, Value>;\n\n  public get size() {\n    return this.#map.size;\n  }\n\n  public [Symbol.iterator]() {\n    return this.#map[Symbol.iterator]();\n  }\n\n  constructor(entries?: readonly (readonly [Key, Value])[] | null) {\n    this.#map = new Map<Key, Value>(entries);\n    Object.freeze(this);\n  }\n\n  public entries() {\n    return this.#map.entries();\n  }\n\n  public forEach(\n    callbackfn: (value: Value, key: Key, map: this) => void,\n    thisArg?: any,\n  ): void {\n    // We have to wrap the specified callback in order to prevent it from\n    // receiving a reference to the inner map.\n    return this.#map.forEach((value: Value, key: Key, _map: unknown) =>\n      callbackfn.call(thisArg, value, key, this),\n    );\n  }\n\n  public get(key: Key) {\n    return this.#map.get(key);\n  }\n\n  public has(key: Key) {\n    return this.#map.has(key);\n  }\n\n  public keys() {\n    return this.#map.keys();\n  }\n\n  public values() {\n    return this.#map.values();\n  }\n\n  public toString(): string {\n    return `FrozenMap(${this.size}) {${\n      this.size > 0\n        ? ` ${[...this.entries()]\n            .map(([key, value]) => `${String(key)} => ${String(value)}`)\n            .join(', ')} `\n        : ''\n    }}`;\n  }\n}\n\n/**\n * A {@link ReadonlySet} that cannot be modified after instantiation.\n * The implementation uses an inner set hidden via a private field, and the\n * immutability guarantee relies on it being impossible to get a reference\n * to this set.\n */\nclass FrozenSet<Value> implements ReadonlySet<Value> {\n  readonly #set: Set<Value>;\n\n  public get size() {\n    return this.#set.size;\n  }\n\n  public [Symbol.iterator]() {\n    return this.#set[Symbol.iterator]();\n  }\n\n  constructor(values?: readonly Value[] | null) {\n    this.#set = new Set<Value>(values);\n    Object.freeze(this);\n  }\n\n  public entries() {\n    return this.#set.entries();\n  }\n\n  public forEach(\n    callbackfn: (value: Value, value2: Value, set: this) => void,\n    thisArg?: any,\n  ): void {\n    // We have to wrap the specified callback in order to prevent it from\n    // receiving a reference to the inner set.\n    return this.#set.forEach((value: Value, value2: Value, _set: unknown) =>\n      callbackfn.call(thisArg, value, value2, this),\n    );\n  }\n\n  public has(value: Value) {\n    return this.#set.has(value);\n  }\n\n  public keys() {\n    return this.#set.keys();\n  }\n\n  public values() {\n    return this.#set.values();\n  }\n\n  public toString(): string {\n    return `FrozenSet(${this.size}) {${\n      this.size > 0\n        ? ` ${[...this.values()].map((member) => String(member)).join(', ')} `\n        : ''\n    }}`;\n  }\n}\n\nObject.freeze(FrozenMap);\nObject.freeze(FrozenMap.prototype);\n\nObject.freeze(FrozenSet);\nObject.freeze(FrozenSet.prototype);\n\nexport { FrozenMap, FrozenSet };\n"]}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './json';
+export * from './misc';
+export * from './time';

package/dist/index.js

@@ -0,0 +1,16 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./json"), exports);
+__exportStar(require("./misc"), exports);
+__exportStar(require("./time"), exports);
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,yCAAuB;AACvB,yCAAuB;AACvB,yCAAuB","sourcesContent":["export * from './json';\nexport * from './misc';\nexport * from './time';\n"]}

package/dist/json.d.ts

@@ -0,0 +1,108 @@
+/**
+ * Any JSON-compatible value.
+ */
+export declare type Json = null | boolean | number | string | Json[] | {
+    [prop: string]: Json;
+};
+/**
+ * Type guard for {@link Json}.
+ *
+ * @param value - The value to check.
+ * @returns Whether the value is valid JSON.
+ */
+export declare function isValidJson(value: unknown): value is Json;
+/**
+ * The string '2.0'.
+ */
+export declare const jsonrpc2: "2.0";
+/**
+ * A String specifying the version of the JSON-RPC protocol.
+ * MUST be exactly "2.0".
+ */
+export declare type JsonRpcVersion2 = typeof jsonrpc2;
+/**
+ * An identifier established by the Client that MUST contain a String, Number,
+ * or NULL value if included. If it is not included it is assumed to be a
+ * notification. The value SHOULD normally not be Null and Numbers SHOULD
+ * NOT contain fractional parts.
+ */
+export declare type JsonRpcId = number | string | null;
+/**
+ * A JSON-RPC error object.
+ */
+export declare type JsonRpcError = {
+    code: number;
+    message: string;
+    data?: unknown;
+    stack?: string;
+};
+/**
+ * A JSON-RPC request object.
+ *
+ * @template Params - The type of the params.
+ */
+export declare type JsonRpcRequest<Params> = {
+    id: JsonRpcId;
+    jsonrpc: JsonRpcVersion2;
+    method: string;
+    params?: Params;
+};
+/**
+ * A JSON-RPC notification object.
+ *
+ * @template Params - The type of the params.
+ */
+export declare type JsonRpcNotification<Params> = {
+    jsonrpc: JsonRpcVersion2;
+    method: string;
+    params?: Params;
+};
+/**
+ * A successful JSON-RPC response object.
+ *
+ * @template Result - The type of the result.
+ */
+export declare type JsonRpcSuccess<Result = unknown> = {
+    id: JsonRpcId;
+    jsonrpc: JsonRpcVersion2;
+    result: Result;
+};
+/**
+ * A failed JSON-RPC response object.
+ */
+export declare type JsonRpcFailure = {
+    id: JsonRpcId;
+    jsonrpc: JsonRpcVersion2;
+    error: JsonRpcError;
+};
+/**
+ * A JSON-RPC response object. Must be checked to determine whether it's a
+ * success or failure.
+ *
+ * @template Result - The type of the result.
+ */
+export declare type JsonRpcResponse<Result = unknown> = JsonRpcSuccess<Result> | JsonRpcFailure;
+/**
+ * ATTN: Assumes that only one of the `result` and `error` properties is
+ * present on the `response`, as guaranteed by e.g.
+ * [`JsonRpcEngine.handle`](https://github.com/MetaMask/json-rpc-engine/blob/main/src/JsonRpcEngine.ts).
+ *
+ * Type guard to narrow a JsonRpcResponse object to a success (or failure).
+ *
+ * @param response - The response object to check.
+ * @returns Whether the response object is a success, i.e. has a `result`
+ * property.
+ */
+export declare function isJsonRpcSuccess<Result>(response: JsonRpcResponse<Result>): response is JsonRpcSuccess<Result>;
+/**
+ * ATTN: Assumes that only one of the `result` and `error` properties is
+ * present on the `response`, as guaranteed by e.g.
+ * [`JsonRpcEngine.handle`](https://github.com/MetaMask/json-rpc-engine/blob/main/src/JsonRpcEngine.ts).
+ *
+ * Type guard to narrow a JsonRpcResponse object to a failure (or success).
+ *
+ * @param response - The response object to check.
+ * @returns Whether the response object is a failure, i.e. has an `error`
+ * property.
+ */
+export declare function isJsonRpcFailure(response: JsonRpcResponse<unknown>): response is JsonRpcFailure;

package/dist/json.js

@@ -0,0 +1,58 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isJsonRpcFailure = exports.isJsonRpcSuccess = exports.jsonrpc2 = exports.isValidJson = void 0;
+const fast_deep_equal_1 = __importDefault(require("fast-deep-equal"));
+const misc_1 = require("./misc");
+/**
+ * Type guard for {@link Json}.
+ *
+ * @param value - The value to check.
+ * @returns Whether the value is valid JSON.
+ */
+function isValidJson(value) {
+    try {
+        return fast_deep_equal_1.default(value, JSON.parse(JSON.stringify(value)));
+    }
+    catch (_) {
+        return false;
+    }
+}
+exports.isValidJson = isValidJson;
+/**
+ * The string '2.0'.
+ */
+exports.jsonrpc2 = '2.0';
+/**
+ * ATTN: Assumes that only one of the `result` and `error` properties is
+ * present on the `response`, as guaranteed by e.g.
+ * [`JsonRpcEngine.handle`](https://github.com/MetaMask/json-rpc-engine/blob/main/src/JsonRpcEngine.ts).
+ *
+ * Type guard to narrow a JsonRpcResponse object to a success (or failure).
+ *
+ * @param response - The response object to check.
+ * @returns Whether the response object is a success, i.e. has a `result`
+ * property.
+ */
+function isJsonRpcSuccess(response) {
+    return misc_1.hasProperty(response, 'result');
+}
+exports.isJsonRpcSuccess = isJsonRpcSuccess;
+/**
+ * ATTN: Assumes that only one of the `result` and `error` properties is
+ * present on the `response`, as guaranteed by e.g.
+ * [`JsonRpcEngine.handle`](https://github.com/MetaMask/json-rpc-engine/blob/main/src/JsonRpcEngine.ts).
+ *
+ * Type guard to narrow a JsonRpcResponse object to a failure (or success).
+ *
+ * @param response - The response object to check.
+ * @returns Whether the response object is a failure, i.e. has an `error`
+ * property.
+ */
+function isJsonRpcFailure(response) {
+    return misc_1.hasProperty(response, 'error');
+}
+exports.isJsonRpcFailure = isJsonRpcFailure;
+//# sourceMappingURL=json.js.map

package/dist/json.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"json.js","sourceRoot":"","sources":["../src/json.ts"],"names":[],"mappings":";;;;;;AAAA,sEAAwC;AACxC,iCAAqC;AAarC;;;;;GAKG;AACH,SAAgB,WAAW,CAAC,KAAc;IACxC,IAAI;QACF,OAAO,yBAAS,CAAC,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;KAC5D;IAAC,OAAO,CAAC,EAAE;QACV,OAAO,KAAK,CAAC;KACd;AACH,CAAC;AAND,kCAMC;AAED;;GAEG;AACU,QAAA,QAAQ,GAAG,KAAc,CAAC;AA+EvC;;;;;;;;;;GAUG;AACH,SAAgB,gBAAgB,CAC9B,QAAiC;IAEjC,OAAO,kBAAW,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;AACzC,CAAC;AAJD,4CAIC;AAED;;;;;;;;;;GAUG;AACH,SAAgB,gBAAgB,CAC9B,QAAkC;IAElC,OAAO,kBAAW,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;AACxC,CAAC;AAJD,4CAIC","sourcesContent":["import deepEqual from 'fast-deep-equal';\nimport { hasProperty } from './misc';\n\n/**\n * Any JSON-compatible value.\n */\nexport type Json =\n  | null\n  | boolean\n  | number\n  | string\n  | Json[]\n  | { [prop: string]: Json };\n\n/**\n * Type guard for {@link Json}.\n *\n * @param value - The value to check.\n * @returns Whether the value is valid JSON.\n */\nexport function isValidJson(value: unknown): value is Json {\n  try {\n    return deepEqual(value, JSON.parse(JSON.stringify(value)));\n  } catch (_) {\n    return false;\n  }\n}\n\n/**\n * The string '2.0'.\n */\nexport const jsonrpc2 = '2.0' as const;\n\n/**\n * A String specifying the version of the JSON-RPC protocol.\n * MUST be exactly \"2.0\".\n */\nexport type JsonRpcVersion2 = typeof jsonrpc2;\n\n/**\n * An identifier established by the Client that MUST contain a String, Number,\n * or NULL value if included. If it is not included it is assumed to be a\n * notification. The value SHOULD normally not be Null and Numbers SHOULD\n * NOT contain fractional parts.\n */\nexport type JsonRpcId = number | string | null;\n\n/**\n * A JSON-RPC error object.\n */\nexport type JsonRpcError = {\n  code: number;\n  message: string;\n  data?: unknown;\n  stack?: string;\n};\n\n/**\n * A JSON-RPC request object.\n *\n * @template Params - The type of the params.\n */\nexport type JsonRpcRequest<Params> = {\n  id: JsonRpcId;\n  jsonrpc: JsonRpcVersion2;\n  method: string;\n  params?: Params;\n};\n\n/**\n * A JSON-RPC notification object.\n *\n * @template Params - The type of the params.\n */\nexport type JsonRpcNotification<Params> = {\n  jsonrpc: JsonRpcVersion2;\n  method: string;\n  params?: Params;\n};\n\n/**\n * A successful JSON-RPC response object.\n *\n * @template Result - The type of the result.\n */\nexport type JsonRpcSuccess<Result = unknown> = {\n  id: JsonRpcId;\n  jsonrpc: JsonRpcVersion2;\n  result: Result;\n};\n\n/**\n * A failed JSON-RPC response object.\n */\nexport type JsonRpcFailure = {\n  id: JsonRpcId;\n  jsonrpc: JsonRpcVersion2;\n  error: JsonRpcError;\n};\n\n/**\n * A JSON-RPC response object. Must be checked to determine whether it's a\n * success or failure.\n *\n * @template Result - The type of the result.\n */\nexport type JsonRpcResponse<Result = unknown> =\n  | JsonRpcSuccess<Result>\n  | JsonRpcFailure;\n\n/**\n * ATTN: Assumes that only one of the `result` and `error` properties is\n * present on the `response`, as guaranteed by e.g.\n * [`JsonRpcEngine.handle`](https://github.com/MetaMask/json-rpc-engine/blob/main/src/JsonRpcEngine.ts).\n *\n * Type guard to narrow a JsonRpcResponse object to a success (or failure).\n *\n * @param response - The response object to check.\n * @returns Whether the response object is a success, i.e. has a `result`\n * property.\n */\nexport function isJsonRpcSuccess<Result>(\n  response: JsonRpcResponse<Result>,\n): response is JsonRpcSuccess<Result> {\n  return hasProperty(response, 'result');\n}\n\n/**\n * ATTN: Assumes that only one of the `result` and `error` properties is\n * present on the `response`, as guaranteed by e.g.\n * [`JsonRpcEngine.handle`](https://github.com/MetaMask/json-rpc-engine/blob/main/src/JsonRpcEngine.ts).\n *\n * Type guard to narrow a JsonRpcResponse object to a failure (or success).\n *\n * @param response - The response object to check.\n * @returns Whether the response object is a failure, i.e. has an `error`\n * property.\n */\nexport function isJsonRpcFailure(\n  response: JsonRpcResponse<unknown>,\n): response is JsonRpcFailure {\n  return hasProperty(response, 'error');\n}\n"]}

package/dist/misc.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Makes every specified property of the specified object type mutable.
+ *
+ * @template ObjectValue - The object whose readonly properties to make mutable.
+ * @template TargetKey - The property key(s) to make mutable.
+ */
+export declare type Mutable<ObjectValue extends Record<string, unknown>, TargetKey extends keyof ObjectValue> = {
+    -readonly [Key in keyof Pick<ObjectValue, TargetKey>]: ObjectValue[Key];
+} & {
+    [Key in keyof Omit<ObjectValue, TargetKey>]: ObjectValue[Key];
+};
+/**
+ * Useful for representing some value that _might_ be present and / or complete.
+ *
+ * @template Value - The value that might be present or complete.
+ */
+export declare type PartialOrAbsent<Value> = Partial<Value> | null | undefined;
+/**
+ * Like {@link Array}, but always non-empty.
+ *
+ * @template Element - The non-empty array member type.
+ */
+export declare type NonEmptyArray<Element> = [Element, ...Element[]];
+/**
+ * A JavaScript object that is not `null`, a function, or an array. The object
+ * can still be an instance of a class.
+ */
+export declare type RuntimeObject = Record<number | string | symbol, unknown>;
+/**
+ * A {@link NonEmptyArray} type guard.
+ *
+ * @template Element - The non-empty array member type.
+ * @param value - The value to check.
+ * @returns Whether the value is a non-empty array.
+ */
+export declare function isNonEmptyArray<Element>(value: Element[]): value is NonEmptyArray<Element>;
+/**
+ * Type guard for "nullishness".
+ *
+ * @param value - Any value.
+ * @returns `true` if the value is null or undefined, `false` otherwise.
+ */
+export declare function isNullOrUndefined(value: unknown): value is null | undefined;
+/**
+ * A type guard for {@link RuntimeObject}.
+ *
+ * @param value - The value to check.
+ * @returns Whether the specified value has a runtime type of `object` and is
+ * neither `null` nor an `Array`.
+ */
+export declare function isObject(value: unknown): value is RuntimeObject;
+/**
+ * An alias for {@link Object.hasOwnProperty}.
+ *
+ * @param object - The object to check.
+ * @param name - The property name to check for.
+ * @returns Whether the specified object has an own property with the specified
+ * name, regardless of whether it is enumerable or not.
+ */
+export declare const hasProperty: (object: RuntimeObject, name: string | number | symbol) => boolean;

package/dist/misc.js

@@ -0,0 +1,55 @@
+"use strict";
+//
+// Types
+//
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasProperty = exports.isObject = exports.isNullOrUndefined = exports.isNonEmptyArray = void 0;
+//
+// Type Guards
+//
+/**
+ * A {@link NonEmptyArray} type guard.
+ *
+ * @template Element - The non-empty array member type.
+ * @param value - The value to check.
+ * @returns Whether the value is a non-empty array.
+ */
+function isNonEmptyArray(value) {
+    return Array.isArray(value) && value.length > 0;
+}
+exports.isNonEmptyArray = isNonEmptyArray;
+/**
+ * Type guard for "nullishness".
+ *
+ * @param value - Any value.
+ * @returns `true` if the value is null or undefined, `false` otherwise.
+ */
+function isNullOrUndefined(value) {
+    return value === null || value === undefined;
+}
+exports.isNullOrUndefined = isNullOrUndefined;
+/**
+ * A type guard for {@link RuntimeObject}.
+ *
+ * @param value - The value to check.
+ * @returns Whether the specified value has a runtime type of `object` and is
+ * neither `null` nor an `Array`.
+ */
+function isObject(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+exports.isObject = isObject;
+//
+// Other utility functions
+//
+/**
+ * An alias for {@link Object.hasOwnProperty}.
+ *
+ * @param object - The object to check.
+ * @param name - The property name to check for.
+ * @returns Whether the specified object has an own property with the specified
+ * name, regardless of whether it is enumerable or not.
+ */
+const hasProperty = (object, name) => Object.hasOwnProperty.call(object, name);
+exports.hasProperty = hasProperty;
+//# sourceMappingURL=misc.js.map

package/dist/misc.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"misc.js","sourceRoot":"","sources":["../src/misc.ts"],"names":[],"mappings":";AAAA,EAAE;AACF,QAAQ;AACR,EAAE;;;AAsCF,EAAE;AACF,cAAc;AACd,EAAE;AAEF;;;;;;GAMG;AACH,SAAgB,eAAe,CAC7B,KAAgB;IAEhB,OAAO,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC;AAClD,CAAC;AAJD,0CAIC;AAED;;;;;GAKG;AACH,SAAgB,iBAAiB,CAAC,KAAc;IAC9C,OAAO,KAAK,KAAK,IAAI,IAAI,KAAK,KAAK,SAAS,CAAC;AAC/C,CAAC;AAFD,8CAEC;AAED;;;;;;GAMG;AACH,SAAgB,QAAQ,CAAC,KAAc;IACrC,OAAO,OAAO,CAAC,KAAK,CAAC,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;AAC9E,CAAC;AAFD,4BAEC;AAED,EAAE;AACF,0BAA0B;AAC1B,EAAE;AAEF;;;;;;;GAOG;AACI,MAAM,WAAW,GAAG,CACzB,MAAqB,EACrB,IAA8B,EACrB,EAAE,CAAC,MAAM,CAAC,cAAc,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;AAH1C,QAAA,WAAW,eAG+B","sourcesContent":["//\n// Types\n//\n\n/**\n * Makes every specified property of the specified object type mutable.\n *\n * @template ObjectValue - The object whose readonly properties to make mutable.\n * @template TargetKey - The property key(s) to make mutable.\n */\nexport type Mutable<\n  ObjectValue extends Record<string, unknown>,\n  TargetKey extends keyof ObjectValue\n> = {\n  -readonly [Key in keyof Pick<ObjectValue, TargetKey>]: ObjectValue[Key];\n} &\n  {\n    [Key in keyof Omit<ObjectValue, TargetKey>]: ObjectValue[Key];\n  };\n\n/**\n * Useful for representing some value that _might_ be present and / or complete.\n *\n * @template Value - The value that might be present or complete.\n */\nexport type PartialOrAbsent<Value> = Partial<Value> | null | undefined;\n\n/**\n * Like {@link Array}, but always non-empty.\n *\n * @template Element - The non-empty array member type.\n */\nexport type NonEmptyArray<Element> = [Element, ...Element[]];\n\n/**\n * A JavaScript object that is not `null`, a function, or an array. The object\n * can still be an instance of a class.\n */\nexport type RuntimeObject = Record<number | string | symbol, unknown>;\n\n//\n// Type Guards\n//\n\n/**\n * A {@link NonEmptyArray} type guard.\n *\n * @template Element - The non-empty array member type.\n * @param value - The value to check.\n * @returns Whether the value is a non-empty array.\n */\nexport function isNonEmptyArray<Element>(\n  value: Element[],\n): value is NonEmptyArray<Element> {\n  return Array.isArray(value) && value.length > 0;\n}\n\n/**\n * Type guard for \"nullishness\".\n *\n * @param value - Any value.\n * @returns `true` if the value is null or undefined, `false` otherwise.\n */\nexport function isNullOrUndefined(value: unknown): value is null | undefined {\n  return value === null || value === undefined;\n}\n\n/**\n * A type guard for {@link RuntimeObject}.\n *\n * @param value - The value to check.\n * @returns Whether the specified value has a runtime type of `object` and is\n * neither `null` nor an `Array`.\n */\nexport function isObject(value: unknown): value is RuntimeObject {\n  return Boolean(value) && typeof value === 'object' && !Array.isArray(value);\n}\n\n//\n// Other utility functions\n//\n\n/**\n * An alias for {@link Object.hasOwnProperty}.\n *\n * @param object - The object to check.\n * @param name - The property name to check for.\n * @returns Whether the specified object has an own property with the specified\n * name, regardless of whether it is enumerable or not.\n */\nexport const hasProperty = (\n  object: RuntimeObject,\n  name: string | number | symbol,\n): boolean => Object.hasOwnProperty.call(object, name);\n"]}

package/dist/time.d.ts

@@ -0,0 +1,27 @@
+/**
+ * A millisecond.
+ */
+export declare const MILLISECOND = 1;
+/**
+ * A second, in milliseconds.
+ */
+export declare const SECOND = 1000;
+/**
+ * A minute, in milliseconds.
+ */
+export declare const MINUTE = 60000;
+/**
+ * An hour, in milliseconds.
+ */
+export declare const HOUR = 3600000;
+/**
+ * A day, in milliseconds.
+ */
+export declare const DAY = 86400000;
+/**
+ * Gets the milliseconds since a particular Unix epoch timestamp.
+ *
+ * @param timestamp - A Unix millisecond timestamp.
+ * @returns The number of milliseconds elapsed since the specified timestamp.
+ */
+export declare function timeSince(timestamp: number): number;

package/dist/time.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.timeSince = exports.DAY = exports.HOUR = exports.MINUTE = exports.SECOND = exports.MILLISECOND = void 0;
+/**
+ * A millisecond.
+ */
+exports.MILLISECOND = 1;
+/**
+ * A second, in milliseconds.
+ */
+exports.SECOND = 1000; // MILLISECOND * 1000
+/**
+ * A minute, in milliseconds.
+ */
+exports.MINUTE = 60000; // SECOND * 60
+/**
+ * An hour, in milliseconds.
+ */
+exports.HOUR = 3600000; // MINUTE * 60
+/**
+ * A day, in milliseconds.
+ */
+exports.DAY = 86400000; // HOUR * 24
+/**
+ * Gets the milliseconds since a particular Unix epoch timestamp.
+ *
+ * @param timestamp - A Unix millisecond timestamp.
+ * @returns The number of milliseconds elapsed since the specified timestamp.
+ */
+function timeSince(timestamp) {
+    return Date.now() - timestamp;
+}
+exports.timeSince = timeSince;
+//# sourceMappingURL=time.js.map

package/dist/time.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"time.js","sourceRoot":"","sources":["../src/time.ts"],"names":[],"mappings":";;;AAAA;;GAEG;AACU,QAAA,WAAW,GAAG,CAAC,CAAC;AAE7B;;GAEG;AACU,QAAA,MAAM,GAAG,IAAI,CAAC,CAAC,qBAAqB;AAEjD;;GAEG;AACU,QAAA,MAAM,GAAG,KAAM,CAAC,CAAC,cAAc;AAE5C;;GAEG;AACU,QAAA,IAAI,GAAG,OAAS,CAAC,CAAC,cAAc;AAE7C;;GAEG;AACU,QAAA,GAAG,GAAG,QAAU,CAAC,CAAC,YAAY;AAE3C;;;;;GAKG;AACH,SAAgB,SAAS,CAAC,SAAiB;IACzC,OAAO,IAAI,CAAC,GAAG,EAAE,GAAG,SAAS,CAAC;AAChC,CAAC;AAFD,8BAEC","sourcesContent":["/**\n * A millisecond.\n */\nexport const MILLISECOND = 1;\n\n/**\n * A second, in milliseconds.\n */\nexport const SECOND = 1000; // MILLISECOND * 1000\n\n/**\n * A minute, in milliseconds.\n */\nexport const MINUTE = 60_000; // SECOND * 60\n\n/**\n * An hour, in milliseconds.\n */\nexport const HOUR = 3_600_000; // MINUTE * 60\n\n/**\n * A day, in milliseconds.\n */\nexport const DAY = 86_400_000; // HOUR * 24\n\n/**\n * Gets the milliseconds since a particular Unix epoch timestamp.\n *\n * @param timestamp - A Unix millisecond timestamp.\n * @returns The number of milliseconds elapsed since the specified timestamp.\n */\nexport function timeSince(timestamp: number): number {\n  return Date.now() - timestamp;\n}\n"]}

package/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "@metamask/utils",
+  "version": "1.0.0",
+  "description": "Various JavaScript/TypeScript utilities of wide relevance to the MetaMask codebase.",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/MetaMask/utils.git"
+  },
+  "license": "ISC",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist/"
+  ],
+  "scripts": {
+    "setup": "yarn install && yarn allow-scripts",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "prepublishOnly": "yarn build:clean && yarn lint && yarn test",
+    "lint:eslint": "eslint . --cache --ext js,ts",
+    "lint:misc": "prettier '**/*.json' '**/*.md' '!CHANGELOG.md' '**/*.yml' --ignore-path .gitignore",
+    "lint": "yarn lint:eslint && yarn lint:misc --check",
+    "lint:fix": "yarn lint:eslint --fix && yarn lint:misc --write",
+    "build:clean": "rimraf dist && yarn build",
+    "build": "tsc --project .",
+    "docs": "typedoc",
+    "docs:publish": "typedoc --cleanOutputDir false --gitRevision \"v$(jq -r .version < ./package.json)\""
+  },
+  "dependencies": {
+    "fast-deep-equal": "^3.1.3"
+  },
+  "devDependencies": {
+    "@lavamoat/allow-scripts": "^1.0.5",
+    "@metamask/auto-changelog": "^2.3.0",
+    "@metamask/eslint-config": "^9.0.0",
+    "@metamask/eslint-config-jest": "^9.0.0",
+    "@metamask/eslint-config-nodejs": "^9.0.0",
+    "@metamask/eslint-config-typescript": "^9.0.1",
+    "@types/jest": "^26.0.13",
+    "@typescript-eslint/eslint-plugin": "^4.21.0",
+    "@typescript-eslint/parser": "^4.21.0",
+    "eslint": "^7.23.0",
+    "eslint-config-prettier": "^8.1.0",
+    "eslint-plugin-import": "^2.22.1",
+    "eslint-plugin-jest": "^24.3.4",
+    "eslint-plugin-jsdoc": "^36.1.0",
+    "eslint-plugin-node": "^11.1.0",
+    "eslint-plugin-prettier": "^3.3.1",
+    "jest": "^26.4.2",
+    "prettier": "^2.2.1",
+    "prettier-plugin-packagejson": "^2.2.11",
+    "rimraf": "^3.0.2",
+    "ts-jest": "^26.3.0",
+    "typedoc": "^0.22.15",
+    "typescript": "^4.2.4"
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "lavamoat": {
+    "allowScripts": {
+      "@lavamoat/preinstall-always-fail": false
+    }
+  }
+}