@wener/utils 1.1.56 → 1.1.58

package/lib/browsers/getFileFromDataTransfer.js

@@ -1,14 +1,14 @@
 export function getFileFromDataTransfer(dataTransfer) {
+    var _dataTransfer_items;
     if (!dataTransfer) {
         return {};
     }
-    var _dataTransfer_items;
     var items = (_dataTransfer_items = dataTransfer.items) !== null && _dataTransfer_items !== void 0 ? _dataTransfer_items : [];
     if (items.length >= 2 && items[0].kind === 'string' && items[1].kind === 'file') {
+        var _items__getAsFile;
         var _dataTransfer_files;
         // name, file
         var text = dataTransfer.getData('text');
-        var _items__getAsFile;
         var file = (_items__getAsFile = items[1].getAsFile()) !== null && _items__getAsFile !== void 0 ? _items__getAsFile : (_dataTransfer_files = dataTransfer.files) === null || _dataTransfer_files === void 0 ? void 0 : _dataTransfer_files.item(0);
         if (!file) {
             console.error("no file ".concat(text), items[1]);

package/lib/crypto/randomUUIDv7.js

@@ -1 +1,64 @@
 // https://github.com/LiosK/uuidv7/blob/main/src/index.ts
+// https://www.rfc-editor.org/rfc/rfc9562.html#name-uuid-version-7
+import { getRandomValues } from "../web/getRandomValues.js";
+/**
+ * Generate a UUIDv7 string
+ *
+ * UUIDv7 format (RFC 9562):
+ * - 48 bits: Unix timestamp in milliseconds
+ * - 4 bits: version (7)
+ * - 12 bits: random (rand_a)
+ * - 2 bits: variant (10)
+ * - 62 bits: random (rand_b)
+ *
+ * Format: xxxxxxxx-xxxx-7xxx-yxxx-xxxxxxxxxxxx
+ * where y is 8, 9, a, or b (variant bits)
+ */ export function randomUUIDv7(timestamp) {
+    var ts = timestamp !== null && timestamp !== void 0 ? timestamp : Date.now();
+    var bytes = new Uint8Array(16);
+    getRandomValues(bytes);
+    // timestamp (48 bits)
+    bytes[0] = ts / Math.pow(2, 40) & 255;
+    bytes[1] = ts / Math.pow(2, 32) & 255;
+    bytes[2] = ts / Math.pow(2, 24) & 255;
+    bytes[3] = ts / Math.pow(2, 16) & 255;
+    bytes[4] = ts / Math.pow(2, 8) & 255;
+    bytes[5] = ts & 255;
+    // version (4 bits) = 7
+    bytes[6] = bytes[6] & 15 | 112;
+    // variant (2 bits) = 10
+    bytes[8] = bytes[8] & 63 | 128;
+    return formatUUID(bytes);
+}
+function formatUUID(bytes) {
+    var hex = Array.from(bytes).map(function (b) {
+        return b.toString(16).padStart(2, "0");
+    }).join("");
+    return "".concat(hex.slice(0, 8), "-").concat(hex.slice(8, 12), "-").concat(hex.slice(12, 16), "-").concat(hex.slice(16, 20), "-").concat(hex.slice(20));
+}
+/**
+ * Extract timestamp from UUIDv7
+ */ export function parseUUIDv7Timestamp(uuid) {
+    var hex = uuid.replace(/-/g, "");
+    if (hex.length !== 32) {
+        throw new Error("Invalid UUID format");
+    }
+    var tsHex = hex.slice(0, 12);
+    return parseInt(tsHex, 16);
+}
+/**
+ * Check if a string is a valid UUIDv7
+ */ export function isUUIDv7(uuid) {
+    if (!uuid)
+        return false;
+    var match = uuid.match(/^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i);
+    return match !== null;
+}
+/**
+ * Create a UUIDv7 generator with custom options
+ */ export function createRandomUUIDv7() {
+    var _ref = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}, _ref_now = _ref.now, now = _ref_now === void 0 ? Date.now : _ref_now;
+    return function uuidv7(timestamp) {
+        return randomUUIDv7(timestamp !== null && timestamp !== void 0 ? timestamp : now());
+    };
+}

package/lib/crypto/randomUUIDv7.test.js

@@ -0,0 +1,79 @@
+import { describe, expect, test } from "vitest";
+import { createRandomUUIDv7, isUUIDv7, parseUUIDv7Timestamp, randomUUIDv7 } from "./randomUUIDv7.js";
+describe("randomUUIDv7", function () {
+    test("generates valid UUIDv7", function () {
+        var uuid = randomUUIDv7();
+        expect(uuid).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i);
+    });
+    test("generates unique UUIDs", function () {
+        var uuids = new Set();
+        for (var i = 0; i < 1000; i++) {
+            uuids.add(randomUUIDv7());
+        }
+        expect(uuids.size).toBe(1000);
+    });
+    test("respects provided timestamp", function () {
+        var ts = 1704067200000; // 2024-01-01 00:00:00 UTC
+        var uuid = randomUUIDv7(ts);
+        var extractedTs = parseUUIDv7Timestamp(uuid);
+        expect(extractedTs).toBe(ts);
+    });
+    test("UUIDs are sortable by time", function () {
+        var ts1 = 1704067200000;
+        var ts2 = 1704067201000;
+        var uuid1 = randomUUIDv7(ts1);
+        var uuid2 = randomUUIDv7(ts2);
+        expect(uuid1 < uuid2).toBe(true);
+    });
+});
+describe("isUUIDv7", function () {
+    test("returns true for valid UUIDv7", function () {
+        var uuid = randomUUIDv7();
+        expect(isUUIDv7(uuid)).toBe(true);
+    });
+    test("returns false for UUIDv4", function () {
+        expect(isUUIDv7("550e8400-e29b-41d4-a716-446655440000")).toBe(false);
+    });
+    test("returns false for invalid strings", function () {
+        expect(isUUIDv7("")).toBe(false);
+        expect(isUUIDv7(null)).toBe(false);
+        expect(isUUIDv7(undefined)).toBe(false);
+        expect(isUUIDv7("not-a-uuid")).toBe(false);
+    });
+});
+describe("parseUUIDv7Timestamp", function () {
+    test("extracts correct timestamp", function () {
+        var ts = Date.now();
+        var uuid = randomUUIDv7(ts);
+        expect(parseUUIDv7Timestamp(uuid)).toBe(ts);
+    });
+    test("throws for invalid UUID format", function () {
+        expect(function () {
+            return parseUUIDv7Timestamp("invalid");
+        }).toThrow("Invalid UUID format");
+    });
+});
+describe("createRandomUUIDv7", function () {
+    test("creates generator with custom now function", function () {
+        var currentTime = 1704067200000;
+        var generator = createRandomUUIDv7({
+            now: function () {
+                return currentTime;
+            }
+        });
+        var uuid1 = generator();
+        expect(parseUUIDv7Timestamp(uuid1)).toBe(currentTime);
+        currentTime = 1704067201000;
+        var uuid2 = generator();
+        expect(parseUUIDv7Timestamp(uuid2)).toBe(currentTime);
+    });
+    test("generator accepts explicit timestamp override", function () {
+        var generator = createRandomUUIDv7({
+            now: function () {
+                return 1000;
+            }
+        });
+        var uuid = generator(2000);
+        expect(parseUUIDv7Timestamp(uuid)).toBe(2000);
+    });
+});

package/lib/fetch/createFetchWith.js

@@ -146,7 +146,7 @@ export function createFetchWith(param) {
     } : _param_onResponse;
     return function (urlOrRequest, init) {
         return _async_to_generator(function () {
-            var url, req, nextFetch, _ref, res, _tmp;
+            var _ref, url, req, nextFetch, res, _tmp;
             return _ts_generator(this, function (_state) {
                 switch (_state.label) {
                     case 0:

package/lib/index.js

@@ -77,9 +77,10 @@ export { sha1, sha256, sha384, sha512, hmac } from "./crypto/hashing.js";
 export { md5 } from "./crypto/md5.js";
 export { hex } from "./crypto/base.js";
 export { isULID, createULID, ulid, parseULID } from "./crypto/ulid.js";
+export { randomUUIDv7, isUUIDv7, parseUUIDv7Timestamp, createRandomUUIDv7 } from "./crypto/randomUUIDv7.js";
 export { PEM } from "./crypto/pem/pem.js";
 // math
-export { createRandom } from "./maths/random.js";
+export { createRandom, resolveRandom } from "./maths/random.js";
 export { clamp } from "./maths/clamp.js";
 // network
 export { createFetchWith, createFetchWithLogging, dumpResponse, dumpRequest, createFetchWithRetry } from "./fetch/index.js";

package/lib/io/dump.js

@@ -2,8 +2,8 @@ import { ArrayBuffers } from "./ArrayBuffers.js";
 export function toHexDump(data) {
     var _ArrayBuffers_toHex_match;
     return Array.from((_ArrayBuffers_toHex_match = ArrayBuffers.toHex(data).match(/.{1,32}/g)) !== null && _ArrayBuffers_toHex_match !== void 0 ? _ArrayBuffers_toHex_match : []).map(function (v, i) {
-        var idxPrefix = "".concat(i.toString(16).padStart(8, "0"), ":");
         var _v_match;
+        var idxPrefix = "".concat(i.toString(16).padStart(8, "0"), ":");
         var content = Array.from((_v_match = v.match(/.{4}/g)) !== null && _v_match !== void 0 ? _v_match : []).join(" ");
         var chars = Array.from(new Uint8Array(ArrayBuffers.fromHex(v).buffer)).map(function (v) {
             var c = String.fromCharCode(v);

package/lib/langs/mixin.test.js

@@ -75,9 +75,6 @@ function _is_native_reflect_construct() {
 }
 import { expect, test } from "vitest";
 import { mixin } from "./mixin.js";
-function Ent() {
-    return function () { };
-}
 test("mixin", function () {
     // @Ent()
     var User = /*#__PURE__*/ function (_mixin) {

package/lib/maths/clamp.js

@@ -1,90 +1,11 @@
-function _array_like_to_array(arr, len) {
-    if (len == null || len > arr.length)
-        len = arr.length;
-    for (var i = 0, arr2 = new Array(len); i < len; i++)
-        arr2[i] = arr[i];
-    return arr2;
-}
-function _array_with_holes(arr) {
-    if (Array.isArray(arr))
-        return arr;
-}
-function _iterable_to_array_limit(arr, i) {
-    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
-    if (_i == null)
-        return;
-    var _arr = [];
-    var _n = true;
-    var _d = false;
-    var _s, _e;
-    try {
-        for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {
-            _arr.push(_s.value);
-            if (i && _arr.length === i)
-                break;
-        }
-    }
-    catch (err) {
-        _d = true;
-        _e = err;
-    }
-    finally {
-        try {
-            if (!_n && _i["return"] != null)
-                _i["return"]();
-        }
-        finally {
-            if (_d)
-                throw _e;
-        }
-    }
-    return _arr;
-}
-function _non_iterable_rest() {
-    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-}
-function _sliced_to_array(arr, i) {
-    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
-}
-function _type_of(obj) {
-    "@swc/helpers - typeof";
-    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
-}
-function _unsupported_iterable_to_array(o, minLen) {
-    if (!o)
-        return;
-    if (typeof o === "string")
-        return _array_like_to_array(o, minLen);
-    var n = Object.prototype.toString.call(o).slice(8, -1);
-    if (n === "Object" && o.constructor)
-        n = o.constructor.name;
-    if (n === "Map" || n === "Set")
-        return Array.from(n);
-    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))
-        return _array_like_to_array(o, minLen);
-}
-import { isDefined } from "../langs/isDefined.js";
-import { isNil } from "../langs/isNil.js";
-export function clamp(value) {
-    for (var _len = arguments.length, o = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
-        o[_key - 1] = arguments[_key];
-    }
-    var min, max, def;
-    if (o.length === 1 && o[0] && _type_of(o[0]) === "object") {
-        var ref, ref1;
-        ref = o[0], min = ref.min, max = ref.max, ref1 = ref.default, def = ref1 === void 0 ? min : ref1, ref;
-    }
-    else {
-        var ref2, ref3;
-        ref2 = _sliced_to_array(o, 3), min = ref2[0], max = ref2[1], ref3 = ref2[2], def = ref3 === void 0 ? min : ref3, ref2;
-    }
-    if (isNil(value)) {
-        return def;
+export function clamp(value, min, max, def) {
+    if (value == null) {
+        return def !== null && def !== void 0 ? def : min;
     }
-    if (isDefined(min) && value < min) {
+    if (min != null && value < min) {
         return min;
     }
-    if (isDefined(max) && value > max) {
+    if (max != null && value > max) {
         return max;
     }
     return value;

package/lib/maths/clamp.test.js

@@ -63,6 +63,7 @@ import { expect, test } from "vitest";
 import { clamp } from "./clamp.js";
 test("clamp", function () {
     for (var _i = 0, _iter = [
+        // 基本用法
         [
             [
                 null,
@@ -116,68 +117,65 @@ test("clamp", function () {
         ],
         [
             [
-                11,
-                {
-                    min: 1,
-                    max: 10
-                }
+                0,
+                1,
+                10,
+                5
             ],
-            10
+            1
         ],
+        // 只限制 min
         [
             [
-                null,
-                {
-                    min: 1,
-                    max: 10
-                }
+                1,
+                2,
+                undefined
             ],
-            1
+            2
         ],
         [
             [
-                null,
-                {
-                    min: 1,
-                    max: 10,
-                    default: 5
-                }
+                5,
+                2,
+                undefined
             ],
             5
         ],
+        // 只限制 max
         [
             [
-                2n,
                 1,
-                10,
-                5
+                undefined,
+                0
             ],
-            2n
+            0
         ],
         [
             [
-                1,
-                2
+                5,
+                undefined,
+                10
             ],
-            2
+            5
         ],
+        // BigInt
         [
             [
-                1,
-                undefined,
-                0
+                2n,
+                1n,
+                10n,
+                5n
             ],
-            0
-        ],
-        [
-            [],
-            undefined
+            2n
         ],
         [
             [
-                null
+                11n,
+                1n,
+                10n,
+                5n
             ],
-            undefined
+            10n
         ]
     ]; _i < _iter.length; _i++) {
         var _iter__i = _sliced_to_array(_iter[_i], 2), a = _iter__i[0], b = _iter__i[1];