@stacksjs/logging 0.58.56 → 0.58.58

package/dist/index.js

@@ -1776,7 +1776,7 @@ var init_consola_36c0034f = __esm(() => {
 });
 
 // src/index.ts
-import process2 from "process";
+import process3 from "process";
 
 // /home/runner/work/stacks/stacks/node_modules/consola/dist/index.mjs
 init_consola_36c0034f();
@@ -1786,17 +1786,174 @@ init_utils();
 
 // src/index.ts
 import {ExitCode} from "@stacksjs/types";
+
+// /home/runner/work/stacks/stacks/storage/framework/core/path/src/index.ts
+import process2 from "process";
+
+// /home/runner/work/stacks/stacks/node_modules/pathe/dist/shared/pathe.ff20891b.mjs
+var normalizeWindowsPath = function(input = "") {
+  if (!input) {
+    return input;
+  }
+  return input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE, (r2) => r2.toUpperCase());
+};
+var cwd = function() {
+  if (typeof process !== "undefined" && typeof process.cwd === "function") {
+    return process.cwd().replace(/\\/g, "/");
+  }
+  return "/";
+};
+var normalizeString = function(path, allowAboveRoot) {
+  let res = "";
+  let lastSegmentLength = 0;
+  let lastSlash = -1;
+  let dots = 0;
+  let char = null;
+  for (let index = 0;index <= path.length; ++index) {
+    if (index < path.length) {
+      char = path[index];
+    } else if (char === "/") {
+      break;
+    } else {
+      char = "/";
+    }
+    if (char === "/") {
+      if (lastSlash === index - 1 || dots === 1)
+        ;
+      else if (dots === 2) {
+        if (res.length < 2 || lastSegmentLength !== 2 || res[res.length - 1] !== "." || res[res.length - 2] !== ".") {
+          if (res.length > 2) {
+            const lastSlashIndex = res.lastIndexOf("/");
+            if (lastSlashIndex === -1) {
+              res = "";
+              lastSegmentLength = 0;
+            } else {
+              res = res.slice(0, lastSlashIndex);
+              lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
+            }
+            lastSlash = index;
+            dots = 0;
+            continue;
+          } else if (res.length > 0) {
+            res = "";
+            lastSegmentLength = 0;
+            lastSlash = index;
+            dots = 0;
+            continue;
+          }
+        }
+        if (allowAboveRoot) {
+          res += res.length > 0 ? "/.." : "..";
+          lastSegmentLength = 2;
+        }
+      } else {
+        if (res.length > 0) {
+          res += `/${path.slice(lastSlash + 1, index)}`;
+        } else {
+          res = path.slice(lastSlash + 1, index);
+        }
+        lastSegmentLength = index - lastSlash - 1;
+      }
+      lastSlash = index;
+      dots = 0;
+    } else if (char === "." && dots !== -1) {
+      ++dots;
+    } else {
+      dots = -1;
+    }
+  }
+  return res;
+};
+var _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
+var _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
+var resolve = function(...arguments_) {
+  arguments_ = arguments_.map((argument) => normalizeWindowsPath(argument));
+  let resolvedPath = "";
+  let resolvedAbsolute = false;
+  for (let index = arguments_.length - 1;index >= -1 && !resolvedAbsolute; index--) {
+    const path = index >= 0 ? arguments_[index] : cwd();
+    if (!path || path.length === 0) {
+      continue;
+    }
+    resolvedPath = `${path}/${resolvedPath}`;
+    resolvedAbsolute = isAbsolute(path);
+  }
+  resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute);
+  if (resolvedAbsolute && !isAbsolute(resolvedPath)) {
+    return `/${resolvedPath}`;
+  }
+  return resolvedPath.length > 0 ? resolvedPath : ".";
+};
+var isAbsolute = function(p2) {
+  return _IS_ABSOLUTE_RE.test(p2);
+};
+// /home/runner/work/stacks/stacks/storage/framework/core/path/src/index.ts
+function logsPath(path2) {
+  return projectStoragePath(`logs/${path2 || ""}`);
+}
+function projectPath(filePath = "") {
+  let path2 = process2.cwd();
+  while (path2.includes("storage"))
+    path2 = resolve(path2, "..");
+  return resolve(path2, filePath);
+}
+function projectStoragePath(path2) {
+  return projectPath(`storage/${path2 || ""}`);
+}
+
+// src/index.ts
+async function writeToLogFile(message) {
+  const formattedMessage = `[${new Date().toISOString()}] ${message}\n`;
+  try {
+    const file = Bun.file(logFilePath);
+    const writer = file.writer();
+    const text2 = await file.text();
+    writer.write(`${text2}\n`);
+    writer.write(`${formattedMessage}\n`);
+    await writer.end();
+  } catch (error) {
+    const file = Bun.file(logFilePath);
+    const writer = file.writer();
+    writer.write(`${formattedMessage}\n`);
+    await writer.end();
+  }
+}
 function dump(...args) {
-  return log.debug(args);
+  args.forEach((arg) => log.debug(arg));
 }
 function dd(...args) {
   args.forEach((arg) => log.debug(arg));
-  process2.exit(ExitCode.FatalError);
+  process3.exit(ExitCode.FatalError);
 }
 var logger = consola;
-var log = consola;
+var logFilePath = logsPath("console.log");
+var log = {
+  info: async (...arg) => {
+    consola.info(...arg);
+    await writeToLogFile(`INFO: ${arg}`);
+  },
+  success: async (msg) => {
+    consola.success(msg);
+    await writeToLogFile(`SUCCESS: ${msg}`);
+  },
+  error: async (err, options) => {
+    handleError(err, options);
+    await writeToLogFile(`ERROR: ${err}`);
+  },
+  warn: async (arg) => {
+    consola.warn(arg);
+    await writeToLogFile(`WARN: ${arg}`);
+  },
+  debug: async (arg) => {
+    consola.debug(arg);
+    await writeToLogFile(`DEBUG: ${arg}`);
+  },
+  dump,
+  dd
+};
 export {
   logger,
+  logFilePath,
   log,
   dump,
   dd

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stacksjs/logging",
   "type": "module",
-  "version": "0.58.56",
+  "version": "0.58.58",
   "description": "The Stacks logging system.",
   "author": "Chris Breuer",
   "license": "MIT",

package/src/index.ts

@@ -1,22 +1,65 @@
 import process from 'node:process'
 import consola from 'consola'
 import { ExitCode } from '@stacksjs/types'
+import { logsPath } from '@stacksjs/path'
 
 export const logger = consola
-export const log = consola
-// export const log = {
-//   info: (...args: any[]) => consola.info(...args),
-//   success: (msg: string) => logger.success(msg),
-//   error: (err: string | StacksError, options?: any) => handleError(err, options),
-//   warn: (...args: any[]) => logger.warn(...args),
-//   debug: (...args: any[]) => logger.debug(...args),
-//   prompt:
-//   dump,
-//   dd,
-// }
+
+export const logFilePath = logsPath('console.log')
+
+async function writeToLogFile(message: string) {
+  const formattedMessage = `[${new Date().toISOString()}] ${message}\n`
+  try {
+    const file = Bun.file(logFilePath)
+    const writer = file.writer()
+    const text = await file.text()
+    writer.write(`${text}\n`)
+    writer.write(`${formattedMessage}\n`)
+    await writer.end()
+  }
+  catch (error) {
+    // Assuming the error is due to the file not existing
+    // Create the file and then write the message
+    const file = Bun.file(logFilePath) // Use the create option
+    const writer = file.writer()
+    writer.write(`${formattedMessage}\n`)
+    await writer.end()
+  }
+}
+
+export const log = {
+  info: async (...arg: any) => {
+    consola.info(...arg)
+    await writeToLogFile(`INFO: ${arg}`)
+  },
+
+  success: async (msg: string) => {
+    consola.success(msg)
+    await writeToLogFile(`SUCCESS: ${msg}`)
+  },
+
+  error: async (err: string, options?: any) => {
+    handleError(err, options) // Assuming handleError logs the error
+    await writeToLogFile(`ERROR: ${err}`)
+  },
+
+  warn: async (arg: string) => {
+    consola.warn(arg)
+    await writeToLogFile(`WARN: ${arg}`)
+  },
+
+  debug: async (arg: string) => {
+    consola.debug(arg)
+    await writeToLogFile(`DEBUG: ${arg}`)
+  },
+
+  // prompt,
+  dump,
+  dd,
+}
 
 export function dump(...args: any[]) {
-  return log.debug(args)
+  args.forEach(arg => log.debug(arg))
 }
 
 export function dd(...args: any[]) {