@rslib/core 0.0.4 → 0.0.6

package/README.md

@@ -6,9 +6,9 @@
 
 Rslib is a library build tool powered by [Rsbuild](https://rsbuild.dev). It allows library developers to leverage the knowledge and ecosystem of webpack and Rspack.
 
-<!-- ## Documentation
+## Documentation
 
-https://rslib.dev/ -->
+https://lib.rsbuild.dev/
 
 ## Contributing
 

package/compiled/picocolors/index.d.ts

@@ -2,6 +2,7 @@ type Formatter = (input: string | number | null | undefined) => string
 
 interface Colors {
 	isColorSupported: boolean
+	
 	reset: Formatter
 	bold: Formatter
 	dim: Formatter
@@ -10,6 +11,7 @@ interface Colors {
 	inverse: Formatter
 	hidden: Formatter
 	strikethrough: Formatter
+	
 	black: Formatter
 	red: Formatter
 	green: Formatter
@@ -19,6 +21,7 @@ interface Colors {
 	cyan: Formatter
 	white: Formatter
 	gray: Formatter
+	
 	bgBlack: Formatter
 	bgRed: Formatter
 	bgGreen: Formatter
@@ -27,6 +30,25 @@ interface Colors {
 	bgMagenta: Formatter
 	bgCyan: Formatter
 	bgWhite: Formatter
+
+	blackBright: Formatter
+  redBright: Formatter
+  greenBright: Formatter
+  yellowBright: Formatter
+  blueBright: Formatter
+  magentaBright: Formatter
+  cyanBright: Formatter
+  whiteBright: Formatter
+
+	bgBlackBright: Formatter
+  bgRedBright: Formatter
+  bgGreenBright: Formatter
+  bgYellowBright: Formatter
+  bgBlueBright: Formatter
+  bgMagentaBright: Formatter
+  bgCyanBright: Formatter
+  bgWhiteBright: Formatter
+
 }
 
 declare const picocolors: Colors & { createColors: (enabled?: boolean) => Colors }

package/compiled/picocolors/index.js

@@ -1,7 +1,7 @@
 /******/ (() => { // webpackBootstrap
 /******/ 	var __webpack_modules__ = ({
 
-/***/ 701:
+/***/ 78:
 /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
 
 let argv = process.argv || [],
@@ -47,6 +47,7 @@ let createColors = (enabled = isColorSupported) => {
 		inverse: init("\x1b[7m", "\x1b[27m"),
 		hidden: init("\x1b[8m", "\x1b[28m"),
 		strikethrough: init("\x1b[9m", "\x1b[29m"),
+
 		black: init("\x1b[30m", "\x1b[39m"),
 		red: init("\x1b[31m", "\x1b[39m"),
 		green: init("\x1b[32m", "\x1b[39m"),
@@ -56,6 +57,7 @@ let createColors = (enabled = isColorSupported) => {
 		cyan: init("\x1b[36m", "\x1b[39m"),
 		white: init("\x1b[37m", "\x1b[39m"),
 		gray: init("\x1b[90m", "\x1b[39m"),
+
 		bgBlack: init("\x1b[40m", "\x1b[49m"),
 		bgRed: init("\x1b[41m", "\x1b[49m"),
 		bgGreen: init("\x1b[42m", "\x1b[49m"),
@@ -64,6 +66,24 @@ let createColors = (enabled = isColorSupported) => {
 		bgMagenta: init("\x1b[45m", "\x1b[49m"),
 		bgCyan: init("\x1b[46m", "\x1b[49m"),
 		bgWhite: init("\x1b[47m", "\x1b[49m"),
+
+		blackBright: init("\x1b[90m", "\x1b[39m"),
+		redBright: init("\x1b[91m", "\x1b[39m"),
+		greenBright: init("\x1b[92m", "\x1b[39m"),
+		yellowBright: init("\x1b[93m", "\x1b[39m"),
+		blueBright: init("\x1b[94m", "\x1b[39m"),
+		magentaBright: init("\x1b[95m", "\x1b[39m"),
+		cyanBright: init("\x1b[96m", "\x1b[39m"),
+		whiteBright: init("\x1b[97m", "\x1b[39m"),
+
+		bgBlackBright: init("\x1b[100m","\x1b[49m"),
+		bgRedBright: init("\x1b[101m","\x1b[49m"),
+		bgGreenBright: init("\x1b[102m","\x1b[49m"),
+		bgYellowBright: init("\x1b[103m","\x1b[49m"),
+		bgBlueBright: init("\x1b[104m","\x1b[49m"),
+		bgMagentaBright: init("\x1b[105m","\x1b[49m"),
+		bgCyanBright: init("\x1b[106m","\x1b[49m"),
+		bgWhiteBright: init("\x1b[107m","\x1b[49m"),
 	}
 }
 
@@ -123,7 +143,7 @@ module.exports = require("tty");
 /******/ 	// 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__(701);
+/******/ 	var __webpack_exports__ = __nccwpck_require__(78);
 /******/ 	module.exports = __webpack_exports__;
 /******/ 	
 /******/ })()

package/compiled/picocolors/license

@@ -1,6 +1,6 @@
 ISC License
 
-Copyright (c) 2021 Alexey Raspopov, Kostiantyn Denysov, Anton Verinov
+Copyright (c) 2021-2024 Oleksii Raspopov, Kostiantyn Denysov, Anton Verinov
 
 Permission to use, copy, modify, and/or distribute this software for any
 purpose with or without fee is hereby granted, provided that the above

package/compiled/picocolors/package.json

@@ -1 +1 @@
-{"name":"picocolors","author":"Alexey Raspopov","version":"1.0.1","license":"ISC","types":"index.d.ts","type":"commonjs"}
+{"name":"picocolors","author":"Alexey Raspopov","version":"1.1.0","license":"ISC","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,334 @@
+"use strict";
+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(require("process"));
+var import_node_os = __toESM(require("os"));
+var import_node_tty = __toESM(require("tty"));
+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 = /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 && (module.exports = {
+  createLogger,
+  logger
+});

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.3","types":"index.d.ts","type":"commonjs"}