@ocap/util 1.27.16 → 1.28.1

package/lib/lodash.d.ts

@@ -0,0 +1,12 @@
+declare module 'lodash/camelCase';
+declare module 'lodash/flatten';
+declare module 'lodash/get';
+declare module 'lodash/isBoolean';
+declare module 'lodash/isNull';
+declare module 'lodash/isNumber';
+declare module 'lodash/isObject';
+declare module 'lodash/isString';
+declare module 'lodash/padEnd';
+declare module 'lodash/padStart';
+declare module 'lodash/uniq';
+declare module 'lodash/upperFirst';

package/lib/md5.d.ts

@@ -1 +1,4 @@
-export declare const md5: (x: $TSFixMe) => string;
+//#region src/md5.d.ts
+declare const md5: (x: $TSFixMe) => string;
+//#endregion
+export { md5 };

package/lib/md5.js

@@ -1,10 +1,9 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.md5 = void 0;
-const crypto_1 = __importDefault(require("crypto"));
-// eslint-disable-next-line import/prefer-default-export
-const md5 = (x) => crypto_1.default.createHash('md5').update(x).digest('hex');
-exports.md5 = md5;
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.js');
+let crypto = require("crypto");
+crypto = require_rolldown_runtime.__toESM(crypto);
+
+//#region src/md5.ts
+const md5 = (x) => crypto.default.createHash("md5").update(x).digest("hex");
+
+//#endregion
+exports.md5 = md5;

package/lib/ready.d.ts

@@ -1,10 +1,14 @@
-import EventEmitter from 'events';
-export declare class Ready extends EventEmitter {
-    emit: $TSFixMe;
-    ready: $TSFixMe;
-    readyCallbacks: $TSFixMe;
-    readyMarks: $TSFixMe;
-    constructor();
-    markReady(mark?: $TSFixMe): void;
-    onReady(cb: $TSFixMe): void;
+import EventEmitter from "events";
+
+//#region src/ready.d.ts
+declare class Ready extends EventEmitter {
+  emit: $TSFixMe;
+  ready: $TSFixMe;
+  readyCallbacks: $TSFixMe;
+  readyMarks: $TSFixMe;
+  constructor();
+  markReady(mark?: $TSFixMe): void;
+  onReady(cb: $TSFixMe): void;
 }
+//#endregion
+export { Ready };

package/lib/ready.js

@@ -1,43 +1,35 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.js');
+let events = require("events");
+events = require_rolldown_runtime.__toESM(events);
+
+//#region src/ready.ts
+var Ready = class extends events.default {
+	constructor() {
+		super();
+		this.ready = false;
+		this.readyCallbacks = [];
+		this.readyMarks = {};
+	}
+	markReady(mark) {
+		if (this.ready) return;
+		if (mark === void 0) {
+			this.ready = true;
+			this.readyCallbacks.forEach((x) => x());
+			this.emit("ready");
+		} else {
+			this.readyMarks[mark] = true;
+			this.ready = Object.values(this.readyMarks).every((x) => !!x);
+			if (this.ready) {
+				this.readyCallbacks.forEach((cb) => cb());
+				this.emit("ready");
+			}
+		}
+	}
+	onReady(cb) {
+		if (this.ready) cb();
+		else this.readyCallbacks.push(cb);
+	}
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Ready = void 0;
-const events_1 = __importDefault(require("events"));
-class Ready extends events_1.default {
-    constructor() {
-        super();
-        this.ready = false;
-        this.readyCallbacks = [];
-        this.readyMarks = {};
-    }
-    markReady(mark) {
-        if (this.ready) {
-            return;
-        }
-        if (mark === undefined) {
-            this.ready = true;
-            this.readyCallbacks.forEach((x) => x());
-            this.emit('ready');
-        }
-        else {
-            // console.log('Ready.markReady', this.name, mark);
-            this.readyMarks[mark] = true;
-            this.ready = Object.values(this.readyMarks).every((x) => !!x);
-            if (this.ready) {
-                this.readyCallbacks.forEach((cb) => cb());
-                this.emit('ready');
-            }
-        }
-    }
-    onReady(cb) {
-        if (this.ready) {
-            cb();
-        }
-        else {
-            this.readyCallbacks.push(cb);
-        }
-    }
-}
-exports.Ready = Ready;
+
+//#endregion
+exports.Ready = Ready;

package/lib/retry.d.ts

@@ -1,11 +1,18 @@
+//#region src/retry.d.ts
 interface RetryOptions {
-    retryLimit?: number;
-    backoff?: {
-        baseDelay: number;
-        maxDelay: number;
-    };
-    shouldRetry?: (error: unknown) => boolean;
-    onError?: (error: unknown, attempt: number) => Promise<void> | void;
+  retryLimit?: number;
+  backoff?: {
+    baseDelay: number;
+    maxDelay: number;
+  };
+  shouldRetry?: (error: unknown) => boolean;
+  onError?: (error: unknown, attempt: number) => Promise<void> | void;
 }
-export declare function withRetry<T>(handle: () => Promise<T>, { retryLimit, backoff, shouldRetry, onError, }?: RetryOptions): Promise<T>;
-export {};
+declare function withRetry<T>(handle: () => Promise<T>, {
+  retryLimit,
+  backoff,
+  shouldRetry,
+  onError
+}?: RetryOptions): Promise<T>;
+//#endregion
+export { withRetry };

package/lib/retry.js

@@ -1,33 +1,30 @@
-"use strict";
-/* eslint-disable no-await-in-loop */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.withRetry = withRetry;
+
+//#region src/retry.ts
 function wait(ms) {
-    return new Promise((resolve) => {
-        setTimeout(resolve, ms);
-    });
+	return new Promise((resolve) => {
+		setTimeout(resolve, ms);
+	});
 }
-// eslint-disable-next-line consistent-return
-async function withRetry(handle, { retryLimit = 30, backoff = { baseDelay: 20, maxDelay: 1000 }, shouldRetry = () => true, onError = () => { }, } = {}) {
-    let attempt = 0;
-    let lastError;
-    while (attempt <= retryLimit) {
-        attempt++;
-        try {
-            const result = await handle();
-            return result;
-        }
-        catch (error) {
-            if (!shouldRetry(error) || attempt > retryLimit) {
-                throw error;
-            }
-            lastError = error;
-            if (onError) {
-                await onError(lastError, attempt);
-            }
-            const { baseDelay, maxDelay } = backoff;
-            const delay = Math.min(maxDelay, baseDelay * 2 ** attempt);
-            await wait(Math.random() * delay);
-        }
-    }
+async function withRetry(handle, { retryLimit = 30, backoff = {
+	baseDelay: 20,
+	maxDelay: 1e3
+}, shouldRetry = () => true, onError = () => {} } = {}) {
+	let attempt = 0;
+	let lastError;
+	while (attempt <= retryLimit) {
+		attempt++;
+		try {
+			return await handle();
+		} catch (error) {
+			if (!shouldRetry(error) || attempt > retryLimit) throw error;
+			lastError = error;
+			if (onError) await onError(lastError, attempt);
+			const { baseDelay, maxDelay } = backoff;
+			const delay = Math.min(maxDelay, baseDelay * 2 ** attempt);
+			await wait(Math.random() * delay);
+		}
+	}
 }
+
+//#endregion
+exports.withRetry = withRetry;

package/lib/tsfixme.d.ts

@@ -0,0 +1,3 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+type $TSFixMe = any;
+type $TSFixMeFunction = (...args: any[]) => any;

package/lib/url.d.ts

@@ -1,13 +1,17 @@
-import * as ipaddr from 'ipaddr.js';
-export declare function parseIp(host: string): ipaddr.IPv4 | ipaddr.IPv6 | null;
-export declare function isUnicastAddress(host: string): boolean;
-export declare function resolveHostAddresses(host: string): Promise<string[]>;
-export interface VerifyUrlOptions {
-    allowIp?: boolean;
-    maxLength?: number;
-    protocols?: string[];
-    blockedHosts?: string[];
-    blockedSuffixes?: string[];
-    checkDns?: boolean;
+import * as ipaddr from "ipaddr.js";
+
+//#region src/url.d.ts
+declare function parseIp(host: string): ipaddr.IPv4 | ipaddr.IPv6 | null;
+declare function isUnicastAddress(host: string): boolean;
+declare function resolveHostAddresses(host: string): Promise<string[]>;
+interface VerifyUrlOptions {
+  allowIp?: boolean;
+  maxLength?: number;
+  protocols?: string[];
+  blockedHosts?: string[];
+  blockedSuffixes?: string[];
+  checkDns?: boolean;
 }
-export declare function verifyUrl(url: string, options?: VerifyUrlOptions): Promise<boolean>;
+declare function verifyUrl(url: string, options?: VerifyUrlOptions): Promise<boolean>;
+//#endregion
+export { VerifyUrlOptions, isUnicastAddress, parseIp, resolveHostAddresses, verifyUrl };

package/lib/url.js

@@ -1,130 +1,81 @@
-"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 (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseIp = parseIp;
-exports.isUnicastAddress = isUnicastAddress;
-exports.resolveHostAddresses = resolveHostAddresses;
-exports.verifyUrl = verifyUrl;
-const url_1 = require("url");
-const ipaddr = __importStar(require("ipaddr.js"));
-const promises_1 = require("dns/promises");
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.js');
+let url = require("url");
+let ipaddr_js = require("ipaddr.js");
+ipaddr_js = require_rolldown_runtime.__toESM(ipaddr_js);
+let dns_promises = require("dns/promises");
+
+//#region src/url.ts
 const MAX_URL_LENGTH = 256;
 function parseIp(host) {
-    if (!ipaddr.isValid(host))
-        return null;
-    try {
-        return ipaddr.parse(host);
-    }
-    catch {
-        return null;
-    }
+	if (!ipaddr_js.isValid(host)) return null;
+	try {
+		return ipaddr_js.parse(host);
+	} catch {
+		return null;
+	}
 }
 function stripTrailingDots(host) {
-    return host.replace(/\.+$/, '');
+	return host.replace(/\.+$/, "");
 }
 function isBlockedHostname(host, blockedHosts, blockedSuffixes) {
-    const normalized = host.toLowerCase();
-    if (blockedHosts.includes(normalized))
-        return true;
-    if (blockedSuffixes.some((suffix) => normalized.endsWith(suffix)))
-        return true;
-    return false;
+	const normalized = host.toLowerCase();
+	if (blockedHosts.includes(normalized)) return true;
+	if (blockedSuffixes.some((suffix) => normalized.endsWith(suffix))) return true;
+	return false;
 }
 function isUnicastAddress(host) {
-    const parsed = parseIp(host);
-    if (!parsed)
-        return false;
-    const range = parsed.range();
-    if (range === 'ipv4Mapped' && parsed.kind() === 'ipv6') {
-        const mapped = parsed.toIPv4Address();
-        return mapped.range() === 'unicast';
-    }
-    return range === 'unicast';
+	const parsed = parseIp(host);
+	if (!parsed) return false;
+	const range = parsed.range();
+	if (range === "ipv4Mapped" && parsed.kind() === "ipv6") return parsed.toIPv4Address().range() === "unicast";
+	return range === "unicast";
 }
 async function resolveHostAddresses(host) {
-    try {
-        const resolver = new promises_1.Resolver();
-        resolver.setServers(['8.8.8.8', '1.1.1.1']);
-        const addresses = [];
-        // resolve ipv4
-        try {
-            const ipv4Addresses = await resolver.resolve4(host);
-            addresses.push(...ipv4Addresses);
-        }
-        catch (error) {
-            console.warn(`IPv4 resolution failed for ${host}:`, error?.message);
-        }
-        // resolve ipv6
-        if (!addresses.length) {
-            try {
-                const ipv6Addresses = await resolver.resolve6(host);
-                addresses.push(...ipv6Addresses);
-            }
-            catch (error) {
-                console.warn(`IPv6 resolution failed for ${host}:`, error?.message);
-            }
-        }
-        return addresses.filter(Boolean);
-    }
-    catch (error) {
-        console.warn(`DNS resolution failed for host: ${host}, error: ${error?.message}`);
-        return [];
-    }
+	try {
+		const resolver = new dns_promises.Resolver();
+		resolver.setServers(["8.8.8.8", "1.1.1.1"]);
+		const addresses = [];
+		try {
+			const ipv4Addresses = await resolver.resolve4(host);
+			addresses.push(...ipv4Addresses);
+		} catch (error) {
+			console.warn(`IPv4 resolution failed for ${host}:`, error?.message);
+		}
+		if (!addresses.length) try {
+			const ipv6Addresses = await resolver.resolve6(host);
+			addresses.push(...ipv6Addresses);
+		} catch (error) {
+			console.warn(`IPv6 resolution failed for ${host}:`, error?.message);
+		}
+		return addresses.filter(Boolean);
+	} catch (error) {
+		console.warn(`DNS resolution failed for host: ${host}, error: ${error?.message}`);
+		return [];
+	}
 }
-async function verifyUrl(url, options = {}) {
-    if (!url)
-        throw new Error('URL is required');
-    const { maxLength = MAX_URL_LENGTH, protocols = ['https:'], blockedHosts = ['localhost'], blockedSuffixes = [], allowIp = false, checkDns = false, } = options;
-    if (url.length > maxLength) {
-        throw new Error(`URL exceeds maximum length of ${maxLength} characters: ${url.length}`);
-    }
-    const { hostname, protocol } = new url_1.URL(url);
-    if (!protocols.includes(protocol)) {
-        throw new Error(`Protocol '${protocol}' is not allowed. Allowed protocols: ${protocols.join(', ')}`);
-    }
-    const normalizedHost = stripTrailingDots(hostname);
-    if (isBlockedHostname(normalizedHost, blockedHosts, blockedSuffixes)) {
-        throw new Error(`Hostname '${normalizedHost}' is blocked`);
-    }
-    const isIP = Boolean(parseIp(normalizedHost));
-    if (isIP) {
-        if (!allowIp) {
-            throw new Error(`IP addresses are not allowed: ${normalizedHost}`);
-        }
-        if (!isUnicastAddress(normalizedHost)) {
-            throw new Error(`IP address is not unicast: ${normalizedHost}`);
-        }
-    }
-    if (checkDns && !isIP) {
-        const resolved = await resolveHostAddresses(normalizedHost);
-        if (resolved.length === 0) {
-            throw new Error(`DNS resolution failed: no addresses found for ${normalizedHost}`);
-        }
-        if (!resolved.every((address) => isUnicastAddress(address))) {
-            throw new Error(`DNS resolved to non-unicast addresses for ${normalizedHost}`);
-        }
-    }
-    return true;
+async function verifyUrl(url$1, options = {}) {
+	if (!url$1) throw new Error("URL is required");
+	const { maxLength = MAX_URL_LENGTH, protocols = ["https:"], blockedHosts = ["localhost"], blockedSuffixes = [], allowIp = false, checkDns = false } = options;
+	if (url$1.length > maxLength) throw new Error(`URL exceeds maximum length of ${maxLength} characters: ${url$1.length}`);
+	const { hostname, protocol } = new url.URL(url$1);
+	if (!protocols.includes(protocol)) throw new Error(`Protocol '${protocol}' is not allowed. Allowed protocols: ${protocols.join(", ")}`);
+	const normalizedHost = stripTrailingDots(hostname);
+	if (isBlockedHostname(normalizedHost, blockedHosts, blockedSuffixes)) throw new Error(`Hostname '${normalizedHost}' is blocked`);
+	const isIP = Boolean(parseIp(normalizedHost));
+	if (isIP) {
+		if (!allowIp) throw new Error(`IP addresses are not allowed: ${normalizedHost}`);
+		if (!isUnicastAddress(normalizedHost)) throw new Error(`IP address is not unicast: ${normalizedHost}`);
+	}
+	if (checkDns && !isIP) {
+		const resolved = await resolveHostAddresses(normalizedHost);
+		if (resolved.length === 0) throw new Error(`DNS resolution failed: no addresses found for ${normalizedHost}`);
+		if (!resolved.every((address) => isUnicastAddress(address))) throw new Error(`DNS resolved to non-unicast addresses for ${normalizedHost}`);
+	}
+	return true;
 }
+
+//#endregion
+exports.isUnicastAddress = isUnicastAddress;
+exports.parseIp = parseIp;
+exports.resolveHostAddresses = resolveHostAddresses;
+exports.verifyUrl = verifyUrl;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ocap/util",
-  "version": "1.27.16",
+  "version": "1.28.1",
   "description": "utils shared across multiple forge js libs, works in both node.js and browser",
   "keywords": [
     "arcblock",
@@ -18,7 +18,7 @@
     "ipaddr.js": "^2.1.0",
     "lodash": "^4.17.21",
     "utf8": "^3.0.0",
-    "@ocap/types": "^1.27.16"
+    "@ocap/types": "^1.28.1"
   },
   "resolutions": {
     "elliptic": "6.5.3"
@@ -33,6 +33,7 @@
     "eslint": "^8.57.0",
     "jest": "^29.7.0",
     "ts-jest": "^29.2.5",
+    "tsdown": "^0.18.4",
     "type-fest": "^3.1.0",
     "typescript": "^5.6.2"
   },
@@ -47,7 +48,21 @@
   "homepage": "https://www.arcblock.io/docs/blockchain-utils",
   "license": "Apache-2.0",
   "main": "./lib/index.js",
-  "types": "./lib/index.d.ts",
+  "sideEffects": false,
+  "module": "./esm/index.js",
+  "types": "./esm/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./esm/index.d.ts",
+      "import": "./esm/index.js",
+      "default": "./lib/index.js"
+    },
+    "./lib/*": {
+      "types": "./lib/*",
+      "import": "./esm/*",
+      "default": "./lib/*.js"
+    }
+  },
   "files": [
     "lib",
     "esm"
@@ -64,11 +79,7 @@
     "lint:fix": "npm run lint -- --fix",
     "test": "jest --forceExit --detectOpenHandles",
     "coverage": "npm run test -- --coverage",
-    "clean": "rm -fr lib esm",
-    "prebuild": "npm run clean",
-    "build:cjs": "tsc -p tsconfig.cjs.json",
-    "build:esm": "tsc -p tsconfig.esm.json",
-    "build": "npm run build:cjs && npm run build:esm",
-    "build:watch": "npm run build -- -w"
+    "build": "tsdown",
+    "build:watch": "tsdown --watch"
   }
 }