@bitgo/wasm-utxo 1.34.0 → 1.36.0

package/dist/cjs/js/testutils/fixtures.js

@@ -0,0 +1,244 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFixture = getFixture;
+exports.jsonNormalize = jsonNormalize;
+exports.matchPath = matchPath;
+exports.toPlainObject = toPlainObject;
+/// <reference types="node" />
+/**
+ * Generic test fixture and serialization utilities.
+ * Ported from @bitgo/utxo-core/testutil/fixtures.utils.ts
+ * and @bitgo/utxo-core/testutil/toPlainObject.utils.ts.
+ *
+ * NOTE: getFixture requires Node.js (fs, process.env).
+ * The toPlainObject / jsonNormalize utilities are platform-independent.
+ */
+const fs = __importStar(require("fs"));
+const mpath = __importStar(require("path"));
+function isNodeJsError(e) {
+    return e instanceof Error && typeof e.code === "string";
+}
+function fixtureEncoding(path) {
+    if (path.endsWith(".json")) {
+        return "json";
+    }
+    if (path.endsWith(".hex")) {
+        return "hex";
+    }
+    if (path.endsWith(".txt")) {
+        return "txt";
+    }
+    throw new Error(`unknown fixture encoding for ${path}`);
+}
+function hexToBytes(hex) {
+    const bytes = new Uint8Array(hex.length / 2);
+    for (let i = 0; i < hex.length; i += 2) {
+        bytes[i / 2] = parseInt(hex.substring(i, i + 2), 16);
+    }
+    return bytes;
+}
+function bytesToHex(bytes) {
+    return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+}
+function decodeFixture(raw, encoding) {
+    switch (encoding) {
+        case "json":
+            return JSON.parse(raw);
+        case "hex":
+            return hexToBytes(raw);
+        case "txt":
+            return raw;
+    }
+}
+function encodeFixture(value, encoding) {
+    switch (encoding) {
+        case "json":
+            return JSON.stringify(value, null, 2) + "\n";
+        case "hex":
+            if (!(value instanceof Uint8Array)) {
+                throw new Error(`expected Uint8Array, got ${typeof value}`);
+            }
+            return bytesToHex(value);
+        case "txt":
+            if (typeof value !== "string") {
+                throw new Error(`expected string, got ${typeof value}`);
+            }
+            return value;
+    }
+}
+/**
+ * Return fixture described in `path`.
+ *
+ * If the file does not exist and `defaultValue` is provided,
+ * writes defaultValue to `path` and throws an error prompting
+ * the developer to inspect and re-run.
+ *
+ * @param path - Path to the fixture file (.json, .hex, or .txt)
+ * @param defaultValue - Default value to write if fixture is missing
+ * @returns The fixture content
+ */
+async function getFixture(path, defaultValue) {
+    try {
+        await fs.promises.stat(mpath.dirname(path));
+    }
+    catch (e) {
+        if (isNodeJsError(e) && e.code === "ENOENT") {
+            throw new Error(`fixture directory ${mpath.dirname(path)} not found, please create it first`);
+        }
+        throw e;
+    }
+    const encoding = fixtureEncoding(path);
+    try {
+        return decodeFixture(await fs.promises.readFile(path, "utf8"), encoding);
+    }
+    catch (e) {
+        if (isNodeJsError(e) && e.code === "ENOENT") {
+            // eslint-disable-next-line no-restricted-globals
+            if (process.env.WRITE_FIXTURES === "0") {
+                throw new Error(`fixture ${path} not found, WRITE_FIXTURES=0`);
+            }
+            if (defaultValue === undefined) {
+                throw new Error(`fixture ${path} not found and no default value given`);
+            }
+            if (typeof defaultValue === "function") {
+                defaultValue = await defaultValue();
+            }
+            await fs.promises.writeFile(path, encodeFixture(defaultValue, encoding));
+            throw new Error(`wrote default value for ${path}, please inspect and restart test`);
+        }
+        throw e;
+    }
+}
+/**
+ * JSON round-trip normalization.
+ * Converts a value to JSON and back, stripping non-serializable properties
+ * and normalizing types (e.g. undefined -> null in arrays).
+ */
+function jsonNormalize(v) {
+    return JSON.parse(JSON.stringify(v));
+}
+function matchPath(a, b) {
+    return a.length === b.length && a.every((e, i) => e === b[i]);
+}
+function includePath(opts, path) {
+    if (!opts.ignorePaths) {
+        return true;
+    }
+    if (typeof opts.ignorePaths === "function") {
+        return !opts.ignorePaths(path);
+    }
+    return !opts.ignorePaths.some((ignorePath) => matchPath(path, ignorePath.split(".")));
+}
+function toPlainEntries(key, value, opts, path) {
+    if (!includePath(opts, [...path, key])) {
+        return [];
+    }
+    if (value === undefined && (opts.skipUndefinedValues ?? true)) {
+        return [];
+    }
+    return [[key, toPlainObject(value, opts, [...path, key])]];
+}
+function getAllPropertyDescriptors(v) {
+    if (v === null || typeof v !== "object") {
+        return {};
+    }
+    const descriptors = Object.getOwnPropertyDescriptors(v);
+    const proto = Object.getPrototypeOf(v);
+    if (proto) {
+        Object.assign(descriptors, getAllPropertyDescriptors(proto));
+    }
+    return descriptors;
+}
+function toPlainObjectFromPropertyDescriptors(v, opts, path) {
+    const descriptors = getAllPropertyDescriptors(v);
+    return Object.fromEntries(Object.entries(descriptors).flatMap(([key, descriptor]) => {
+        if (typeof descriptor.value === "function") {
+            return [];
+        }
+        if (descriptor.value !== undefined) {
+            return toPlainEntries(key, descriptor.value, opts, path);
+        }
+        if (typeof descriptor.get === "function") {
+            return toPlainEntries(key, descriptor.get.call(v), opts, path);
+        }
+        return [];
+    }));
+}
+/**
+ * Recursively convert a value to a plain JSON-serializable object.
+ * Handles Uint8Array (to hex), bigint (to string), Buffer, and more.
+ *
+ * @param v - The value to convert
+ * @param opts - Options for customizing the conversion
+ * @param path - Current property path (used for ignorePaths)
+ */
+function toPlainObject(v, opts = {}, path = []) {
+    if (opts.apply) {
+        const result = opts.apply(v, path);
+        if (result !== undefined) {
+            return result;
+        }
+    }
+    switch (typeof v) {
+        case "string":
+        case "number":
+        case "boolean":
+        case "undefined":
+            return v;
+        case "bigint":
+            return v.toString();
+        case "function":
+        case "symbol":
+            return undefined;
+    }
+    if (v === null) {
+        return v;
+    }
+    if (v instanceof Uint8Array) {
+        return Array.from(v, (b) => b.toString(16).padStart(2, "0")).join("");
+    }
+    if (Array.isArray(v)) {
+        return v.map((e, i) => toPlainObject(e, opts, [...path, i]));
+    }
+    if (typeof v === "object") {
+        const result = Object.fromEntries(Object.entries(v).flatMap(([key, value]) => toPlainEntries(key, value, opts, path)));
+        if (opts.propertyDescriptors) {
+            Object.assign(result, toPlainObjectFromPropertyDescriptors(v, opts, path));
+        }
+        return result;
+    }
+    throw new Error(`unknown v ${typeof v}`);
+}

package/dist/cjs/js/testutils/index.d.ts

@@ -1,2 +1,4 @@
 export * from "./keys.js";
 export * from "./AcidTest.js";
+export * from "./fixtures.js";
+export * as descriptor from "./descriptor/index.js";

package/dist/cjs/js/testutils/index.js

@@ -10,9 +10,34 @@ var __createBinding = (this && this.__createBinding) || (Object.create ? (functi
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
 }));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
 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);
 };
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.descriptor = void 0;
 __exportStar(require("./keys.js"), exports);
 __exportStar(require("./AcidTest.js"), exports);
+__exportStar(require("./fixtures.js"), exports);
+exports.descriptor = __importStar(require("./descriptor/index.js"));