prebundle 1.0.4 → 1.1.0-beta.0

package/compiled/fs-extra/package.json

@@ -1 +1 @@
-{"name":"fs-extra","author":"JP Richardson <jprichardson@gmail.com>","version":"11.2.0","license":"MIT","type":"commonjs"}
+{"name":"fs-extra","author":"JP Richardson <jprichardson@gmail.com>","version":"11.2.0","license":"MIT","types":"index.d.ts","type":"commonjs"}

package/compiled/rslog/index.d.ts

@@ -0,0 +1,66 @@
+type ColorFn = (input: string | number | null | undefined) => string;
+
+declare let LOG_TYPES: {
+    error: {
+        label: string;
+        level: "error";
+        color: ColorFn;
+    };
+    warn: {
+        label: string;
+        level: "warn";
+        color: ColorFn;
+    };
+    info: {
+        label: string;
+        level: "info";
+        color: ColorFn;
+    };
+    start: {
+        label: string;
+        level: "info";
+        color: ColorFn;
+    };
+    ready: {
+        label: string;
+        level: "info";
+        color: ColorFn;
+    };
+    success: {
+        label: string;
+        level: "info";
+        color: ColorFn;
+    };
+    log: {
+        level: "log";
+    };
+    debug: {
+        label: string;
+        level: "verbose";
+        color: ColorFn;
+    };
+};
+
+type LogLevel = 'error' | 'warn' | 'info' | 'log' | 'verbose';
+type LogMessage = unknown;
+interface LogType {
+    label?: string;
+    level: LogLevel;
+    color?: ColorFn;
+}
+type LogFunction = (message?: LogMessage, ...args: any[]) => void;
+interface Options {
+    level?: LogLevel;
+}
+type LogMethods = keyof typeof LOG_TYPES;
+type Logger = Record<LogMethods, LogFunction> & {
+    greet: (message: string) => void;
+    level: LogLevel;
+    override: (customLogger: Partial<Record<LogMethods, LogFunction>>) => void;
+};
+
+declare let createLogger: (options?: Options) => Logger;
+
+declare let logger: Logger;
+
+export { type LogFunction, type LogLevel, type LogMessage, type LogType, type Logger, type Options, createLogger, logger };

package/compiled/rslog/index.js

@@ -0,0 +1,410 @@
+/******/ (() => { // webpackBootstrap
+/******/ 	"use strict";
+/******/ 	var __webpack_modules__ = ({
+
+/***/ 37:
+/***/ ((module) => {
+
+module.exports = require("os");
+
+/***/ }),
+
+/***/ 282:
+/***/ ((module) => {
+
+module.exports = require("process");
+
+/***/ }),
+
+/***/ 224:
+/***/ ((module) => {
+
+module.exports = require("tty");
+
+/***/ }),
+
+/***/ 103:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  createLogger: () => createLogger,
+  logger: () => logger
+});
+module.exports = __toCommonJS(src_exports);
+
+// node_modules/.pnpm/supports-color@9.4.0/node_modules/supports-color/index.js
+var import_node_process = __toESM(__nccwpck_require__(282));
+var import_node_os = __toESM(__nccwpck_require__(37));
+var import_node_tty = __toESM(__nccwpck_require__(224));
+function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : import_node_process.default.argv) {
+  const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
+  const position = argv.indexOf(prefix + flag);
+  const terminatorPosition = argv.indexOf("--");
+  return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
+}
+var { env } = import_node_process.default;
+var flagForceColor;
+if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
+  flagForceColor = 0;
+} else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
+  flagForceColor = 1;
+}
+function envForceColor() {
+  if ("FORCE_COLOR" in env) {
+    if (env.FORCE_COLOR === "true") {
+      return 1;
+    }
+    if (env.FORCE_COLOR === "false") {
+      return 0;
+    }
+    return env.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
+  }
+}
+function translateLevel(level) {
+  if (level === 0) {
+    return false;
+  }
+  return {
+    level,
+    hasBasic: true,
+    has256: level >= 2,
+    has16m: level >= 3
+  };
+}
+function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
+  const noFlagForceColor = envForceColor();
+  if (noFlagForceColor !== void 0) {
+    flagForceColor = noFlagForceColor;
+  }
+  const forceColor = sniffFlags ? flagForceColor : noFlagForceColor;
+  if (forceColor === 0) {
+    return 0;
+  }
+  if (sniffFlags) {
+    if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
+      return 3;
+    }
+    if (hasFlag("color=256")) {
+      return 2;
+    }
+  }
+  if ("TF_BUILD" in env && "AGENT_NAME" in env) {
+    return 1;
+  }
+  if (haveStream && !streamIsTTY && forceColor === void 0) {
+    return 0;
+  }
+  const min = forceColor || 0;
+  if (env.TERM === "dumb") {
+    return min;
+  }
+  if (import_node_process.default.platform === "win32") {
+    const osRelease = import_node_os.default.release().split(".");
+    if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
+      return Number(osRelease[2]) >= 14931 ? 3 : 2;
+    }
+    return 1;
+  }
+  if ("CI" in env) {
+    if ("GITHUB_ACTIONS" in env || "GITEA_ACTIONS" in env) {
+      return 3;
+    }
+    if (["TRAVIS", "CIRCLECI", "APPVEYOR", "GITLAB_CI", "BUILDKITE", "DRONE"].some((sign) => sign in env) || env.CI_NAME === "codeship") {
+      return 1;
+    }
+    return min;
+  }
+  if ("TEAMCITY_VERSION" in env) {
+    return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+  }
+  if (env.COLORTERM === "truecolor") {
+    return 3;
+  }
+  if (env.TERM === "xterm-kitty") {
+    return 3;
+  }
+  if ("TERM_PROGRAM" in env) {
+    const version = Number.parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+    switch (env.TERM_PROGRAM) {
+      case "iTerm.app": {
+        return version >= 3 ? 3 : 2;
+      }
+      case "Apple_Terminal": {
+        return 2;
+      }
+    }
+  }
+  if (/-256(color)?$/i.test(env.TERM)) {
+    return 2;
+  }
+  if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
+    return 1;
+  }
+  if ("COLORTERM" in env) {
+    return 1;
+  }
+  return min;
+}
+function createSupportsColor(stream, options = {}) {
+  const level = _supportsColor(stream, {
+    streamIsTTY: stream && stream.isTTY,
+    ...options
+  });
+  return translateLevel(level);
+}
+var supportsColor = {
+  stdout: createSupportsColor({ isTTY: import_node_tty.default.isatty(1) }),
+  stderr: createSupportsColor({ isTTY: import_node_tty.default.isatty(2) })
+};
+var supports_color_default = supportsColor;
+
+// src/utils.ts
+var colorLevel = supports_color_default.stdout ? supports_color_default.stdout.level : 0;
+var errorStackRegExp = /at\s.*:\d+:\d+[\s\)]*$/;
+var anonymousErrorStackRegExp = /^\s*at\s.*\(<anonymous>\)$/;
+var isErrorStackMessage = (message) => errorStackRegExp.test(message) || anonymousErrorStackRegExp.test(message);
+
+// src/color.ts
+var formatter = (open, close, replace = open) => colorLevel >= 2 ? (input) => {
+  let string = "" + input;
+  let index = string.indexOf(close, open.length);
+  return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close;
+} : String;
+var replaceClose = (string, close, replace, index) => {
+  let start = string.substring(0, index) + replace;
+  let end = string.substring(index + close.length);
+  let nextIndex = end.indexOf(close);
+  return ~nextIndex ? start + replaceClose(end, close, replace, nextIndex) : start + end;
+};
+var bold = formatter("\x1B[1m", "\x1B[22m", "\x1B[22m\x1B[1m");
+var red = formatter("\x1B[31m", "\x1B[39m");
+var green = formatter("\x1B[32m", "\x1B[39m");
+var yellow = formatter("\x1B[33m", "\x1B[39m");
+var magenta = formatter("\x1B[35m", "\x1B[39m");
+var cyan = formatter("\x1B[36m", "\x1B[39m");
+var gray = formatter("\x1B[90m", "\x1B[39m");
+
+// src/gradient.ts
+var startColor = [189, 255, 243];
+var endColor = [74, 194, 154];
+var isWord = (char) => !/[\s\n]/.test(char);
+var gradient = (message) => {
+  if (colorLevel < 3) {
+    return colorLevel === 2 ? bold(cyan(message)) : message;
+  }
+  let chars = [...message];
+  let steps = chars.filter(isWord).length;
+  let r = startColor[0];
+  let g = startColor[1];
+  let b = startColor[2];
+  let rStep = (endColor[0] - r) / steps;
+  let gStep = (endColor[1] - g) / steps;
+  let bStep = (endColor[2] - b) / steps;
+  let output = "";
+  for (let char of chars) {
+    if (isWord(char)) {
+      r += rStep;
+      g += gStep;
+      b += bStep;
+    }
+    output += `\x1B[38;2;${Math.round(r)};${Math.round(g)};${Math.round(
+      b
+    )}m${char}\x1B[39m`;
+  }
+  return bold(output);
+};
+
+// src/constants.ts
+var LOG_LEVEL = {
+  error: 0,
+  warn: 1,
+  info: 2,
+  log: 3,
+  verbose: 4
+};
+var LOG_TYPES = {
+  // Level error
+  error: {
+    label: "error",
+    level: "error",
+    color: red
+  },
+  // Level warn
+  warn: {
+    label: "warn",
+    level: "warn",
+    color: yellow
+  },
+  // Level info
+  info: {
+    label: "info",
+    level: "info",
+    color: cyan
+  },
+  start: {
+    label: "start",
+    level: "info",
+    color: cyan
+  },
+  ready: {
+    label: "ready",
+    level: "info",
+    color: green
+  },
+  success: {
+    label: "success",
+    level: "info",
+    color: green
+  },
+  // Level log
+  log: {
+    level: "log"
+  },
+  // Level debug
+  debug: {
+    label: "debug",
+    level: "verbose",
+    color: magenta
+  }
+};
+
+// src/createLogger.ts
+var createLogger = (options = {}) => {
+  let maxLevel = options.level || "log";
+  let log = (type, message, ...args) => {
+    if (LOG_LEVEL[LOG_TYPES[type].level] > LOG_LEVEL[maxLevel]) {
+      return;
+    }
+    if (message === void 0 || message === null) {
+      return console.log();
+    }
+    let logType = LOG_TYPES[type];
+    let label = "";
+    let text = "";
+    if ("label" in logType) {
+      label = (logType.label || "").padEnd(7);
+      label = bold(logType.color ? logType.color(label) : label);
+    }
+    if (message instanceof Error) {
+      if (message.stack) {
+        let [name, ...rest] = message.stack.split("\n");
+        if (name.startsWith("Error: ")) {
+          name = name.slice(7);
+        }
+        text = `${name}
+${gray(rest.join("\n"))}`;
+      } else {
+        text = message.message;
+      }
+    } else if (logType.level === "error" && typeof message === "string") {
+      let lines = message.split("\n");
+      text = lines.map((line) => isErrorStackMessage(line) ? gray(line) : line).join("\n");
+    } else {
+      text = `${message}`;
+    }
+    console.log(label.length ? `${label} ${text}` : text, ...args);
+  };
+  let logger2 = {
+    greet: (message) => log("log", gradient(message))
+  };
+  Object.keys(LOG_TYPES).forEach((key) => {
+    logger2[key] = (...args) => log(key, ...args);
+  });
+  Object.defineProperty(logger2, "level", {
+    get: () => maxLevel,
+    set(val) {
+      maxLevel = val;
+    }
+  });
+  logger2.override = (customLogger) => {
+    Object.assign(logger2, customLogger);
+  };
+  return logger2;
+};
+
+// src/index.ts
+var logger = createLogger();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
+
+
+/***/ })
+
+/******/ 	});
+/************************************************************************/
+/******/ 	// The module cache
+/******/ 	var __webpack_module_cache__ = {};
+/******/ 	
+/******/ 	// The require function
+/******/ 	function __nccwpck_require__(moduleId) {
+/******/ 		// Check if module is in cache
+/******/ 		var cachedModule = __webpack_module_cache__[moduleId];
+/******/ 		if (cachedModule !== undefined) {
+/******/ 			return cachedModule.exports;
+/******/ 		}
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = __webpack_module_cache__[moduleId] = {
+/******/ 			// no module.id needed
+/******/ 			// no module.loaded needed
+/******/ 			exports: {}
+/******/ 		};
+/******/ 	
+/******/ 		// Execute the module function
+/******/ 		var threw = true;
+/******/ 		try {
+/******/ 			__webpack_modules__[moduleId](module, module.exports, __nccwpck_require__);
+/******/ 			threw = false;
+/******/ 		} finally {
+/******/ 			if(threw) delete __webpack_module_cache__[moduleId];
+/******/ 		}
+/******/ 	
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+/******/ 	
+/************************************************************************/
+/******/ 	/* webpack/runtime/compat */
+/******/ 	
+/******/ 	if (typeof __nccwpck_require__ !== 'undefined') __nccwpck_require__.ab = __dirname + "/";
+/******/ 	
+/************************************************************************/
+/******/ 	
+/******/ 	// startup
+/******/ 	// Load entry module and return exports
+/******/ 	// This entry module is referenced by other modules so it can't be inlined
+/******/ 	var __webpack_exports__ = __nccwpck_require__(103);
+/******/ 	module.exports = __webpack_exports__;
+/******/ 	
+/******/ })()
+;

package/compiled/rslog/license

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023-present Bytedance, Inc. and its affiliates.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/compiled/rslog/package.json

@@ -0,0 +1 @@
+{"name":"rslog","version":"1.2.2","types":"index.d.ts","type":"commonjs"}

package/dist/helper.js

@@ -2,7 +2,6 @@ import { dirname, join } from 'node:path';
 import fs from '../compiled/fs-extra/index.js';
 import { cwd, DIST_DIR } from './constant.js';
 import { createRequire } from 'node:module';
-import { pathToFileURL } from 'node:url';
 const require = createRequire(import.meta.url);
 export function findDepPath(name) {
     let entry = dirname(require.resolve(join(name), { paths: [cwd] }));
@@ -16,7 +15,7 @@ export function findDepPath(name) {
 }
 export const resolveConfig = async () => {
     const configPath = join(cwd, 'prebundle.config.mjs');
-    const config = await import(pathToFileURL(configPath).href);
+    const config = await import(configPath);
     return config.default;
 };
 export function parseTasks(dependencies) {
@@ -36,7 +35,8 @@ export function parseTasks(dependencies) {
         };
         if (typeof dep === 'string') {
             result.push({
-                minify: true,
+                minify: false,
+                target: 'es2019',
                 externals: {},
                 emitFiles: [],
                 packageJsonField: [],
@@ -45,7 +45,8 @@ export function parseTasks(dependencies) {
         }
         else {
             result.push({
-                minify: dep.minify ?? true,
+                minify: dep.minify ?? false,
+                target: dep.target ?? 'es2019',
                 ignoreDts: dep.ignoreDts,
                 externals: dep.externals ?? {},
                 emitFiles: dep.emitFiles ?? [],

package/dist/prebundle.js

@@ -1,10 +1,12 @@
 import { join } from 'node:path';
 import ncc from '@vercel/ncc';
-import { Package as DtsPacker } from 'dts-packer';
 import fastGlob from '../compiled/fast-glob/index.js';
 import fs from '../compiled/fs-extra/index.js';
-import { cwd, DEFAULT_EXTERNALS } from './constant.js';
+import { logger } from 'rslog';
+import { DEFAULT_EXTERNALS } from './constant.js';
 import { pick, replaceFileContent } from './helper.js';
+import { dts } from 'rollup-plugin-dts';
+import { rollup } from 'rollup';
 function emitAssets(assets, distPath) {
     for (const key of Object.keys(assets)) {
         const asset = assets[key];
@@ -25,25 +27,65 @@ function fixTypeExternalPath(file, task, externals) {
         return newContent;
     });
 }
-function emitDts(task, externals) {
-    if (task.ignoreDts) {
+async function emitDts(task, externals) {
+    const outputDefaultDts = () => {
         fs.writeFileSync(join(task.distPath, 'index.d.ts'), 'export = any;\n');
+    };
+    if (task.ignoreDts) {
+        outputDefaultDts();
+        return;
+    }
+    const pkgPath = join(task.depPath, 'package.json');
+    const pkgJson = fs.readJsonSync(pkgPath, 'utf-8');
+    const types = pkgJson.types || pkgJson.typing || pkgJson.typings;
+    if (!types) {
+        outputDefaultDts();
         return;
     }
     try {
-        const { files } = new DtsPacker({
-            cwd,
-            name: task.depName,
-            typesRoot: task.distPath,
-            externals: Object.keys(externals),
-        });
-        for (const file of Object.keys(files)) {
-            fixTypeExternalPath(file, task, externals);
-        }
+        const inputConfig = {
+            input: join(task.depPath, types),
+            external: Object.keys(externals),
+            plugins: [
+                dts({
+                    respectExternal: true,
+                    compilerOptions: {
+                        skipLibCheck: true,
+                        // https://github.com/Swatinem/rollup-plugin-dts/issues/143,
+                        // but it will cause error when bundle ts which import another ts file.
+                        preserveSymlinks: false,
+                        // https://github.com/Swatinem/rollup-plugin-dts/issues/127
+                        composite: false,
+                        // https://github.com/Swatinem/rollup-plugin-dts/issues/113
+                        declarationMap: false,
+                        // Ensure ".d.ts" modules are generated
+                        declaration: true,
+                        // Skip ".js" generation
+                        noEmit: false,
+                        emitDeclarationOnly: true,
+                        // Skip code generation when error occurs
+                        noEmitOnError: true,
+                        // Avoid extra work
+                        checkJs: false,
+                        // Ensure we can parse the latest code
+                        // @ts-expect-error
+                        target: task.target,
+                    },
+                }),
+            ],
+        };
+        const outputConfig = {
+            dir: task.distPath,
+            format: 'esm',
+            exports: 'named',
+            entryFileNames: '[name].ts',
+        };
+        const bundle = await rollup(inputConfig);
+        await bundle.write(outputConfig);
     }
     catch (error) {
-        console.error(`DtsPacker failed: ${task.depName}`);
-        console.error(error);
+        logger.error(`rollup-plugin-dts failed: ${task.depName}`);
+        logger.error(error);
     }
 }
 function emitPackageJson(task) {
@@ -56,19 +98,12 @@ function emitPackageJson(task) {
         'version',
         'funding',
         'license',
-        'types',
-        'typing',
-        'typings',
         ...task.packageJsonField,
     ]);
     if (task.depName !== pickedPackageJson.name) {
         pickedPackageJson.name = task.depName;
     }
-    if (task.ignoreDts) {
-        delete pickedPackageJson.typing;
-        delete pickedPackageJson.typings;
-        pickedPackageJson.types = 'index.d.ts';
-    }
+    pickedPackageJson.types = 'index.d.ts';
     fs.writeJSONSync(outputPath, pickedPackageJson);
 }
 function emitLicense(task) {
@@ -112,7 +147,7 @@ export async function prebundle(task, commonExternals = {}) {
     if (pkgName && task.depName !== pkgName) {
         return;
     }
-    console.log(`==== Start prebundle "${task.depName}" ====`);
+    logger.info(`prebundle: ${task.depName}`);
     fs.removeSync(task.distPath);
     if (task.beforeBundle) {
         await task.beforeBundle(task);
@@ -124,13 +159,13 @@ export async function prebundle(task, commonExternals = {}) {
     };
     const { code, assets } = await ncc(task.depEntry, {
         minify: task.minify,
-        target: 'es2019',
+        target: task.target,
         externals: mergedExternals,
         assetBuilds: false,
     });
     emitIndex(code, task.distPath);
     emitAssets(assets, task.distPath);
-    emitDts(task, mergedExternals);
+    await emitDts(task, mergedExternals);
     emitLicense(task);
     emitPackageJson(task);
     removeSourceMap(task);
@@ -139,5 +174,5 @@ export async function prebundle(task, commonExternals = {}) {
     if (task.afterBundle) {
         await task.afterBundle(task);
     }
-    console.log(`==== Finish prebundle "${task.depName}" ====\n\n`);
+    logger.success(`prebundle: ${task.depName}\n\n`);
 }