@unpackjs/core 2.1.0 → 2.3.0

package/dist/loadEnv.d.ts

@@ -0,0 +1,64 @@
+export type LoadEnvOptions = {
+    /**
+     * The root path to load the env file
+     * @default process.cwd()
+     */
+    cwd?: string;
+    /**
+     * Used to specify the name of the .env.[mode] file
+     * @default process.env.NODE_ENV
+     */
+    mode?: string;
+    /**
+     * The prefix of public variables
+     * @default ['PUBLIC_']
+     */
+    prefixes?: string | string[];
+    /**
+     * Specify a target object to store environment variables.
+     * If not provided, variables will be written to `process.env`.
+     * @default process.env
+     */
+    processEnv?: Record<string, string>;
+};
+export type LoadEnvResult = {
+    /**
+     * All env variables in the .env file
+     */
+    parsed: Record<string, string>;
+    /**
+     * The absolute paths to all env files
+     */
+    filePaths: string[];
+    /**
+     * Env variables that start with prefixes.
+     *
+     * @example
+     * ```ts
+     * {
+     *   PUBLIC_FOO: 'bar',
+     * }
+     * ```
+     **/
+    rawPublicVars: Record<string, string | undefined>;
+    /**
+     * Formatted env variables that start with prefixes.
+     * The keys contain the prefixes `process.env.*` and `import.meta.env.*`.
+     * The values are processed by `JSON.stringify`.
+     *
+     * @example
+     * ```ts
+     * {
+     *   'process.env.PUBLIC_FOO': '"bar"',
+     *   'import.meta.env.PUBLIC_FOO': '"bar"',
+     * }
+     * ```
+     **/
+    publicVars: Record<string, string>;
+    /**
+     * Clear the env variables mounted on `process.env`
+     */
+    cleanup: () => void;
+};
+export declare function loadEnv({ cwd, mode, prefixes, processEnv, }?: LoadEnvOptions): LoadEnvResult;
+//# sourceMappingURL=loadEnv.d.ts.map

package/dist/loadEnv.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadEnv.d.ts","sourceRoot":"","sources":["../src/loadEnv.ts"],"names":[],"mappings":"AAkDA,MAAM,MAAM,cAAc,GAAG;IAC3B;;;OAGG;IACH,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ;;;OAGG;IACH,IAAI,CAAC,EAAE,MAAM,CAAA;IACb;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAA;IAC5B;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CACpC,CAAA;AAED,MAAM,MAAM,aAAa,GAAG;IAC1B;;OAEG;IACH,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC9B;;OAEG;IACH,SAAS,EAAE,MAAM,EAAE,CAAA;IACnB;;;;;;;;;QASI;IACJ,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAA;IACjD;;;;;;;;;;;;QAYI;IACJ,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAClC;;OAEG;IACH,OAAO,EAAE,MAAM,IAAI,CAAA;CACpB,CAAA;AAED,wBAAgB,OAAO,CAAC,EACtB,GAAmB,EACnB,IAAmB,EACnB,QAAsB,EACtB,UAAkD,GACnD,GAAE,cAAmB,GAAG,aAAa,CA0ErC"}

package/dist/loadEnv.js

@@ -0,0 +1,80 @@
+import 'module';
+/*#__PURE__*/ import.meta.url;
+import node_fs from "node:fs";
+import { join } from "node:path";
+import { expand } from "dotenv-expand";
+import { colors } from "./colors.js";
+import { isFileSync } from "./fs.js";
+import { logger } from "./logger.js";
+import { getNodeEnv } from "./utils.js";
+const DOTENV_LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/gm;
+function parse(src) {
+    const obj = {};
+    let lines = src.toString();
+    lines = lines.replace(/\r\n?/gm, '\n');
+    let match;
+    while(null != (match = DOTENV_LINE.exec(lines))){
+        const key = match[1];
+        let value = match[2] || '';
+        value = value.trim();
+        const maybeQuote = value[0];
+        value = value.replace(/^(['"`])([\s\S]*)\1$/gm, '$2');
+        if ('"' === maybeQuote) {
+            value = value.replace(/\\n/g, '\n');
+            value = value.replace(/\\r/g, '\r');
+        }
+        obj[key] = value;
+    }
+    return obj;
+}
+function loadEnv({ cwd = process.cwd(), mode = getNodeEnv(), prefixes = [
+    'PUBLIC_'
+], processEnv = process.env } = {}) {
+    if ('local' === mode) throw new Error(`${colors.yellow('local')} cannot be used as a value for env mode, because ${colors.yellow('.env.local')} represents a temporary local file. Please use another value.`);
+    const filenames = [
+        '.env',
+        '.env.local',
+        `.env.${mode}`,
+        `.env.${mode}.local`
+    ];
+    const filePaths = filenames.map((filename)=>join(cwd, filename)).filter(isFileSync);
+    const parsed = {};
+    for (const envPath of filePaths){
+        Object.assign(parsed, parse(node_fs.readFileSync(envPath)));
+        logger.debug('loaded env file:', envPath);
+    }
+    if (parsed.NODE_ENV) processEnv.NODE_ENV = parsed.NODE_ENV;
+    expand({
+        parsed,
+        processEnv
+    });
+    const publicVars = {};
+    const rawPublicVars = {};
+    const normalizedPrefixes = Array.isArray(prefixes) ? prefixes : [
+        prefixes
+    ];
+    for (const key of Object.keys(processEnv))if (normalizedPrefixes.some((prefix)=>key.startsWith(prefix))) {
+        const val = processEnv[key];
+        publicVars[`import.meta.env.${key}`] = JSON.stringify(val);
+        publicVars[`process.env.${key}`] = JSON.stringify(val);
+        rawPublicVars[key] = val;
+    }
+    publicVars['import.meta.env'] = JSON.stringify(rawPublicVars);
+    publicVars['process.env'] = JSON.stringify(rawPublicVars);
+    let cleaned = false;
+    const cleanup = ()=>{
+        if (cleaned) return;
+        for (const key of Object.keys(parsed))if ('NODE_ENV' !== key) {
+            if (processEnv[key] === parsed[key]) delete processEnv[key];
+        }
+        cleaned = true;
+    };
+    return {
+        parsed,
+        cleanup,
+        filePaths,
+        publicVars,
+        rawPublicVars
+    };
+}
+export { loadEnv };

package/dist/loadingAnimation.cjs

@@ -0,0 +1,76 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    LoadingAnimation: ()=>LoadingAnimation
+});
+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;
+}
+class LoadingAnimation {
+    getCurrentChar() {
+        const now = Date.now();
+        if (now - this.lastUpdateTime >= this.interval) {
+            this.currentIndex = (this.currentIndex + 1) % this.chars.length;
+            this.lastUpdateTime = now;
+        }
+        return this.chars[this.currentIndex];
+    }
+    reset() {
+        this.currentIndex = 0;
+        this.lastUpdateTime = 0;
+    }
+    constructor(){
+        _define_property(this, "chars", [
+            "\u280B",
+            "\u2819",
+            "\u2839",
+            "\u2838",
+            "\u283C",
+            "\u2834",
+            "\u2826",
+            "\u2827",
+            "\u2807",
+            "\u280F"
+        ]);
+        _define_property(this, "currentIndex", 0);
+        _define_property(this, "lastUpdateTime", 0);
+        _define_property(this, "interval", 150);
+    }
+}
+exports.LoadingAnimation = __webpack_exports__.LoadingAnimation;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "LoadingAnimation"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/loadingAnimation.d.ts

@@ -0,0 +1,9 @@
+export declare class LoadingAnimation {
+    private chars;
+    private currentIndex;
+    private lastUpdateTime;
+    private interval;
+    getCurrentChar(): string;
+    reset(): void;
+}
+//# sourceMappingURL=loadingAnimation.d.ts.map

package/dist/loadingAnimation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadingAnimation.d.ts","sourceRoot":"","sources":["../src/loadingAnimation.ts"],"names":[],"mappings":"AAAA,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,KAAK,CAA+D;IAC5E,OAAO,CAAC,YAAY,CAAI;IACxB,OAAO,CAAC,cAAc,CAAI;IAC1B,OAAO,CAAC,QAAQ,CAAM;IAEtB,cAAc,IAAI,MAAM;IASxB,KAAK,IAAI,IAAI;CAId"}

package/dist/loadingAnimation.js

@@ -0,0 +1,44 @@
+import 'module';
+/*#__PURE__*/ import.meta.url;
+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;
+}
+class LoadingAnimation {
+    getCurrentChar() {
+        const now = Date.now();
+        if (now - this.lastUpdateTime >= this.interval) {
+            this.currentIndex = (this.currentIndex + 1) % this.chars.length;
+            this.lastUpdateTime = now;
+        }
+        return this.chars[this.currentIndex];
+    }
+    reset() {
+        this.currentIndex = 0;
+        this.lastUpdateTime = 0;
+    }
+    constructor(){
+        _define_property(this, "chars", [
+            "\u280B",
+            "\u2819",
+            "\u2839",
+            "\u2838",
+            "\u283C",
+            "\u2834",
+            "\u2826",
+            "\u2827",
+            "\u2807",
+            "\u280F"
+        ]);
+        _define_property(this, "currentIndex", 0);
+        _define_property(this, "lastUpdateTime", 0);
+        _define_property(this, "interval", 150);
+    }
+}
+export { LoadingAnimation };

package/dist/logger.cjs

@@ -38,7 +38,6 @@ __webpack_require__.d(__webpack_exports__, {
 const external_node_readline_namespaceObject = require("node:readline");
 var external_node_readline_default = /*#__PURE__*/ __webpack_require__.n(external_node_readline_namespaceObject);
 const external_colors_cjs_namespaceObject = require("./colors.cjs");
-var external_colors_cjs_default = /*#__PURE__*/ __webpack_require__.n(external_colors_cjs_namespaceObject);
 const index_cjs_namespaceObject = require("./types/index.cjs");
 const external_utils_cjs_namespaceObject = require("./utils.cjs");
 const prefixes = {
@@ -48,11 +47,11 @@ const prefixes = {
     info: "\u2139",
     ready: "\u2713",
     event: "\xbb",
-    debug: "\u2699"
+    debug: '-'
 };
 const createLogger = ()=>{
     const log = (type, message, ...args)=>{
-        const label = external_colors_cjs_default()[index_cjs_namespaceObject.LogColor[type]](external_colors_cjs_default().bold(prefixes[type]));
+        const label = external_colors_cjs_namespaceObject.colors[index_cjs_namespaceObject.LogColor[type]](prefixes[type]);
         let text = '';
         switch(type){
             case 'error':
@@ -62,12 +61,12 @@ const createLogger = ()=>{
                         name = name.slice(7);
                         rest = rest.map((line)=>line.slice(2));
                     }
-                    text = `${external_colors_cjs_default().red(name)}\n${external_colors_cjs_default().dim(rest.join('\n'))}`;
-                } else text = external_colors_cjs_default().red(message.message);
-                else text = external_colors_cjs_default().red(message);
+                    text = `${external_colors_cjs_namespaceObject.colors.red(name)}\n${external_colors_cjs_namespaceObject.colors.dim(rest.join('\n'))}`;
+                } else text = external_colors_cjs_namespaceObject.colors.red(message.message);
+                else text = external_colors_cjs_namespaceObject.colors.red(message);
                 break;
             case 'warn':
-                text = external_colors_cjs_default().yellow(message);
+                text = external_colors_cjs_namespaceObject.colors.yellow(message);
                 break;
             default:
                 text = message;

package/dist/logger.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../src/logger.ts"],"names":[],"mappings":"AAEA,OAAO,EAA0B,KAAK,MAAM,EAAE,MAAM,iBAAiB,CAAA;AA2ErE,eAAO,MAAM,MAAM,QAAiB,CAAA"}
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../src/logger.ts"],"names":[],"mappings":"AAEA,OAAO,EAAY,KAAK,MAAM,EAAgB,MAAM,iBAAiB,CAAA;AA2ErE,eAAO,MAAM,MAAM,QAAiB,CAAA"}

package/dist/logger.js

@@ -1,9 +1,9 @@
-import __rslib_shim_module__ from 'module';
+import 'module';
 /*#__PURE__*/ import.meta.url;
-import * as __WEBPACK_EXTERNAL_MODULE_node_readline_91c31510__ from "node:readline";
-import * as __WEBPACK_EXTERNAL_MODULE__colors_js_b738ede3__ from "./colors.js";
-import * as __WEBPACK_EXTERNAL_MODULE__types_index_js_63ede62f__ from "./types/index.js";
-import * as __WEBPACK_EXTERNAL_MODULE__utils_js_d88b7fe1__ from "./utils.js";
+import node_readline from "node:readline";
+import { colors } from "./colors.js";
+import { LogColor } from "./types/index.js";
+import { isDebug } from "./utils.js";
 const prefixes = {
     wait: "\u25CB",
     error: "\u2A2F",
@@ -11,11 +11,11 @@ const prefixes = {
     info: "\u2139",
     ready: "\u2713",
     event: "\xbb",
-    debug: "\u2699"
+    debug: '-'
 };
 const createLogger = ()=>{
     const log = (type, message, ...args)=>{
-        const label = __WEBPACK_EXTERNAL_MODULE__colors_js_b738ede3__["default"][__WEBPACK_EXTERNAL_MODULE__types_index_js_63ede62f__.LogColor[type]](__WEBPACK_EXTERNAL_MODULE__colors_js_b738ede3__["default"].bold(prefixes[type]));
+        const label = colors[LogColor[type]](prefixes[type]);
         let text = '';
         switch(type){
             case 'error':
@@ -25,18 +25,18 @@ const createLogger = ()=>{
                         name = name.slice(7);
                         rest = rest.map((line)=>line.slice(2));
                     }
-                    text = `${__WEBPACK_EXTERNAL_MODULE__colors_js_b738ede3__["default"].red(name)}\n${__WEBPACK_EXTERNAL_MODULE__colors_js_b738ede3__["default"].dim(rest.join('\n'))}`;
-                } else text = __WEBPACK_EXTERNAL_MODULE__colors_js_b738ede3__["default"].red(message.message);
-                else text = __WEBPACK_EXTERNAL_MODULE__colors_js_b738ede3__["default"].red(message);
+                    text = `${colors.red(name)}\n${colors.dim(rest.join('\n'))}`;
+                } else text = colors.red(message.message);
+                else text = colors.red(message);
                 break;
             case 'warn':
-                text = __WEBPACK_EXTERNAL_MODULE__colors_js_b738ede3__["default"].yellow(message);
+                text = colors.yellow(message);
                 break;
             default:
                 text = message;
                 break;
         }
-        if ('debug' === type && !(0, __WEBPACK_EXTERNAL_MODULE__utils_js_d88b7fe1__.isDebug)()) return;
+        if ('debug' === type && !isDebug()) return;
         console.log(`${label} ${text}`, ...args);
     };
     const logger = {
@@ -44,8 +44,8 @@ const createLogger = ()=>{
             const repeatCount = process.stdout.rows - 2;
             const blank = repeatCount > 0 ? '\n'.repeat(repeatCount) : '';
             console.log(blank);
-            __WEBPACK_EXTERNAL_MODULE_node_readline_91c31510__["default"].cursorTo(process.stdout, 0, 0);
-            __WEBPACK_EXTERNAL_MODULE_node_readline_91c31510__["default"].clearScreenDown(process.stdout);
+            node_readline.cursorTo(process.stdout, 0, 0);
+            node_readline.clearScreenDown(process.stdout);
         },
         greet: (msg)=>{
             const { npm_execpath, npm_lifecycle_event } = process.env;

package/dist/openBrowser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"openBrowser.d.ts","sourceRoot":"","sources":["../src/openBrowser.ts"],"names":[],"mappings":"AAKA,wBAAsB,WAAW,CAAC,GAAG,EAAE,MAAM,oBAkC5C"}
+{"version":3,"file":"openBrowser.d.ts","sourceRoot":"","sources":["../src/openBrowser.ts"],"names":[],"mappings":"AAMA,wBAAsB,WAAW,CAAC,GAAG,EAAE,MAAM,oBAkC5C"}

package/dist/openBrowser.js

@@ -1,11 +1,11 @@
-import __rslib_shim_module__ from 'module';
+import 'module';
 /*#__PURE__*/ import.meta.url;
 import { fileURLToPath as __webpack_fileURLToPath__ } from "node:url";
 import { dirname as __webpack_dirname__ } from "node:path";
 import * as __WEBPACK_EXTERNAL_MODULE_open__ from "open";
-import * as __WEBPACK_EXTERNAL_MODULE_node_child_process_27f17141__ from "node:child_process";
-import * as __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__ from "node:path";
-import * as __WEBPACK_EXTERNAL_MODULE__logger_js_c2be5186__ from "./logger.js";
+import { exec } from "node:child_process";
+import node_path from "node:path";
+import { logger } from "./logger.js";
 var __webpack_modules__ = {
     open: function(module) {
         module.exports = __WEBPACK_EXTERNAL_MODULE_open__;
@@ -39,24 +39,24 @@ async function openBrowser(url) {
         const openedBrowser = supportedChromiumBrowsers.find((b)=>ps.includes(b));
         if (openedBrowser) {
             await execAsync(`osascript openChrome.applescript "${encodeURI(url)}" "${openedBrowser}"`, {
-                cwd: __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(openBrowser_dirname, '../bin')
+                cwd: node_path.join(openBrowser_dirname, '../bin')
             });
             return true;
         }
     } catch (err) {
-        __WEBPACK_EXTERNAL_MODULE__logger_js_c2be5186__.logger.error(err);
+        logger.error(err);
     }
     try {
         openBrowser_open(url).catch(()=>{});
         return true;
     } catch (err) {
-        __WEBPACK_EXTERNAL_MODULE__logger_js_c2be5186__.logger.error(err);
+        logger.error(err);
         return false;
     }
 }
 function execAsync(command, options) {
     return new Promise((resolve, reject)=>{
-        (0, __WEBPACK_EXTERNAL_MODULE_node_child_process_27f17141__.exec)(command, options, (error, stdout)=>{
+        exec(command, options, (error, stdout)=>{
             if (error) reject(error);
             else resolve(stdout.toString());
         });

package/dist/plugin.js

@@ -1,4 +1,4 @@
-import __rslib_shim_module__ from 'module';
+import 'module';
 /*#__PURE__*/ import.meta.url;
 function getNormalizedPluginsByHook(hook, plugins) {
     const pluginMap = new Map();

package/dist/prebundleDeps.cjs

@@ -48,12 +48,24 @@ const external_html_webpack_plugin_namespaceObject = require("html-webpack-plugi
 var external_html_webpack_plugin_default = /*#__PURE__*/ __webpack_require__.n(external_html_webpack_plugin_namespaceObject);
 const external_tinyglobby_namespaceObject = require("tinyglobby");
 const external_colors_cjs_namespaceObject = require("./colors.cjs");
-var external_colors_cjs_default = /*#__PURE__*/ __webpack_require__.n(external_colors_cjs_namespaceObject);
 const external_constants_cjs_namespaceObject = require("./constants.cjs");
+const external_fs_cjs_namespaceObject = require("./fs.cjs");
 const external_global_cjs_namespaceObject = require("./global.cjs");
 const external_logger_cjs_namespaceObject = require("./logger.cjs");
 const external_utils_cjs_namespaceObject = require("./utils.cjs");
 const CACHE_DIR = 'umd';
+const FAILED_DEPS_CACHE_FILE = 'failed-deps.json';
+const getFailedDepsCache = (failedDepsCachePath)=>{
+    if (external_node_fs_default().existsSync(failedDepsCachePath)) return JSON.parse(external_node_fs_default().readFileSync(failedDepsCachePath, 'utf-8'));
+    return {};
+};
+const saveFailedDepsCache = (failedDepsCachePath, cache)=>{
+    const cacheDir = external_node_path_default().dirname(failedDepsCachePath);
+    if (!external_node_fs_default().existsSync(cacheDir)) external_node_fs_default().mkdirSync(cacheDir, {
+        recursive: true
+    });
+    external_node_fs_default().writeFileSync(failedDepsCachePath, JSON.stringify(cache, null, 2), 'utf-8');
+};
 const getExternalLibraryName = (pkgName)=>{
     const externalAlias = {
         react: 'React',
@@ -94,11 +106,13 @@ const prebundleDeps = async ({ unpackConfig })=>{
         bundled: 0
     };
     const failedDeps = [];
+    const { root } = unpackConfig;
+    const failedDepsCachePath = external_node_path_default().resolve(root, external_constants_cjs_namespaceObject.TEMP_DIR, FAILED_DEPS_CACHE_FILE);
+    const failedCache = getFailedDepsCache(failedDepsCachePath);
     const updateProgress = ()=>{
-        (0, external_utils_cjs_namespaceObject.logUpdate)(`${external_colors_cjs_default().magenta(external_colors_cjs_default().bold("\xbb"))} optimizing dependencies (${count.bundled}/${count.total})`);
+        (0, external_utils_cjs_namespaceObject.logUpdate)(`${external_colors_cjs_namespaceObject.colors.magenta("\xbb")} optimizing dependencies (${count.bundled}/${count.total})`);
         if (count.total === count.bundled + failedDeps.length) console.log();
     };
-    const { root } = unpackConfig;
     const bundleDep = ({ name, entry, version })=>new Promise((resolve)=>{
             const pkgDir = external_node_path_default().resolve(root, external_constants_cjs_namespaceObject.TEMP_DIR, CACHE_DIR, name);
             const outDir = external_node_path_default().resolve(pkgDir, version);
@@ -113,7 +127,6 @@ const prebundleDeps = async ({ unpackConfig })=>{
                 };
             };
             if (external_node_fs_default().existsSync(outDir)) return void resolve(getResult());
-            (0, external_utils_cjs_namespaceObject.removeDir)(pkgDir);
             count.total++;
             updateProgress();
             const getSwcOptions = ({ tsx })=>({
@@ -224,7 +237,8 @@ const prebundleDeps = async ({ unpackConfig })=>{
                 if (null == stats ? void 0 : stats.hasErrors()) {
                     isFailed = true;
                     failedDeps.push(name);
-                    (0, external_utils_cjs_namespaceObject.removeDir)(outDir);
+                    failedCache[name] = version;
+                    (0, external_fs_cjs_namespaceObject.removeDir)(outDir);
                 } else count.bundled++;
                 updateProgress();
                 compiler.close(()=>{
@@ -244,17 +258,23 @@ const prebundleDeps = async ({ unpackConfig })=>{
     const noEntryDeps = [];
     const needBundleDeps = shouldIncludeDeps.map((pkgName)=>{
         const packageJson = JSON.parse(external_node_fs_default().readFileSync(external_node_path_default().resolve(root, 'node_modules', pkgName, 'package.json'), 'utf-8'));
+        const version = packageJson.version;
+        if (failedCache[pkgName] === version) return;
         const entry = getPkgEntry(packageJson);
-        if (!entry) return void noEntryDeps.push(pkgName);
+        if (!entry) {
+            noEntryDeps.push(pkgName);
+            failedCache[pkgName] = version;
+            return;
+        }
         return {
             name: pkgName,
             entry: external_node_path_default().resolve(root, 'node_modules', pkgName, entry),
-            version: packageJson.version
+            version
         };
     }).filter(Boolean);
-    if (noEntryDeps[0]) external_logger_cjs_namespaceObject.logger.warn(`could not find entry for "${external_colors_cjs_default().bold(noEntryDeps.join(', '))}"`);
     const bundledDeps = await Promise.all(needBundleDeps.map((depInfo)=>bundleDep(depInfo)));
-    if (failedDeps[0]) external_logger_cjs_namespaceObject.logger.warn(`something went wrong while optimizing "${external_colors_cjs_default().bold(failedDeps.join(', '))}"`);
+    saveFailedDepsCache(failedDepsCachePath, failedCache);
+    if (failedDeps[0]) external_logger_cjs_namespaceObject.logger.warn(`something went wrong while optimizing "${external_colors_cjs_namespaceObject.colors.bold(failedDeps.join(', '))}"`);
     const cachePath = external_node_path_default().resolve(root, external_constants_cjs_namespaceObject.TEMP_DIR, CACHE_DIR);
     const app = external_express_default()();
     app.use(external_cors_default()());
@@ -309,7 +329,8 @@ const prebundleDeps = async ({ unpackConfig })=>{
                 apply: (compiler)=>{
                     compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation)=>{
                         HtmlPlugin.getCompilationHooks(compilation).beforeAssetTagGeneration.tapPromise(PLUGIN_NAME, async (args)=>{
-                            args.assets.js.unshift(...preJsAssets.sort((a, b)=>a.order - b.order).map((item)=>item.path), ...jsAssets);
+                            const sortedPreJsAssets = preJsAssets.sort((a, b)=>a.order - b.order).map((item)=>item.path);
+                            args.assets.js.unshift(...sortedPreJsAssets, ...jsAssets);
                             args.assets.css.unshift(...cssAssets);
                             return args;
                         });

package/dist/prebundleDeps.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"prebundleDeps.d.ts","sourceRoot":"","sources":["../src/prebundleDeps.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA;AA2D3C,eAAO,MAAM,aAAa,sBAEvB;IACD,YAAY,EAAE,YAAY,CAAA;CAC3B,KAAG,OAAO,CAAC,YAAY,CAgRvB,CAAA"}
+{"version":3,"file":"prebundleDeps.d.ts","sourceRoot":"","sources":["../src/prebundleDeps.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA;AA0E3C,eAAO,MAAM,aAAa,GAAU,mBAEjC;IACD,YAAY,EAAE,YAAY,CAAA;CAC3B,KAAG,OAAO,CAAC,YAAY,CAuRvB,CAAA"}