@wener/utils 1.1.51 → 1.1.54

package/lib/scripts/getGenerateContext.js

@@ -1,87 +1,396 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { Errors } from '../errors/Errors.js';
-import { getPackageDir } from '../server/index.js';
-import { formatBytes } from '../strings/formatBytes.js';
-let _root;
-async function cache(dir, url) {
-    const key = path.basename(url);
-    await fs.mkdir(path.join(dir), {
-        recursive: true
-    });
-    const file = path.join(dir, key);
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
     try {
-        await fs.stat(file);
-        console.info('[cache] hit', url);
-        return await fs.readFile(file, 'utf-8');
-    } catch (e) {}
-    console.info('[cache] miss', url);
-    const text = await fetch(url).then((v)=>{
-        if (v.status >= 300) {
-            throw new Error(`[cache] fetch ${url} ${v.status} ${v.statusText}`);
-        }
-        return v.text();
-    });
-    const size = new Blob([
-        text
-    ]).size;
-    console.info(`[cache] write ${file} ${formatBytes(size)} (${size})`);
-    await fs.writeFile(file, text);
-    return text;
+        var info = gen[key](arg);
+        var value = info.value;
+    }
+    catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    }
+    else {
+        Promise.resolve(value).then(_next, _throw);
+    }
 }
-export function getGenerateContext(prefix) {
-    if (prefix) {
-        return Promise.resolve(getGenerateContext()).then((c)=>{
-            const cacheDir = path.resolve(c.cacheDir, prefix);
-            const dataDir = path.resolve(c.dataDir, prefix);
-            const srcDir = path.resolve(c.srcDir, prefix);
-            return {
-                ...c,
-                dataDir,
-                cacheDir,
-                srcDir,
-                cache: (url)=>cache(cacheDir, url),
-                writeData: (file, content)=>write(dataDir, file, content),
-                writeSrc: (file, content)=>write(srcDir, file, content)
-            };
+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);
+        });
+    };
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    }
+    else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _object_spread(target) {
+    for (var i = 1; i < arguments.length; i++) {
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function (key) {
+            _define_property(target, key, source[key]);
         });
     }
-    return _root || Promise.resolve().then(async ()=>{
-        const pkgDir = await getPackageDir();
-        Errors.BadRequest.check(pkgDir, 'pkgDir not found');
-        const dataDir = path.resolve(pkgDir, 'data');
-        const cacheDir = path.resolve(pkgDir, 'cache');
-        const srcDir = path.resolve(pkgDir, 'src');
-        await fs.mkdir(cacheDir, {
-            recursive: true
+    return target;
+}
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+            symbols = symbols.filter(function (sym) {
+                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+        }
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    }
+    else {
+        ownKeys(Object(source)).forEach(function (key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
         });
-        await fs.mkdir(dataDir, {
-            recursive: true
+    }
+    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;
+            }
+        if (op[0] & 5)
+            throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+import fs from "node:fs/promises";
+import path from "node:path";
+import { Errors } from "../errors/Errors.js";
+import { getPackageDir } from "../server/index.js";
+import { formatBytes } from "../strings/formatBytes.js";
+var _root;
+function cache(dir, url) {
+    return _async_to_generator(function () {
+        var key, file, e, text, size;
+        return _ts_generator(this, function (_state) {
+            switch (_state.label) {
+                case 0:
+                    key = path.basename(url);
+                    return [
+                        4,
+                        fs.mkdir(path.join(dir), {
+                            recursive: true
+                        })
+                    ];
+                case 1:
+                    _state.sent();
+                    file = path.join(dir, key);
+                    _state.label = 2;
+                case 2:
+                    _state.trys.push([
+                        2,
+                        5,
+                        ,
+                        6
+                    ]);
+                    return [
+                        4,
+                        fs.stat(file)
+                    ];
+                case 3:
+                    _state.sent();
+                    console.info("[cache] hit", url);
+                    return [
+                        4,
+                        fs.readFile(file, "utf-8")
+                    ];
+                case 4:
+                    return [
+                        2,
+                        _state.sent()
+                    ];
+                case 5:
+                    e = _state.sent();
+                    return [
+                        3,
+                        6
+                    ];
+                case 6:
+                    console.info("[cache] miss", url);
+                    return [
+                        4,
+                        fetch(url).then(function (v) {
+                            if (v.status >= 300) {
+                                throw new Error("[cache] fetch ".concat(url, " ").concat(v.status, " ").concat(v.statusText));
+                            }
+                            return v.text();
+                        })
+                    ];
+                case 7:
+                    text = _state.sent();
+                    size = new Blob([
+                        text
+                    ]).size;
+                    console.info("[cache] write ".concat(file, " ").concat(formatBytes(size), " (").concat(size, ")"));
+                    return [
+                        4,
+                        fs.writeFile(file, text)
+                    ];
+                case 8:
+                    _state.sent();
+                    return [
+                        2,
+                        text
+                    ];
+            }
         });
-        return _root = Object.freeze({
-            pkgDir,
-            dataDir,
-            cacheDir,
-            srcDir,
-            rootCacheDir: cacheDir,
-            rootDataDir: dataDir,
-            cache: (url)=>cache(cacheDir, url),
-            writeData: (file, content)=>write(dataDir, file, content),
-            writeSrc: (file, content)=>write(srcDir, file, content)
+    })();
+}
+export function getGenerateContext(prefix) {
+    if (prefix) {
+        return Promise.resolve(getGenerateContext()).then(function (c) {
+            var cacheDir = path.resolve(c.cacheDir, prefix);
+            var dataDir = path.resolve(c.dataDir, prefix);
+            var srcDir = path.resolve(c.srcDir, prefix);
+            return _object_spread_props(_object_spread({}, c), {
+                dataDir: dataDir,
+                cacheDir: cacheDir,
+                srcDir: srcDir,
+                cache: function (url) {
+                    return cache(cacheDir, url);
+                },
+                writeData: function (file, content) {
+                    return write(dataDir, file, content);
+                },
+                writeSrc: function (file, content) {
+                    return write(srcDir, file, content);
+                }
+            });
         });
+    }
+    return _root || Promise.resolve().then(function () {
+        return _async_to_generator(function () {
+            var pkgDir, dataDir, cacheDir, srcDir;
+            return _ts_generator(this, function (_state) {
+                switch (_state.label) {
+                    case 0:
+                        return [
+                            4,
+                            getPackageDir()
+                        ];
+                    case 1:
+                        pkgDir = _state.sent();
+                        Errors.BadRequest.check(pkgDir, "pkgDir not found");
+                        dataDir = path.resolve(pkgDir, "data");
+                        cacheDir = path.resolve(pkgDir, "cache");
+                        srcDir = path.resolve(pkgDir, "src");
+                        return [
+                            4,
+                            fs.mkdir(cacheDir, {
+                                recursive: true
+                            })
+                        ];
+                    case 2:
+                        _state.sent();
+                        return [
+                            4,
+                            fs.mkdir(dataDir, {
+                                recursive: true
+                            })
+                        ];
+                    case 3:
+                        _state.sent();
+                        return [
+                            2,
+                            _root = Object.freeze({
+                                pkgDir: pkgDir,
+                                dataDir: dataDir,
+                                cacheDir: cacheDir,
+                                srcDir: srcDir,
+                                rootCacheDir: cacheDir,
+                                rootDataDir: dataDir,
+                                cache: function (url) {
+                                    return cache(cacheDir, url);
+                                },
+                                writeData: function (file, content) {
+                                    return write(dataDir, file, content);
+                                },
+                                writeSrc: function (file, content) {
+                                    return write(srcDir, file, content);
+                                }
+                            })
+                        ];
+                }
+            });
+        })();
     });
 }
-async function write(dir, file, content) {
-    const size = new Blob([
-        content
-    ]).size;
-    const dst = path.join(dir, file);
-    let last;
-    try {
-        last = (await fs.stat(dst)).size;
-    } catch  {}
-    console.info(`[write] ${path.relative(_root.pkgDir, dir)} ${file} ${last ? last !== size ? `${formatBytes(last)} (${last}) -> ` : 'SAME SIZE ' : ''}${formatBytes(size)} (${size})`);
-    await fs.writeFile(dst, content);
+function write(dir, file, content) {
+    return _async_to_generator(function () {
+        var size, dst, last, e;
+        return _ts_generator(this, function (_state) {
+            switch (_state.label) {
+                case 0:
+                    size = new Blob([
+                        content
+                    ]).size;
+                    dst = path.join(dir, file);
+                    _state.label = 1;
+                case 1:
+                    _state.trys.push([
+                        1,
+                        3,
+                        ,
+                        4
+                    ]);
+                    return [
+                        4,
+                        fs.stat(dst)
+                    ];
+                case 2:
+                    last = _state.sent().size;
+                    return [
+                        3,
+                        4
+                    ];
+                case 3:
+                    e = _state.sent();
+                    return [
+                        3,
+                        4
+                    ];
+                case 4:
+                    console.info("[write] ".concat(path.relative(_root.pkgDir, dir), " ").concat(file, " ").concat(last ? last !== size ? "".concat(formatBytes(last), " (").concat(last, ") -> ") : "SAME SIZE " : "").concat(formatBytes(size), " (").concat(size, ")"));
+                    return [
+                        4,
+                        fs.writeFile(dst, content)
+                    ];
+                case 5:
+                    _state.sent();
+                    return [
+                        2
+                    ];
+            }
+        });
+    })();
 }
-
-//# sourceMappingURL=getGenerateContext.js.map

package/lib/server/crypto/md5.js

@@ -2,5 +2,3 @@ import { createHash } from 'node:crypto';
 export function md5(input) {
     return createHash('md5').update(input).digest('hex');
 }
-
-//# sourceMappingURL=md5.js.map

package/lib/server/fetch/createFetchWithProxy.js

@@ -1,4 +1,2 @@
-import { createFetchWithProxyByUndici } from './createFetchWithProxyByUndici.js';
-export const createFetchWithProxy = createFetchWithProxyByUndici;
-
-//# sourceMappingURL=createFetchWithProxy.js.map
+import { createFetchWithProxyByUndici } from "./createFetchWithProxyByUndici.js";
+export var createFetchWithProxy = createFetchWithProxyByUndici;