🎉 initiate project *astro_rewrite*

node_modules/astro/dist/core/logger/console.d.ts

@@ -0,0 +1,4 @@
+import type { LogMessage } from './core.js';
+export declare const consoleLogDestination: {
+    write(event: LogMessage): boolean;
+};

node_modules/astro/dist/core/logger/console.js

@@ -0,0 +1,42 @@
+import { bold, cyan, dim, red, reset, yellow } from "kleur/colors";
+import { dateTimeFormat, levels } from "./core.js";
+let lastMessage;
+let lastMessageCount = 1;
+const consoleLogDestination = {
+  write(event) {
+    let dest = console.error;
+    if (levels[event.level] < levels["error"]) {
+      dest = console.log;
+    }
+    function getPrefix() {
+      let prefix = "";
+      let type = event.type;
+      if (type) {
+        prefix += dim(dateTimeFormat.format(/* @__PURE__ */ new Date()) + " ");
+        if (event.level === "info") {
+          type = bold(cyan(`[${type}]`));
+        } else if (event.level === "warn") {
+          type = bold(yellow(`[${type}]`));
+        } else if (event.level === "error") {
+          type = bold(red(`[${type}]`));
+        }
+        prefix += `${type} `;
+      }
+      return reset(prefix);
+    }
+    let message = event.message;
+    if (message === lastMessage) {
+      lastMessageCount++;
+      message = `${message} ${yellow(`(x${lastMessageCount})`)}`;
+    } else {
+      lastMessage = message;
+      lastMessageCount = 1;
+    }
+    const outMessage = getPrefix() + message;
+    dest(outMessage);
+    return true;
+  }
+};
+export {
+  consoleLogDestination
+};

node_modules/astro/dist/core/logger/core.d.ts

@@ -0,0 +1,31 @@
+interface LogWritable<T> {
+    write: (chunk: T) => boolean;
+}
+export type LoggerLevel = 'debug' | 'info' | 'warn' | 'error' | 'silent';
+export type LoggerEvent = 'info' | 'warn' | 'error';
+export interface LogOptions {
+    dest: LogWritable<LogMessage>;
+    level: LoggerLevel;
+}
+export declare const dateTimeFormat: Intl.DateTimeFormat;
+export interface LogMessage {
+    type: string | null;
+    level: LoggerLevel;
+    message: string;
+}
+export declare const levels: Record<LoggerLevel, number>;
+/** Full logging API */
+export declare function log(opts: LogOptions, level: LoggerLevel, type: string | null, message: string): void;
+/** Emit a user-facing message. Useful for UI and other console messages. */
+export declare function info(opts: LogOptions, type: string | null, message: string): void;
+/** Emit a warning message. Useful for high-priority messages that aren't necessarily errors. */
+export declare function warn(opts: LogOptions, type: string | null, message: string): void;
+/** Emit a error message, Useful when Astro can't recover from some error. */
+export declare function error(opts: LogOptions, type: string | null, message: string): void;
+type LogFn = typeof info | typeof warn | typeof error;
+export declare function table(opts: LogOptions, columns: number[]): (logFn: LogFn, ...input: Array<any>) => void;
+export declare function debug(...args: any[]): void;
+export declare let defaultLogLevel: LoggerLevel;
+/** Print out a timer message for debug() */
+export declare function timerMessage(message: string, startTime?: number): string;
+export {};

node_modules/astro/dist/core/logger/core.js

@@ -0,0 +1,89 @@
+import { dim } from "kleur/colors";
+import stringWidth from "string-width";
+const dateTimeFormat = new Intl.DateTimeFormat([], {
+  hour: "2-digit",
+  minute: "2-digit",
+  second: "2-digit"
+});
+const levels = {
+  debug: 20,
+  info: 30,
+  warn: 40,
+  error: 50,
+  silent: 90
+};
+function log(opts, level, type, message) {
+  const logLevel = opts.level;
+  const dest = opts.dest;
+  const event = {
+    type,
+    level,
+    message
+  };
+  if (levels[logLevel] > levels[level]) {
+    return;
+  }
+  dest.write(event);
+}
+function info(opts, type, message) {
+  return log(opts, "info", type, message);
+}
+function warn(opts, type, message) {
+  return log(opts, "warn", type, message);
+}
+function error(opts, type, message) {
+  return log(opts, "error", type, message);
+}
+function table(opts, columns) {
+  return function logTable(logFn, ...input) {
+    const message = columns.map((len, i) => padStr(input[i].toString(), len)).join(" ");
+    logFn(opts, null, message);
+  };
+}
+function debug(...args) {
+  if ("_astroGlobalDebug" in globalThis) {
+    globalThis._astroGlobalDebug(...args);
+  }
+}
+function padStr(str, len) {
+  const strLen = stringWidth(str);
+  if (strLen > len) {
+    return str.substring(0, len - 3) + "...";
+  }
+  const spaces = Array.from({ length: len - strLen }, () => " ").join("");
+  return str + spaces;
+}
+let defaultLogLevel;
+if (typeof process !== "undefined") {
+  let proc = process;
+  if ("argv" in proc && Array.isArray(proc.argv)) {
+    if (proc.argv.includes("--verbose")) {
+      defaultLogLevel = "debug";
+    } else if (proc.argv.includes("--silent")) {
+      defaultLogLevel = "silent";
+    } else {
+      defaultLogLevel = "info";
+    }
+  } else {
+    defaultLogLevel = "info";
+  }
+} else {
+  defaultLogLevel = "info";
+}
+function timerMessage(message, startTime = Date.now()) {
+  let timeDiff = Date.now() - startTime;
+  let timeDisplay = timeDiff < 750 ? `${Math.round(timeDiff)}ms` : `${(timeDiff / 1e3).toFixed(1)}s`;
+  return `${message}   ${dim(timeDisplay)}`;
+}
+export {
+  dateTimeFormat,
+  debug,
+  defaultLogLevel,
+  error,
+  info,
+  levels,
+  log,
+  table,
+  timerMessage,
+  warn
+};

node_modules/astro/dist/core/logger/node.d.ts

@@ -0,0 +1,33 @@
+/// <reference types="node" />
+import { Writable } from 'node:stream';
+export declare const nodeLogDestination: Writable;
+interface LogWritable<T> {
+    write: (chunk: T) => boolean;
+}
+export type LoggerLevel = 'debug' | 'info' | 'warn' | 'error' | 'silent';
+export type LoggerEvent = 'info' | 'warn' | 'error';
+export interface LogOptions {
+    dest?: LogWritable<LogMessage>;
+    level?: LoggerLevel;
+}
+export declare const nodeLogOptions: Required<LogOptions>;
+export interface LogMessage {
+    type: string | null;
+    level: LoggerLevel;
+    message: string;
+}
+export declare const levels: Record<LoggerLevel, number>;
+/**
+ * Emit a message only shown in debug mode.
+ * Astro (along with many of its dependencies) uses the `debug` package for debug logging.
+ * You can enable these logs with the `DEBUG=astro:*` environment variable.
+ * More info https://github.com/debug-js/debug#environment-variables
+ */
+export declare function debug(type: string, ...messages: Array<any>): any;
+export declare const logger: {
+    info: (type: string | null, message: string) => void;
+    warn: (type: string | null, message: string) => void;
+    error: (type: string | null, message: string) => void;
+};
+export declare function enableVerboseLogging(): void;
+export {};

node_modules/astro/dist/core/logger/node.js

@@ -0,0 +1,96 @@
+import debugPackage from "debug";
+import { bold, cyan, dim, red, reset, yellow } from "kleur/colors";
+import * as readline from "node:readline";
+import { Writable } from "node:stream";
+import stringWidth from "string-width";
+import { dateTimeFormat, error, info, warn } from "./core.js";
+let lastMessage;
+let lastMessageCount = 1;
+const nodeLogDestination = new Writable({
+  objectMode: true,
+  write(event, _, callback) {
+    let dest = process.stderr;
+    if (levels[event.level] < levels["error"]) {
+      dest = process.stdout;
+    }
+    function getPrefix() {
+      let prefix = "";
+      let type = event.type;
+      if (type) {
+        prefix += dim(dateTimeFormat.format(/* @__PURE__ */ new Date()) + " ");
+        if (event.level === "info") {
+          type = bold(cyan(`[${type}]`));
+        } else if (event.level === "warn") {
+          type = bold(yellow(`[${type}]`));
+        } else if (event.level === "error") {
+          type = bold(red(`[${type}]`));
+        }
+        prefix += `${type} `;
+      }
+      return reset(prefix);
+    }
+    let message = event.message;
+    if (message === lastMessage) {
+      lastMessageCount++;
+      if (levels[event.level] < levels["error"]) {
+        let lines = 1;
+        let len = stringWidth(`${getPrefix()}${message}`);
+        let cols = dest.columns;
+        if (len > cols) {
+          lines = Math.ceil(len / cols);
+        }
+        for (let i = 0; i < lines; i++) {
+          readline.clearLine(dest, 0);
+          readline.cursorTo(dest, 0);
+          readline.moveCursor(dest, 0, -1);
+        }
+      }
+      message = `${message} ${yellow(`(x${lastMessageCount})`)}`;
+    } else {
+      lastMessage = message;
+      lastMessageCount = 1;
+    }
+    dest.write(getPrefix());
+    dest.write(message);
+    dest.write("\n");
+    callback();
+  }
+});
+const nodeLogOptions = {
+  dest: nodeLogDestination,
+  level: "info"
+};
+const levels = {
+  debug: 20,
+  info: 30,
+  warn: 40,
+  error: 50,
+  silent: 90
+};
+const debuggers = {};
+function debug(type, ...messages) {
+  const namespace = `astro:${type}`;
+  debuggers[namespace] = debuggers[namespace] || debugPackage(namespace);
+  return debuggers[namespace](...messages);
+}
+globalThis._astroGlobalDebug = debug;
+const logger = {
+  info: info.bind(null, nodeLogOptions),
+  warn: warn.bind(null, nodeLogOptions),
+  error: error.bind(null, nodeLogOptions)
+};
+function enableVerboseLogging() {
+  debug("cli", '--verbose flag enabled! Enabling: DEBUG="*,-babel"');
+  debug(
+    "cli",
+    'Tip: Set the DEBUG env variable directly for more control. Example: "DEBUG=astro:*,vite:* astro build".'
+  );
+}
+export {
+  debug,
+  enableVerboseLogging,
+  levels,
+  logger,
+  nodeLogDestination,
+  nodeLogOptions
+};