@wener/utils 1.1.50 → 1.1.53

package/lib/server/polyfill/polyfillJsDom.js

@@ -1,64 +1,270 @@
-import { getGlobalThis } from '../../runtime/getGlobalThis.js';
-export async function polyfillJsDom() {
-    if (typeof window !== 'undefined') {
-        return false;
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
     }
-    const globalThis = getGlobalThis();
-    const { ResourceLoader, JSDOM } = await import('jsdom');
-    // https://github.com/lukechilds/window/blob/master/src/index.js
-    // eslint-disable-next-line @typescript-eslint/no-extraneous-class
-    let Window = class Window {
-        constructor(opts = {}){
-            const { proxy, strictSSL, userAgent, ...jsdomOpts } = opts;
-            const resources = new ResourceLoader({
-                proxy,
-                strictSSL,
-                userAgent
-            });
-            return new JSDOM('', Object.assign(jsdomOpts, {
-                resources
-            })).window;
-        }
-    };
-    // https://github.com/lukechilds/browser-env/blob/master/src/index.js
-    // Default jsdom config.
-    // These settings must override any custom settings to make sure we can iterate
-    // over the window object.
-    const defaultJsdomConfig = {
+    catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    }
+    else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function () {
+        var self = this, args = arguments;
+        return new Promise(function (resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
     };
-    // IIFE executed on import to return an array of global Node.js properties that
-    // conflict with global browser properties.
-    const protectedProperties = (()=>Object.getOwnPropertyNames(new Window(defaultJsdomConfig)).filter((prop)=>typeof globalThis[prop] !== 'undefined'))();
-    function installEnv(...args) {
-        // Sets up global browser environment
-        // Extract options from args
-        const properties = args.filter((arg)=>Array.isArray(arg))[0];
-        const userJsdomConfig = args.filter((arg)=>!Array.isArray(arg))[0];
-        // Create window object
-        const window1 = new Window(Object.assign({}, userJsdomConfig, defaultJsdomConfig));
-        // Get all global browser properties
-        Object.getOwnPropertyNames(window1)// Remove protected properties
-        .filter((prop)=>!protectedProperties.includes(prop))// If we're only applying specific required properties remove everything else
-        .filter((prop)=>!(properties && properties.indexOf(prop) === -1)).filter((prop)=>{
-            switch(prop){
-                case 'undefined':
-                    return false;
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _object_without_properties(source, excluded) {
+    if (source == null)
+        return {};
+    var target = _object_without_properties_loose(source, excluded);
+    var key, i;
+    if (Object.getOwnPropertySymbols) {
+        var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+        for (i = 0; i < sourceSymbolKeys.length; i++) {
+            key = sourceSymbolKeys[i];
+            if (excluded.indexOf(key) >= 0)
+                continue;
+            if (!Object.prototype.propertyIsEnumerable.call(source, key))
+                continue;
+            target[key] = source[key];
+        }
+    }
+    return target;
+}
+function _object_without_properties_loose(source, excluded) {
+    if (source == null)
+        return {};
+    var target = {};
+    var sourceKeys = Object.keys(source);
+    var key, i;
+    for (i = 0; i < sourceKeys.length; i++) {
+        key = sourceKeys[i];
+        if (excluded.indexOf(key) >= 0)
+            continue;
+        target[key] = source[key];
+    }
+    return target;
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function () {
+            if (t[0] & 1)
+                throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function () {
+        return this;
+    }), g;
+    function verb(n) {
+        return function (v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f)
+            throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _)
+            try {
+                if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done)
+                    return t;
+                if (y = 0, t)
+                    op = [
+                        op[0] & 2,
+                        t.value
+                    ];
+                switch (op[0]) {
+                    case 0:
+                    case 1:
+                        t = op;
+                        break;
+                    case 4:
+                        _.label++;
+                        return {
+                            value: op[1],
+                            done: false
+                        };
+                    case 5:
+                        _.label++;
+                        y = op[1];
+                        op = [
+                            0
+                        ];
+                        continue;
+                    case 7:
+                        op = _.ops.pop();
+                        _.trys.pop();
+                        continue;
+                    default:
+                        if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                            _ = 0;
+                            continue;
+                        }
+                        if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                            _.label = op[1];
+                            break;
+                        }
+                        if (op[0] === 6 && _.label < t[1]) {
+                            _.label = t[1];
+                            t = op;
+                            break;
+                        }
+                        if (t && _.label < t[2]) {
+                            _.label = t[2];
+                            _.ops.push(op);
+                            break;
+                        }
+                        if (t[2])
+                            _.ops.pop();
+                        _.trys.pop();
+                        continue;
+                }
+                op = body.call(thisArg, _);
+            }
+            catch (e) {
+                op = [
+                    6,
+                    e
+                ];
+                y = 0;
+            }
+            finally {
+                f = t = 0;
             }
-            return true;
-        })// Copy what's left to the Node.js global scope
-        .forEach((prop)=>{
-            // console.debug(`define globalThis.${prop}`);
-            Object.defineProperty(globalThis, prop, {
-                configurable: true,
-                get: ()=>window1[prop]
+        if (op[0] & 5)
+            throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+import { getGlobalThis } from "../../web/getGlobalThis.js";
+export function polyfillJsDom() {
+    return _async_to_generator(function () {
+        var globalThis, _ref, ResourceLoader, JSDOM, Window, defaultJsdomConfig, protectedProperties;
+        function installEnv() {
+            for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+                args[_key] = arguments[_key];
+            }
+            // Sets up global browser environment
+            // Extract options from args
+            var properties = args.filter(function (arg) {
+                return Array.isArray(arg);
+            })[0];
+            var userJsdomConfig = args.filter(function (arg) {
+                return !Array.isArray(arg);
+            })[0];
+            // Create window object
+            var _$window = new Window(Object.assign({}, userJsdomConfig, defaultJsdomConfig));
+            // Get all global browser properties
+            Object.getOwnPropertyNames(_$window) // Remove protected properties
+                .filter(function (prop) {
+                return !protectedProperties.includes(prop);
+            }) // If we're only applying specific required properties remove everything else
+                .filter(function (prop) {
+                return !(properties && properties.indexOf(prop) === -1);
+            }).filter(function (prop) {
+                switch (prop) {
+                    case "undefined":
+                        return false;
+                }
+                return true;
+            }) // Copy what's left to the Node.js global scope
+                .forEach(function (prop) {
+                // console.debug(`define globalThis.${prop}`);
+                Object.defineProperty(globalThis, prop, {
+                    configurable: true,
+                    get: function () {
+                        return _$window[prop];
+                    }
+                });
             });
+            return _$window;
+        }
+        return _ts_generator(this, function (_state) {
+            switch (_state.label) {
+                case 0:
+                    if (typeof window !== "undefined") {
+                        return [
+                            2,
+                            false
+                        ];
+                    }
+                    globalThis = getGlobalThis();
+                    return [
+                        4,
+                        import("jsdom")
+                    ];
+                case 1:
+                    _ref = _state.sent(), ResourceLoader = _ref.ResourceLoader, JSDOM = _ref.JSDOM;
+                    // https://github.com/lukechilds/window/blob/master/src/index.js
+                    // eslint-disable-next-line @typescript-eslint/no-extraneous-class
+                    Window = function Window() {
+                        "use strict";
+                        var opts = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+                        _class_call_check(this, Window);
+                        var proxy = opts.proxy, strictSSL = opts.strictSSL, userAgent = opts.userAgent, jsdomOpts = _object_without_properties(opts, [
+                            "proxy",
+                            "strictSSL",
+                            "userAgent"
+                        ]);
+                        var resources = new ResourceLoader({
+                            proxy: proxy,
+                            strictSSL: strictSSL,
+                            userAgent: userAgent
+                        });
+                        return new JSDOM("", Object.assign(jsdomOpts, {
+                            resources: resources
+                        })).window;
+                    };
+                    // https://github.com/lukechilds/browser-env/blob/master/src/index.js
+                    // Default jsdom config.
+                    // These settings must override any custom settings to make sure we can iterate
+                    // over the window object.
+                    defaultJsdomConfig = {};
+                    // IIFE executed on import to return an array of global Node.js properties that
+                    // conflict with global browser properties.
+                    protectedProperties = function () {
+                        return Object.getOwnPropertyNames(new Window(defaultJsdomConfig)).filter(function (prop) {
+                            return typeof globalThis[prop] !== "undefined";
+                        });
+                    }();
+                    installEnv({
+                        url: "http://localhost"
+                    });
+                    return [
+                        2,
+                        true
+                    ];
+            }
         });
-        return window1;
-    }
-    installEnv({
-        url: 'http://localhost'
-    });
-    return true;
+    })();
 }
-
-//# sourceMappingURL=polyfillJsDom.js.map

package/lib/server/polyfill/polyfillWebSocket.js

@@ -1,21 +1,21 @@
-import { getGlobalThis } from '../../runtime/getGlobalThis.js';
+import { getGlobalThis } from "../../web/getGlobalThis.js";
 export function polyfillWebSocket(ws) {
-    const globalThis = getGlobalThis();
-    if ('WebSocket' in globalThis) {
+    var globalThis = getGlobalThis();
+    if ("WebSocket" in globalThis) {
         return false;
     }
-    if (ws && 'then' in ws) {
-        return ws.then((v)=>{
-            return polyfillWebSocket(v?.default || v);
+    if (ws && "then" in ws) {
+        return ws.then(function (v) {
+            return polyfillWebSocket((v === null || v === void 0 ? void 0 : v.default) || v);
         });
     }
     if (ws) {
-        const { WebSocket } = ws;
+        var WebSocket = ws.WebSocket;
         Object.assign(globalThis, {
-            WebSocket
+            WebSocket: WebSocket
         });
     }
-    return import('ws').then((ws)=>polyfillWebSocket(ws));
+    return import("ws").then(function (ws) {
+        return polyfillWebSocket(ws);
+    });
 }
-
-//# sourceMappingURL=polyfillWebSocket.js.map

package/lib/server/ws.js

@@ -1,3 +1 @@
-export * from './polyfill/polyfillWebSocket.js';
-
-//# sourceMappingURL=ws.js.map
+export * from "./polyfill/polyfillWebSocket.js";

package/lib/strings/bytes.test.js

@@ -0,0 +1,327 @@
+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 _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 { describe, expect, test } from "vitest";
+import { formatBytes } from "./formatBytes.js";
+import { parseBytes } from "./parseBytes.js";
+describe("bytes", function () {
+    describe("formatBytes", function () {
+        var testCases = [
+            // IEC standard by default
+            [
+                1024,
+                undefined,
+                "1.0 KiB"
+            ],
+            [
+                1024 * 1024,
+                undefined,
+                "1.0 MiB"
+            ],
+            [
+                1536,
+                undefined,
+                "1.5 KiB"
+            ],
+            // SI standard
+            [
+                1000,
+                true,
+                "1.0 kB"
+            ],
+            [
+                1000 * 1000,
+                true,
+                "1.0 MB"
+            ],
+            [
+                1500,
+                true,
+                "1.5 kB"
+            ],
+            // Small byte values
+            [
+                100,
+                undefined,
+                "100 B"
+            ],
+            [
+                999,
+                undefined,
+                "999 B"
+            ],
+            [
+                1023,
+                undefined,
+                "1023 B"
+            ],
+            // SI small byte values
+            [
+                100,
+                true,
+                "100 B"
+            ],
+            [
+                999,
+                true,
+                "999 B"
+            ],
+            // Decimal places
+            [
+                1536,
+                {
+                    dp: 2
+                },
+                "1.50 KiB"
+            ],
+            [
+                1536,
+                {
+                    dp: 3
+                },
+                "1.500 KiB"
+            ],
+            // Force unit
+            [
+                1024 * 1024,
+                {
+                    unit: "KiB"
+                },
+                "1024.0 KiB"
+            ],
+            [
+                1000 * 1000,
+                {
+                    si: true,
+                    unit: "kB"
+                },
+                "1000.0 kB"
+            ]
+        ];
+        test("should format bytes correctly", function () {
+            var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+            try {
+                for (var _iterator = testCases[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+                    var _step_value = _sliced_to_array(_step.value, 3), bytes = _step_value[0], options = _step_value[1], expected = _step_value[2];
+                    expect(formatBytes(bytes, options)).toBe(expected);
+                }
+            }
+            catch (err) {
+                _didIteratorError = true;
+                _iteratorError = err;
+            }
+            finally {
+                try {
+                    if (!_iteratorNormalCompletion && _iterator.return != null) {
+                        _iterator.return();
+                    }
+                }
+                finally {
+                    if (_didIteratorError) {
+                        throw _iteratorError;
+                    }
+                }
+            }
+        });
+    });
+    describe("parseBytes", function () {
+        var validTestCases = [
+            [
+                "1B",
+                {
+                    value: 1,
+                    unit: "B",
+                    bytes: 1
+                }
+            ],
+            [
+                "1KB",
+                {
+                    value: 1,
+                    unit: "KB",
+                    bytes: 1000
+                }
+            ],
+            [
+                "1KiB",
+                {
+                    value: 1,
+                    unit: "KiB",
+                    bytes: 1024
+                }
+            ],
+            [
+                "1.5GB",
+                {
+                    value: 1.5,
+                    unit: "GB",
+                    bytes: 1.5 * Math.pow(1000, 3)
+                }
+            ],
+            [
+                "2TiB",
+                {
+                    value: 2,
+                    unit: "TiB",
+                    bytes: 2 * Math.pow(1024, 4)
+                }
+            ],
+            // single letter
+            [
+                "1G",
+                {
+                    value: 1,
+                    unit: "G",
+                    bytes: Math.pow(1000, 3)
+                }
+            ],
+            [
+                "1.5T",
+                {
+                    value: 1.5,
+                    unit: "T",
+                    bytes: 1.5 * Math.pow(1000, 4)
+                }
+            ],
+            // case-insensitive
+            [
+                "1gb",
+                {
+                    value: 1,
+                    unit: "gb",
+                    bytes: Math.pow(1000, 3)
+                }
+            ],
+            [
+                "1.5 mib",
+                {
+                    value: 1.5,
+                    unit: "mib",
+                    bytes: 1.5 * Math.pow(1024, 2)
+                }
+            ],
+            // whitespace
+            [
+                " 1.5 GB ",
+                {
+                    value: 1.5,
+                    unit: "GB",
+                    bytes: 1.5 * Math.pow(1000, 3)
+                }
+            ]
+        ];
+        test("should parse valid byte strings", function () {
+            var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+            try {
+                for (var _iterator = validTestCases[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+                    var _step_value = _sliced_to_array(_step.value, 2), str = _step_value[0], expected = _step_value[1];
+                    expect(parseBytes(str)).toEqual(expected);
+                }
+            }
+            catch (err) {
+                _didIteratorError = true;
+                _iteratorError = err;
+            }
+            finally {
+                try {
+                    if (!_iteratorNormalCompletion && _iterator.return != null) {
+                        _iterator.return();
+                    }
+                }
+                finally {
+                    if (_didIteratorError) {
+                        throw _iteratorError;
+                    }
+                }
+            }
+        });
+        var invalidTestCases = [
+            "abc",
+            "1.5XB",
+            ""
+        ];
+        test("should return undefined for invalid strings", function () {
+            var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+            try {
+                for (var _iterator = invalidTestCases[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+                    var str = _step.value;
+                    expect(parseBytes(str)).toBeUndefined();
+                }
+            }
+            catch (err) {
+                _didIteratorError = true;
+                _iteratorError = err;
+            }
+            finally {
+                try {
+                    if (!_iteratorNormalCompletion && _iterator.return != null) {
+                        _iterator.return();
+                    }
+                }
+                finally {
+                    if (_didIteratorError) {
+                        throw _iteratorError;
+                    }
+                }
+            }
+        });
+    });
+});